Context Navigation

Back to Ticket #463

Ticket #463: banktransfer_validation.php

File banktransfer_validation.php, 130.5 KB (added by Mediagenie System, 11 years ago)
Die Klasse

Line
1	<?php
2	/* -----------------------------------------------------------------------------------------
3	$Id: banktransfer_validation.php 4434 2013-02-11 09:05:02Z dokuman $
4
5	modified eCommerce Shopsoftware
6	http://www.modified-shop.org
7
8	Copyright (c) 2009 - 2013 [www.modified-shop.org]
9	-----------------------------------------------------------------------------------------
10	based on:
11	(c) 2000-2001 The Exchange Project (earlier name of osCommerce)
12	(c) 2002-2003 osCommerce(banktransfer_validation.php,v 1.17 2003/02/18 18:33:15); www.oscommerce.com
13	(c) 2003 nextcommerce (banktransfer_validation.php,v 1.4 2003/08/1); www.nextcommerce.org
14	(c) 2004 - 2006 fmce.de
15	(c) 2004 - 2006 discus24.de
16	(c) 2006 xt:Commerce
17	(c) 2004 - 2010 Frank Maroke
18	(c) 2010-2011 Nico Sommer
19	(c) 2011-2012 Christian Rothe
20
21	Released under the GNU General Public License
22	-----------------------------------------------------------------------------------------
23	Third Party contributions:
24	OSC German Banktransfer v0.85a Autor: Dominik Guder <osc@guder.org>
25	Extensioncode: Marcel Bossert-Schwab <info@opensourcecommerce.de> (mbs)
26	New methods 2005 - 2010: Frank Maroke (FrankM) <info@fmce.de>
27	New methods and bug fixes 2010 - 2013: Christian Rothe <buero@laufstar.de>
28
29	BLZ-Downloadseite der Deutschen Bundesbank:
30	http://www.bundesbank.de/Redaktion/DE/Standardartikel/Kerngeschaeftsfelder/Unbarer_Zahlungsverkehr/bankleitzahlen_download.html
31
32	Aktuelle Beschreibung der Pruefverfahren:
33	http://www.bundesbank.de/Navigation/DE/Kerngeschaeftsfelder/Unbarer_Zahlungsverkehr/Pruefzifferberechnung/pruefzifferberechnung.html
34
35	Stand dieses Klassen-Moduls: 9. Dezember 2013
36
37	Released under the GNU General Public License
38	---------------------------------------------------------------------------------------*/
39
40
41	class AccountCheck {
42
43	/* Folgende Returncodes werden übergeben */
44	/* */
45	/* 0 -> Kontonummer & BLZ OK */
46	/* 1 -> Kontonummer & BLZ passen nicht */
47	/* 2 -> Für diese Kontonummer ist kein Prüfziffernverfahren definiert */
48	/* 3 -> Dieses Prüfziffernverfahren ist noch nicht implementiert */
49	/* 4 -> Diese Kontonummer ist technisch nicht prüfbar */
50	/* 5 -> BLZ nicht gefunden */
51	/* 8 -> Keine BLZ übergeben */
52	/* 9 -> Keine Kontonummer übergeben */
53	/* 10 -> Kein Kontoinhaber übergeben */
54	/* 128 -> interner Fehler, der zeigt, dass eine Methode nicht implementiert ist */
55	/* */
56
57	function __construct() {
58	$this->banktransfer_number = ''; // Enthält nach der Prüfung die geprüfte Kontonummer
59	$this->banktransfer_blz = ''; // Enthält nach der Prüfung die geprüfte BLZ
60	$this->Bankname = ''; // Enthält nach der Prüfung den Namen der Bank bei der Suche nach BLZ
61	$this->PRZ = ''; //Enthält nach der Prüfung die Prüfziffer
62	$this->checkmode = 'classic'; //
63	}
64
65	var $Bankname; // Enthält den Namen der Bank bei der Suche nach BLZ
66	var $PRZ; //Enthält die Prüfziffer
67
68	////
69	// Diese Funktion gibt die Bankinformationen aus der csv-Datei zurück*/
70	function csv_query($blz) {
71	$cdata = -1;
72	$fp = fopen(DIR_WS_INCLUDES . 'data/blz.csv', 'r');
73	while ($data = fgetcsv($fp, 1024, ";")) {
74	if ($data[0] == $blz){
75	$cdata = array ('blz' => $data[0],
76	'bankname' => $data[1],
77	'prz' => $data[2]);
78	}
79	}
80	return $cdata;
81	}
82
83	////
84	// Diese Funktion gibt die Bankinformationen aus der Datenbank zurück*/
85	function db_query($blz) {
86	$blz_query = xtc_db_query("SELECT * from ".TABLE_BANKTRANSFER_BLZ." WHERE blz = '" . xtc_db_input($blz) . "'");
87	if (xtc_db_num_rows($blz_query)){
88	$data = xtc_db_fetch_array ($blz_query);
89	}else
90	$data = -1;
91	return $data;
92	}
93
94	////
95	// Diese Funktion gibt die Bankinformationen aus der Datenbank zurück*/
96	function query($blz) {
97	if (MODULE_PAYMENT_BANKTRANSFER_DATABASE_BLZ == 'true' && defined(MODULE_PAYMENT_BANKTRANSFER_DATABASE_BLZ))
98	$data = $this->db_query($blz);
99	else
100	$data = $this->csv_query($blz);
101	return $data;
102	}
103
104	////
105	// Diese Funktion gibt die Einer einer Zahl zwischen 0 und 99 zurueck.
106	private function OnlyOne($Digit) {
107	return $Digit = $Digit % 10;
108	} /* End of OnlyOne */
109
110	// Diese Funktion berechnet die Quersumme einer Zahl zwischen 0 und 99.
111	private function CrossSum($Digit) {
112	$CrossSum = $Digit;
113	if ($Digit > 9) {
114	$Help1 = substr($Digit,0,1);
115	$Help2 = substr($Digit,1,1);
116	$CrossSum = (int) $Help1 + (int) $Help2;
117	}
118	return $CrossSum;
119	} /* End of CrossSum */
120
121	// Auffüllen der Konto-Nr. mit '0' auf 10 Stellen.
122	public function ExpandAccount($AccountNo) {
123	$AccountNo = str_pad($AccountNo, 10, "0", STR_PAD_LEFT);
124
125	while (strlen($AccountNo) > 10) {
126	$AccountNo = substr($AccountNo, 1);
127	}
128	return $AccountNo;
129	} /* End of ExpandAccount */
130
131	// Erweiterte ExpandAccount fuer Methode C5:
132	// Entfernt die führenden Nullen einer Kontonummer
133	// und gibt den Integer zusammen mit der Laenge zurueck.
134	private function ExpandAccountExtended($AccountNo) {
135	$AccountNoLong = $this->ExpandAccount($AccountNo);
136	$AccountNoShort = ltrim($AccountNoLong, "0");
137	$AccountNoShortLen = strlen($AccountNoShort);
138	$aAccountNo = array(
139	'AccountNoLong' => $AccountNoLong,
140	'AccountNoShort' => $AccountNoShort,
141	'AccountNoShortLen' => $AccountNoShortLen,
142	);
143	return $aAccountNo;
144	} /* End of ExpandAccountExtended */
145
146
147	/* --- Changed FrankM 20061206, 20070822, 20080717, 20100602 --- */
148	/* --- Changed Christian Rothe 20110606 --- */
149	private function Method00($AccountNo, $Significance, $Checkpoint, $Modulator=10, $LeaveCheckpoint=0, $DoNotExpand=0, $ChecksumCalcMethod = '') {
150	$Help = 0;
151	$Method00 = 1;
152
153	// Methoden der Bundesbank C6 und D1 uebergeben die finale Kontonummer, $DoNotExpand = 1.
154	if ($DoNotExpand == 0) {
155	$AccountNo = $this->ExpandAccount($AccountNo);
156	}
157
158	// Pruefziffer ermitteln..
159	$PNumber = substr($AccountNo, $Checkpoint-1, 1);
160
161	// Sonderfall Methoden der Bundesbank C6 und D1, zur Pruefung letzte Stelle entfernen.
162	if ($Checkpoint == 16) {
163	$AccountNo = substr($AccountNo, 0, -1);
164	}
165
166	if ($LeaveCheckpoint == 0) {
167	for ($Run = 0; $Run < strlen($Significance); $Run++) {
168	$Help += $this->CrossSum(substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
169	}
170	// Sonderfall fuer Methode 57
171	}else{
172	$HelpFirst = substr($AccountNo,0,2);
173	$HelpCheckP = substr($AccountNo,($Checkpoint - 1),1);
174	$HelpSecond = substr($AccountNo,3,7);
175	$AccountNo = $HelpFirst . $HelpSecond . $HelpCheckP;
176	for ($Run = 0; $Run < strlen($Significance); $Run++) {
177	$Help += $this->CrossSum(substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
178	}
179	}
180
181	// Sonderfall fuer Methode E0
182	if ($ChecksumCalcMethod == 'E0') {
183	$Help += 7;
184	}
185
186	$Help = $Help % $Modulator;
187
188	if ($ChecksumCalcMethod == 'D7') {
189	$Checksum = $Help;
190	} else {
191	$Checksum = $Modulator - $Help;
192	}
193
194	if ($Checksum == $Modulator) {
195	$Checksum = 0;
196	}
197
198	if ($Checksum == $PNumber) {
199	$Method00 = 0;
200	}
201
202	return $Method00;
203	} /* End of Method00 */
204
205
206	private function Method01($AccountNo, $Significance) {
207	$Help = 0;
208	$Method01 = 1;
209	$AccountNo = $this->ExpandAccount($AccountNo);
210	for ($Run = 0; $Run < strlen($Significance); $Run++) {
211	$Help += substr($AccountNo,$Run,1) * substr($Significance,$Run,1);
212	}
213	$Help = $this->OnlyOne($Help);
214	$Checksum = 10 - $Help;
215
216	if ($Checksum == 10) {
217	$Checksum = 0;
218	}
219	if ($Checksum == substr($AccountNo,-1)) {
220	$Method01 = 0;
221	}
222	return $Method01;
223	} /* End of Method01 */
224
225
226	private function Method02($AccountNo , $Significance, $Modified) {
227	$Help = 0;
228	$Method02 = 1;
229	$AccountNo = $this->ExpandAccount($AccountNo);
230	switch ($Modified) {
231	case FALSE :
232	for ($Run = 0;$Run < strlen($Significance);$Run++) {
233	$Help += substr($AccountNo,$Run,1) * substr($Significance,$Run,1);
234	}
235	break;
236	case TRUE :
237	for ($Run = 0;$Run < strlen($Significance);$Run++) {
238	$Help += substr($AccountNo,$Run,1) * HexDec(substr($Significance,$Run,1));
239	}
240	break;
241	}
242	$Help = $Help % 11;
243	if ($Help == 0) {
244	$Help = 11;
245	}
246	if ($Help <> 1) {
247	$Checksum = 11 - $Help;
248	if ($Checksum == substr($AccountNo,-1)) {
249	$Method02 = 0;
250	}
251	}
252	return $Method02;
253	} /* End of Method02 */
254
255	/* --- Hotfix FrankM 20081208 --- */
256	private function Method06($AccountNo, $Significance, $Modified, $Checkpoint, $Modulator) {
257	$Help = 0;
258	$Method06 = 1;
259	$AccountNo = $this->ExpandAccount($AccountNo);
260	switch ($Modified) {
261	case FALSE :
262	for ($Run = 0; $Run < strlen($Significance);$Run++) {
263	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
264	}
265	break;
266	case TRUE :
267	for ($Run = 0; $Run < strlen($Significance);$Run++) {
268	$Help += (substr($AccountNo,$Run,1) * HexDec(substr($Significance,$Run,1)));
269	}
270	break;
271	}
272	$Help = $Help % $Modulator;
273	$Checksum = $Modulator - $Help;
274	// Bedingung bei Modulator 7
275	/* --- Fix by Christian Rothe 20110327 --- */
276	if ($Help == 0 && $Modulator == 7) {
277	$Checksum = 0;
278	}
279	// Bedingung bei Modulator 11
280	if ($Help < 2 && $Modulator == 11) {
281	$Checksum = 0;
282	}
283	if ($Checksum == substr($AccountNo,$Checkpoint-1,1)) {
284	$Method06 = 0;
285	}
286	return $Method06;
287	} /* End of Method06 */
288
289	private function Method16($AccountNo , $Significance, $Checkpoint) {
290	$Help = 0;
291	$Method16 = 1;
292	$AccountNo = $this->ExpandAccount($AccountNo);
293	for ($Run = 0;$Run < strlen($Significance);$Run++) {
294	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
295	}
296	$Help = $Help % 11;
297	$Checksum = 11 - $Help;
298	if ($Help == 0) {
299	$Checksum = 0;
300	}
301	if ($Checksum == substr($AccountNo,$Checkpoint-1,1)) {
302	$Method16 = 0;
303	}
304	if ($Help == 1) {
305	if ($Checksum == substr($AccountNo,$Checkpoint - 2,1)) {
306	$Method16 = 0;
307	}
308	}
309	return $Method16;
310	} /* End of Method16 */
311
312	private function Method90($AccountNo , $Significance ,$Checkpoint, $Modulator) {
313	$Help = 0;
314	$Method90 = 1;
315	$AccountNo = $this->ExpandAccount($AccountNo);
316	for ($Run = 0;$Run < strlen($Significance);$Run++) {
317	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
318	}
319	$Help = $Help % $Modulator;
320	$Checksum = $Modulator - $Help;
321	if ($Help == 0) {
322	$Checksum = 0;
323	}
324	if ($Checksum == substr($AccountNo,$Checkpoint -1, 1)) {
325	$Method90 = 0;
326	}
327	return $Method90;
328	} /* End of Method90 */
329
330
331	/* ----- Endgueltige Funktionen der einzelnen Berechnungsmethoden. ---- */
332
333	private function Mark00($AccountNo) {
334	$Mark00 = $this->Method00($AccountNo, '212121212', 10);
335	return $Mark00;
336	} /* End of Mark00 */
337
338	private function Mark01($AccountNo) {
339	$Mark01 = $this->Method01($AccountNo, '173173173');
340	return $Mark01;
341	} /* End of Mark01 */
342
343	private function Mark02($AccountNo) {
344	$Mark02 = $this->Method02($AccountNo, '298765432', FALSE);
345	return $Mark02;
346	} /* End of Mark02 */
347
348	private function Mark03($AccountNo) {
349	$Mark03 = $this->Method01($AccountNo, '212121212');
350	return $Mark03;
351	} /* End of Mark03 */
352
353	private function Mark04($AccountNo) {
354	$Mark04 = $this->Method02($AccountNo, '432765432', FALSE);
355	return $Mark04;
356	} /* End of Mark04 */
357
358	private function Mark05($AccountNo) {
359	$Mark05 = $this->Method01($AccountNo, '137137137');
360	return $Mark05;
361	} /* End of Mark05 */
362
363	private function Mark06($AccountNo) {
364	$Mark06 = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
365	return $Mark06;
366	} /* End of Mark06 */
367
368	private function Mark07($AccountNo) {
369	$Mark07 = $this->Method02($AccountNo, 'A98765432', TRUE);
370	return $Mark07;
371	} /* End of Mark07 */
372
373	private function Mark08($AccountNo) {
374	$Mark08 = 1;
375	if ($AccountNo > 60000) {
376	$Mark08 = $this->Method00($AccountNo, '212121212', 10);
377	}
378	return $Mark08;
379	} /* End of Mark08 */
380
381	// Kein Pruefziffernverfahren vorhanden.
382	// Kontonummer ist aktuell bei der Implementierung immer als RICHTIG zu beurteilen.
383	private function Mark09($AccountNo) {
384	$Mark09 = 2;
385	return $Mark09;
386	} /* End of Mark09 */
387
388	private function Mark10($AccountNo) {
389	$Mark10 = $this->Method06($AccountNo, 'A98765432', TRUE, 10, 11);
390	return $Mark10;
391	} /* End of Mark10 */
392
393	private function Mark11($AccountNo) {
394	$Significance = 'A98765432';
395	$Help = 0;
396	$Mark11 = 1;
397	$AccountNo = $this->ExpandAccount($AccountNo);
398	for ($Run = 0;$Run < strlen($Significance);$Run++) {
399	$Help += (substr($AccountNo,$Run,1) * HexDec(substr($Significance,$Run,1)));
400	}
401	$Help = $Help % 11;
402	$Checksum = 11 - $Help;
403	if ($Help == 0) {
404	$Checksum = 0;
405	}
406	if ($Help == 1) {
407	$Checksum = 9;
408	}
409	if ($Checksum == substr($AccountNo,-1)) {
410	$Mark11 = 0;
411	}
412	return $Mark11;
413	} /* End of Mark11 */
414
415	private function Mark12($AccountNo) {
416	$Mark12 = $this->Method01($AccountNo, '731731731');
417	return $Mark12;
418	} /* End of Mark12 */
419
420	private function Mark13($AccountNo) {
421	$Help = $this->Method00($AccountNo, '0121212', 8);
422	if ($Help == 1) {
423	if (Substr($AccountNo,-2) <> '00') {
424	$Help = $this->Method00(substr($this->ExpandAccount($AccountNo), 2) . '00', '0121212', 8);
425	}
426	}
427	$Mark13 = $Help;
428	return $Mark13;
429	} /* End of Mark13 */
430
431	private function Mark14($AccountNo) {
432	$Mark14 = $this->Method02($AccountNo, '000765432', FALSE);
433	return $Mark14;
434	} /* End of Mark14 */
435
436	private function Mark15($AccountNo) {
437	$Mark15 = $this->Method06($AccountNo, '000005432', FALSE, 10, 11);
438	return $Mark15;
439	} /* End of Mark15 */
440
441	private function Mark16($AccountNo) {
442	$Mark16 = $this->Method16($AccountNo, '432765432', 10);
443	return $Mark16;
444	} /* End of Mark16 */
445
446	private function Mark17($AccountNo) {
447	$Significance = '0121212';
448	$Help = 0;
449	$Help2 = 1;
450	$AccountNo = $this->ExpandAccount($AccountNo);
451	for ($Run = 0;$Run < strlen($Significance);$Run++) {
452	$Help += ($this->CrossSum(substr($AccountNo,$Run,1) * substr($Significance,$Run,1)));
453	}
454	$Help = $Help -1;
455	$Checksum = $Help % 11;
456	$Checksum = 10 - $Checksum;
457	if ($Checksum == 10) {
458	$Checksum = 0;
459	}
460	if ($Checksum == substr($AccountNo,7,1)) {
461	$Help2 = 0;
462	}
463	$Mark17 = $Help2;
464	return $Mark17;
465	} /* End of Mark17 */
466
467	private function Mark18($AccountNo) {
468	$Mark18 = $this->Method01($AccountNo, '317931793');
469	return $Mark18;
470	} /* End of Mark18 */
471
472	private function Mark19($AccountNo) {
473	$Mark19 = $this->Method06($AccountNo, '198765432', FALSE, 10, 11);
474	return $Mark19;
475	} /* End of Mark19 */
476
477	private function Mark20($AccountNo) {
478	$Mark20 = $this->Method06($AccountNo, '398765432', FALSE, 10, 11);
479
480	return $Mark20;
481	} /* End of Mark20 */
482
483	// --- Fix FrankM 20080717 ---
484	private function Mark21($AccountNo) {
485	// Initialisierung
486	$Significance = '212121212';
487	$Help = 0;
488	$Mark21 = 1;
489	// Kontonummer auf zehn Stellen auffuellen.
490	$AccountNo = $this->ExpandAccount($AccountNo);
491	// Quersumme aus Produkten bilden.
492	for ($Run = 0;$Run < strlen($Significance);$Run++) {
493	$Help += $this->CrossSum(substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
494	}
495	// Daraus erneut Quersumme bilden bis diese einstellig ist.
496	while (strlen($Help) > 1){
497	$Help = $this->CrossSum($Help);
498	}
499	// Quersumme von 10 subtrahieren = Pruefziffer
500	$Checksum = 10 - $Help;
501	if ($Checksum == substr($AccountNo,-1)) {
502	$Mark21 = 0;
503	}
504	return $Mark21;
505	} /* End of Mark21 */
506
507	private function Mark22($AccountNo) {
508	$Significance = '313131313';
509	$Help = 0;
510	$Mark22 = 1;
511	$AccountNo = $this->ExpandAccount($AccountNo);
512	for ($Run = 0;$Run < strlen($Significance);$Run++) {
513	$Zwischenwert = (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
514	$Help += $this->OnlyOne($Zwischenwert);
515	}
516	$Checksum = ceil($Help/10)*10 - $Help;
517	if ($Checksum == substr($AccountNo,-1)) {
518	$Mark22 = 0;
519	}
520	return $Mark22;
521	} /* End of Mark22 */
522
523	private function Mark23($AccountNo) {
524	$Mark23 = $this->Method16($AccountNo, '765432', 7);
525	return $Mark23;
526	} /* End of Mark23 */
527
528	private function Mark24($AccountNo) {
529	$Significance = '123123123';
530	$Help = 0;
531	$Mark24 = 1;
532	switch (substr($AccountNo,0,1)) {
533	case 3 :
534	case 4 :
535	case 5 :
536	case 6 :
537	// deaktiviert, da die Postbank diese Definition nicht einhaelt.
538	//$AccountNo = Substr($AccountNo,1);
539	break;
540	case 9 :
541	// $AccountNo = SubStr($AccountNo,3);
542	break;
543	}
544	while (substr($AccountNo,0,1)==0){
545	$AccountNo = substr($AccountNo,1);
546	}
547
548	for ($Run = 0;$Run < strlen($AccountNo)-1;$Run++ ) {
549	$ZwischenHilf = substr($AccountNo,$Run,1) * substr($Significance,$Run,1) + substr($Significance,$Run,1);
550	$Help += $ZwischenHilf % 11;
551	}
552
553	$Checksum = $this->OnlyOne($Help);
554
555	if ($Checksum == substr($AccountNo,-1)) {
556	$Mark24 = 0;
557	}
558	return $Mark24;
559	} /* End of Mark24 */
560
561	private function Mark25($AccountNo) {
562	$Significance = '098765432';
563	$Falsch = FALSE;
564	$Help = 0;
565	$AccountNo = $this->ExpandAccount($AccountNo);
566	for ($Run = 0;$Run < strlen($Significance);$Run++) {
567	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
568	}
569	$Help = $Help % 11;
570	$Checksum = 11 - $Help;
571	if ($Checksum == 11) {
572	$Checksum = 0;
573	}
574	if ($Checksum == 10) {
575	$Checksum = 0;
576	if ((substr($AccountNo,1,1) <> '8') and (substr($AccountNo,1,1) <> '9')) {
577	$Mark25 = 1;
578	$Falsch = TRUE;
579	}
580	}
581	if ($Falsch == FALSE) {
582	if ($Checksum == substr($AccountNo,-1)) {
583	$Mark25 = 0;
584	} else {
585	$Mark25 = 1;
586	}
587	}
588	return $Mark25;
589	} /* End of Mark25 */
590
591	private function Mark26($AccountNo) {
592	$AccountNo = $this->ExpandAccount($AccountNo);
593	if (Substr($AccountNo,-2) == '00') {
594	$AccountNo = Substr($AccountNo,2) . '00';
595	}
596	$Mark26 = $this->Method06($AccountNo,'2345672',FALSE,8,11);
597	return $Mark26;
598	} /* End of Mark26 */
599
600	private function Mark27($AccountNo) {
601	if ((int)$AccountNo <= 999999999.) {
602	$Mark27 = $this->Method00($AccountNo, '212121212', 10);
603	} else {
604	$Mark27 = $this->Mark29($AccountNo);
605	}
606	return $Mark27;
607	} /* End of Mark27 */
608
609	private function Mark28($AccountNo) {
610	$Mark28 = $this->Method06($AccountNo, '8765432', FALSE, 8, 11);
611	return $Mark28;
612	} /* End of Mark28 */
613
614	/* --- Hotfix FrankM 20081208 --- */
615	/* --- Fix Christian Rothe 20110606 --- */
616	private function Mark29($AccountNo) {
617	$Transform = '143214321';
618	$AccountNo = $this->ExpandAccount($AccountNo);
619	$Help = 0;
620	for ($Run = 0;$Run < strlen($Transform);$Run++) {
621	$ToAdd = 0;
622	switch (substr($Transform,$Run,1)) {
623	case '1' :
624	switch (substr($AccountNo,$Run,1)) {
625	Case '0' :
626	$ToAdd = 0;
627	break;
628	Case '1' :
629	$ToAdd = 1;
630	break;
631	Case '2' :
632	$ToAdd = 5;
633	break;
634	Case '3' :
635	$ToAdd = 9;
636	break;
637	Case '4' :
638	$ToAdd = 3;
639	break;
640	Case '5' :
641	$ToAdd = 7;
642	break;
643	Case '6' :
644	$ToAdd = 4;
645	break;
646	Case '7' :
647	$ToAdd = 8;
648	break;
649	Case '8' :
650	$ToAdd = 2;
651	break;
652	Case '9' :
653	$ToAdd = 6;
654	break;
655	}
656	break;
657	case '2' :
658	switch (substr($AccountNo,$Run,1)) {
659	Case '0' :
660	$ToAdd = 0;
661	break;
662	Case '1' :
663	$ToAdd = 1;
664	break;
665	Case '2' :
666	$ToAdd = 7;
667	break;
668	Case '3' :
669	$ToAdd = 6;
670	break;
671	Case '4' :
672	$ToAdd = 9;
673	break;
674	Case '5' :
675	$ToAdd = 8;
676	break;
677	Case '6' :
678	$ToAdd = 3;
679	break;
680	Case '7' :
681	$ToAdd = 2;
682	break;
683	Case '8' :
684	$ToAdd = 5;
685	break;
686	Case '9' :
687	$ToAdd = 4;
688	break;
689	}
690	break;
691	case '3' :
692	switch (substr($AccountNo,$Run,1)) {
693	Case '0' :
694	$ToAdd = 0;
695	break;
696	Case '1' :
697	$ToAdd = 1;
698	break;
699	Case '2' :
700	$ToAdd = 8;
701	break;
702	Case '3' :
703	$ToAdd = 4;
704	break;
705	Case '4' :
706	$ToAdd = 6;
707	break;
708	Case '5' :
709	$ToAdd = 2;
710	break;
711	Case '6' :
712	$ToAdd = 9;
713	break;
714	Case '7' :
715	$ToAdd = 5;
716	break;
717	Case '8' :
718	$ToAdd = 7;
719	break;
720	Case '9' :
721	$ToAdd = 3;
722	break;
723	}
724	break;
725	case '4' :
726	switch (substr($AccountNo,$Run,1)) {
727	Case '0' :
728	$ToAdd = 0;
729	break;
730	Case '1' :
731	$ToAdd = 1;
732	break;
733	Case '2' :
734	$ToAdd = 2;
735	break;
736	Case '3' :
737	$ToAdd = 3;
738	break;
739	Case '4' :
740	$ToAdd = 4;
741	break;
742	Case '5' :
743	$ToAdd = 5;
744	break;
745	Case '6' :
746	$ToAdd = 6;
747	break;
748	Case '7' :
749	$ToAdd = 7;
750	break;
751	Case '8' :
752	$ToAdd = 8;
753	break;
754	Case '9' :
755	$ToAdd = 9;
756	break;
757	}
758	break;
759	}
760	$Help += $ToAdd;
761	}
762	$Help = $this->OnlyOne($Help);
763	$Checksum = 10 - $Help;
764	// Fix by Christian Rothe 20110606: Nur 1 Stelle beruecksichtigen
765	// Ist die Pruefsumme = 10, ist die Pruefziffer = 0
766	$Checksum = $this->OnlyOne($Checksum);
767	if ($Checksum == substr($AccountNo,-1)) {
768	$Mark29 = 0;
769	} else {
770	$Mark29 = 1;
771	}
772	return $Mark29;
773	}
774
775	private function Mark30($AccountNo) {
776	$Significance = '200001212';
777	$Help = 0;
778	$Mark30 = 1;
779	$AccountNo = $this->ExpandAccount($AccountNo);
780	for ($Run = 0;$Run < strlen($Significance);$Run++){
781	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
782	}
783	$Help = $this->OnlyOne($Help);
784	$Checksum = 10 - $Help;
785	if ($Checksum == 10) {
786	$Checksum = 0;
787	}
788	if ($Checksum == substr($AccountNo,-1)) {
789	$Mark30 = 0;
790	}
791	return $Mark30;
792	} /* End of Mark30 */
793
794	private function Mark31($AccountNo) {
795	$Significance = '123456789';
796	$Help = 0;
797	$Mark31 = 1;
798	$AccountNo = $this->ExpandAccount($AccountNo);
799	for ($Run = 0;$Run < strlen($Significance);$Run++){
800	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
801	}
802	$Checksum = $Help % 11;
803	if($Checksum == substr($AccountNo,-1)) {
804	$Mark31 = 0;
805	}
806	return $Mark31;
807	} /* End of Mark31 */
808
809	private function Mark32($AccountNo) {
810	$Mark32 = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
811	return $Mark32;
812	} /* End of Mark32 */
813
814	private function Mark33($AccountNo) {
815	$Mark33 = $this->Method06($AccountNo, '000065432', FALSE, 10, 11);
816	return $Mark33;
817	} /* End of Mark33 */
818
819	private function Mark34($AccountNo) {
820	$Mark34 = $this->Method06($AccountNo, '79A5842', TRUE, 8, 11);
821	return $Mark34;
822	} /* End of Mark34 */
823
824	private function Mark35($AccountNo) {
825	$Mark35 = 3;
826	return $Mark35;
827	} /* End of Mark35 */
828
829	private function Mark36($AccountNo) {
830	$Mark36 = $this->Method06($AccountNo, '000005842', FALSE, 10, 11);
831	return $Mark36;
832	} /* End of Mark36 */
833
834	private function Mark37($AccountNo) {
835	$Mark37 = $this->Method06($AccountNo, '0000A5842', TRUE, 10, 11);
836	return $Mark37;
837	} /* End of Mark37 */
838
839	private function Mark38($AccountNo) {
840	$Mark38 = $this->Method06($AccountNo, '0009A5842', TRUE, 10, 11);
841	return $Mark38;
842	} /* End of Mark38 */
843
844	private function Mark39($AccountNo) {
845	$Mark39 = $this->Method06($AccountNo, '0079A5842', TRUE, 10, 11);
846	return $Mark39;
847	} /* End of Mark39 */
848
849	private function Mark40($AccountNo) {
850	$Mark40 = $this->Method06($AccountNo, '6379A5842', TRUE, 10, 11);
851	return $Mark40;
852	} /* End of Mark40 */
853
854	private function Mark41($AccountNo) {
855	$AccountNo = $this->ExpandAccount($AccountNo);
856	if (substr($AccountNo,3,1) == '9') {
857	$AccountNo = '000'. substr($AccountNo,3);
858	}
859	$Mark41 = $this->Method00($AccountNo,'212121212',10);
860	return $Mark41;
861	} /* End of Mark41 */
862
863	private function Mark42($AccountNo) {
864	$Mark42 = $this->Method06($AccountNo, '098765432', FALSE, 10, 11);
865	return $Mark42;
866	} /* End of Mark42 */
867
868	private function Mark43($AccountNo) {
869	$Significance = '987654321';
870	$Help = 0;
871	$Mark43 = 1;
872	$AccountNo = $this->ExpandAccount($AccountNo);
873	for ($Run = 0;$Run < strlen($Significance);$Run++) {
874	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
875	}
876	$Help = $Help % 10;
877	$Checksum = 10 - $Help;
878	if ($Checksum == 10) {
879	$Checksum = 0;
880	}
881	if ($Checksum == substr($AccountNo,-1)) {
882	$Mark43 = 0;
883	}
884	return $Mark43;
885	} /* End of Mark43 */
886
887	private function Mark44($AccountNo) {
888	$Mark44 = $this->Method06($AccountNo, '0000A5842', TRUE, 10, 11);
889	return $Mark44;
890	} /* End of Mark44 */
891
892	private function Mark45($AccountNo) {
893	if (substr($AccountNo,0,1)=='0' or substr($AccountNo,4,1)=='1'){
894	$Mark45 = 2;
895	} else {
896	$Mark45 = $this->Method00($AccountNo, '212121212', 10);
897	}
898	return $Mark45;
899	} /* End of Mark45 */
900
901	private function Mark46($AccountNo) {
902	$Mark46 = $this->Method06($AccountNo, '0065432', FALSE, 8, 11);
903	return $Mark46;
904	} /* End of Mark46 */
905
906	private function Mark47($AccountNo) {
907	$Mark47 = $this->Method06($AccountNo, '00065432', FALSE, 9, 11);
908	return $Mark47;
909	} /* End of Mark47 */
910
911	private function Mark48($AccountNo) {
912	$Mark48 = $this->Method06($AccountNo, '00765432', FALSE, 9, 11);
913	return $Mark48;
914	} /* End of Mark48 */
915
916	private function Mark49($AccountNo) {
917	$Mark49=$this->Mark00($AccountNo);
918	if ($Mark49 == 0)
919	return $Mark49;
920	$Mark49=$this->Mark01($AccountNo);
921	return $Mark49;
922	} /* End of Mark49 */
923
924	private function Mark50($AccountNo) {
925	$Help = $this->Method06($AccountNo, '765432', FALSE, 7, 11);
926	if ($Help == 1) {
927	if (strlen($AccountNo) < 7) {
928	$Help = $this->Method06($AccountNo . '000', '765432', FALSE, 7, 11);
929	}
930	}
931	$Mark50 = $Help;
932	return $Mark50;
933	} /* End of Mark50 */
934
935
936	/* --- Hotfix FrankM 20081208 --- */
937	/* --- Changed Christian Rothe 20130603 --- */
938	private function Mark51($AccountNo) {
939	$AccountNo = $this->ExpandAccount($AccountNo);
940	// Normale Berechnung, keine Sachkonten
941	if (substr($AccountNo, 2, 1) != '9') {
942	// Methode A: Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7
943	$Help = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
944	if ($Help == 1) {
945	// Methode B: Modulus 11, Gewichtung 2, 3, 4, 5, 6 (= Mark33)
946	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 11);
947	if ($Help == 1) {
948	// Methode C: Modulus 10, Gewichtung 2, 1, 2, 1, 2, 1
949	$Help = $this->Method00($AccountNo,'000121212',10);
950	if ($Help == 1) {
951	// 10. Stelle 7, 8 oder 9 = ungueltig
952	switch (substr($AccountNo, -1)) {
953	case '7' :
954	case '8' :
955	case '9' :
956	$Help = 1;
957	break;
958	default :
959	// Methode D: Modulus 7, Gewichtung 2, 3, 4, 5, 6
960	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 7);
961	break;
962	}
963	}
964	}
965	}
966	} else {
967	// Ausnahme fuer Sachkonten, 3. Stelle der Kontonummer = 9
968	// Variante 1 zur Ausnahme, Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7, 8
969	$Help = $this->Method06($AccountNo, '008765432', FALSE, 10, 11);
970	if ($Help == 1 ){
971	// Variante 2 zur Ausnahme, Modulus 11, Gewichtung 2, 3, 4, 5, 6, 7, 8, 9, 10
972	$Help = $this->Method06($AccountNo, 'A98765432', TRUE, 10, 11);
973	}
974	}
975	return $Help;
976	} /* End of Mark51 */
977
978	private function Mark52($AccountNo,$BLZ ) {
979	$Significance = '4216379A5842';
980	if ((strlen($AccountNo) == 10) && (substr($AccountNo,0,1) == '9')){
981	$Correct = $this->Mark20($AccountNo);
982
983	} else {
984	$Help = 0;
985	$Rest = 0;
986	$AltKonto = substr($BLZ,-4).substr($AccountNo,0,2);
987
988	$AccountNo = Substr($AccountNo,2);
989	while (substr($AccountNo,0,1) == '0') {
990	$AccountNo = Substr($AccountNo,1);
991	}
992	$AltKonto = $AltKonto . $AccountNo;
993
994	$Checksum = substr($AltKonto,5,1);
995
996	$AltKonto = substr($AltKonto,0,5).'0'.substr($AltKonto,6);
997
998	$Laenge = strlen($AltKonto);
999
1000	$Significance=substr($Significance,(12 - $Laenge));
1001	for ($Run = 0; $Run < $Laenge;$Run++) {
1002	$Help += substr($AltKonto,$Run,1) * HexDec(substr($Significance,$Run,1));
1003	}
1004	$Rest = $Help % 11;
1005	$Gewicht = HexDec(substr($Significance,5,1));
1006
1007	$PZ = -1;
1008	$Help2 = $Rest + ($PZ * $Gewicht);
1009	while ($Help2 % 11 <>10) { //franky_n
1010	$PZ++;
1011	$Help2 = $Rest + ($PZ * $Gewicht);
1012	if ($PZ == 9) {
1013	break;
1014	}
1015	} //franky_n
1016	if ($Help2 % 11 == 10) {
1017	if ($PZ == $Checksum) {
1018	$Correct = 0;
1019	} else {
1020	$Correct = 1;
1021	}
1022	} else {
1023	$Correct = 1;
1024	}
1025	}
1026	return $Correct;
1027	} /* End of Mark52 */
1028
1029	private function Mark53($AccountNo,$BLZ ) {
1030	$Significance = '4216379A5842';
1031	if (strlen($AccountNo) == 10) {
1032	if (substr($AccountNo,0,1) == '9') {
1033	$Correct = $this->Mark20($AccountNo);
1034	}
1035	} else {
1036	$Help = 0;
1037	$Rest = 0;
1038
1039	$AltKonto = substr($BLZ,-4,2) . substr($AccountNo,1,1) . substr($BLZ,-1). substr($AccountNo,0,1) . substr($AccountNo,2,1);
1040
1041	$AccountNo = Substr($AccountNo,3);
1042
1043	while (substr($AccountNo,0,1) == '0') {
1044	$AccountNo = Substr($AccountNo,1);
1045	}
1046
1047	$AltKonto = $AltKonto . $AccountNo;
1048
1049	while (strlen($AltKonto) < 12){
1050	$AltKonto = "0" . $AltKonto;
1051	}
1052
1053	$Checksum = substr($AltKonto, 5, 1);
1054	$AltKonto = substr($AltKonto, 0, 5) . '0' . substr($AltKonto, 6);
1055	$Laenge = strlen($AltKonto);
1056
1057	for ($Run = 0; $Run < $Laenge;$Run++) {
1058	$Help += substr($AltKonto, $Run, 1) * HexDec(substr($Significance, $Run, 1));
1059	}
1060
1061	$Rest = $Help % 11;
1062
1063	$Gewicht = HexDec(substr($Significance,5, 1));
1064	$PZ = -1;
1065	$Help2 = $Rest + ($PZ * $Gewicht);
1066	while ($Help2 % 11 <> 10 or $PZ > 9) { //franky_n
1067	$PZ++;
1068	$Help2 = $Rest + ($PZ * $Gewicht);
1069	} //franky_n
1070
1071	if ($Help2 % 11 == 10) {
1072	if ($PZ == $Checksum) {
1073	$Correct = 0;
1074	} else {
1075	$Correct = 1;
1076	}
1077	} else {
1078	$Correct = 1;
1079	}
1080	}
1081	return $Correct;
1082	} /* End of Mark53 */
1083
1084	private function Mark54($AccountNo) {
1085	$Mark54 = 3;
1086	return $Mark54;
1087	} /* End of Mark54 */
1088
1089	private function Mark55($AccountNo) {
1090	$Mark55 = $this->Method06($AccountNo, '878765432', FALSE, 10, 11);
1091	return $Mark55;
1092	} /* End of Mark55 */
1093
1094	private function Mark56($AccountNo) {
1095	$Significance = '432765432';
1096	$Mark56 = 1;
1097	$Help = 0;
1098	$Correct = 0;
1099	$AccountNo = $this->ExpandAccount($AccountNo);
1100	for ($Run = 0;$Run < strlen($Significance);$Run++) {
1101	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1102	}
1103	$Help = $Help % 11;
1104	$Help = 11 - $Help;
1105	$Checksum = $Help;
1106	switch (substr($AccountNo,1,1)) {
1107	case '9' :
1108	if ($Help == 11) {
1109	$Checksum = 8;
1110	}
1111	if ($Help == 10) {
1112	$Checksum = 7;
1113	}
1114	default :
1115	if ($Help == 11) {
1116	$Correct = 1;
1117	}
1118	if ($Help == 10) {
1119	$Correct = 1;
1120	}
1121	}
1122	if ($Correct == 0) {
1123	if ($Checksum == substr($AccountNo,-1)) {
1124	$Mark56 = 0;
1125	}
1126	}
1127	return $Mark56;
1128	} /* End of Mark56 */
1129
1130	/* Alte Methode 57 - ungueltig.
1131	private function Mark57($AccountNo) {
1132	$Correct = 1;
1133
1134	$AccountNo = $this->ExpandAccount($AccountNo);
1135
1136	$help = substr($AccountNo,0,2);
1137
1138	switch (true){
1139	case ($help <= 50):
1140	case ($help == 91):
1141	case ($help >= 96 && $help <= 99):
1142	return 0;
1143	break;
1144	default:
1145	}
1146
1147	if (preg_match("/[87]{6}/", $AccountNo)) {
1148	return 0;
1149	}
1150
1151	$Mark57 = $this->Method00($AccountNo, '121212121', 10);
1152	return $Mark57;
1153
1154	}
1155	*/
1156
1157	/* --- Neue Methode 57 --- */
1158	/* --- Changed FrankM 20061206, 20070822 --- */
1159	/* --- Changed Christian Rothe 20130909 --- */
1160	private function Mark57($AccountNo) {
1161
1162	// Auffuellen mit Nullen auf 10 Stellen.
1163	$AccountNo = $this->ExpandAccount($AccountNo);
1164
1165	// Pruefstellen zum ermitteln der Varianten.
1166	$help01 = substr($AccountNo,0,2);
1167
1168	// Genutzte Berechnungsvariante ermitteln.
1169	switch (true){
1170	case ($help01 == 51):
1171	case ($help01 == 55):
1172	case ($help01 == 61):
1173	case ($help01 >= 64 && $help01 <= 66):
1174	case ($help01 == 70):
1175	case ($help01 >= 73 && $help01 <= 82):
1176	case ($help01 == 88):
1177	case ($help01 >= 94 && $help01 <= 95):
1178	// Variante 1: Modulus 10, Gewichtung 1,2,1,2,1,2,1,2,1, Pruefziffer Stelle 10.
1179	$PResult = $this->Method00($AccountNo, '121212121', 10);
1180	// Ausnahme: Wenn die ersten 6 Stellen 777777 oder 888888 dann richtig.
1181	$help02 = substr($AccountNo,0,6);
1182	if ($help02 == 777777) {
1183	$PResult = 0;
1184	}
1185	if ($help02 == 888888) {
1186	$PResult = 0;
1187	}
1188	break;
1189	case ($help01 >= 32 && $help01 <= 39):
1190	case ($help01 >= 41 && $help01 <= 49):
1191	case ($help01 >= 52 && $help01 <= 54):
1192	case ($help01 >= 56 && $help01 <= 60):
1193	case ($help01 >= 62 && $help01 <= 63):
1194	case ($help01 >= 67 && $help01 <= 69):
1195	case ($help01 >= 71 && $help01 <= 72):
1196	case ($help01 >= 83 && $help01 <= 87):
1197	case ($help01 >= 89 && $help01 <= 90):
1198	case ($help01 >= 92 && $help01 <= 93):
1199	case ($help01 >= 96 && $help01 <= 98):
1200	// Variante 2: Modulus 10, Gewichtung 1,2,1,2,1,2,1,2,1, Pruefziffer Stelle 3,
1201	// Pruefziffer bei der Berechnung auslassen.
1202	$PResult = $this->Method00($AccountNo, '121212121', 3, 10, -1);
1203	break;
1204	case ($help01 == 40):
1205	case ($help01 == 50):
1206	case ($help01 == 91):
1207	case ($help01 == 99):
1208	// Variante 3: Methode 09 (Keine Berechnung).
1209	$PResult = $this->Mark09($AccountNo);
1210	break;
1211	case ($help01 >= 01 && $help01 <= 31):
1212	// Variante 4: Dritte und vierte Stelle zwischen 01 und 12
1213	// -UND- siebte bis neunte Stelle kleiner 500.
1214	$help03 = substr($AccountNo,2,2);
1215	$help04 = substr($AccountNo,6,3);
1216	$PResult = 1;
1217	if ($help03 >= 01 && $help03 <= 12) {
1218	if ($help04 < 500) {
1219	$PResult = 0;
1220	}
1221	}
1222	// Ausnahme: Diese Kontonummer ist als richtig zu bewerten.
1223	if ((string)$AccountNo == '0185125434') {
1224	$PResult = 0;
1225	}
1226	break;
1227	default:
1228	// Kontonummern die mit 00 beginnen sind falsch.
1229	$PResult = 1;
1230	break;
1231	}
1232
1233	// Der Ordnung halber...
1234	$Mark57 = $PResult;
1235	return $Mark57;
1236
1237	} /* End of Mark57 */
1238
1239	private function Mark58($AccountNo) {
1240	$Mark58 = $this->Method02($AccountNo, '000065432', FALSE);
1241	return $Mark58;
1242	} /* End of Mark58 */
1243
1244	private function Mark59($AccountNo) {
1245	$Mark59 = 1;
1246	if (strlen($AccountNo) > 8) {
1247	$Mark59 = $this->Method00($AccountNo, '212121212', 10);
1248	}
1249	return $Mark59;
1250	} /* End of Mark59 */
1251
1252	private function Mark60($AccountNo) {
1253	$Mark60 = $this->Method00($AccountNo, '002121212', 10);
1254	return $Mark60;
1255	} /* End of Mark60 */
1256
1257	private function Mark61($AccountNo) {
1258	$AccountNo = $this->ExpandAccount($AccountNo);
1259	if (substr($AccountNo,8,1) == '8') {
1260	$Mark61 = $this->Method00($AccountNo, '2121212012', 8);
1261	} else {
1262	$Mark61 = $this->Method00($AccountNo, '2121212', 8);
1263	}
1264	return $Mark61;
1265	} /* End of Mark61 */
1266
1267	private function Mark62($AccountNo) {
1268	$Mark62 = $this->Method00($AccountNo,'0021212',8);
1269	return $Mark62;
1270	} /* End of Mark62 */
1271
1272	private function Mark63($AccountNo) {
1273	$Help = $this->Method00($AccountNo,'0121212',8);
1274	if ($Help == 1) {
1275	$Help = $this->Method00($AccountNo,'000121212',10);
1276	}
1277	$Mark63 = $Help;
1278	return $Mark63;
1279	} /* End of Mark63 */
1280
1281	private function Mark64($AccountNo) {
1282	$Mark64 = $this->Method06($AccountNo, '9A5842', TRUE, 7, 11);
1283	return $Mark64;
1284	} /* End of Mark64 */
1285
1286	private function Mark65($AccountNo) {
1287	$AccountNo = $this->ExpandAccount($AccountNo);
1288	if (substr($AccountNo,8,1) == '9') {
1289	$Mark65 = $this->Method00($AccountNo, '2121212012', 8);
1290	} else {
1291	$Mark65 = $this->Method00($AccountNo, '2121212', 8);
1292	}
1293	return $Mark65;
1294	} /* End of Mark65 */
1295
1296	/* --- Changed Christian Rothe 20140303 --- */
1297	private function Mark66($AccountNo) {
1298	$AccountNo = $this->ExpandAccount($AccountNo);
1299	if (substr($AccountNo,1,1) == '9') {
1300	$Mark66 = $this->Mark09($AccountNo);
1301	} else {
1302	$Significance = '070065432';
1303	$Help = 0;
1304	$Mark66 = 1;
1305	for ($Run = 0;$Run < strlen($Significance);$Run++) {
1306	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1307	}
1308	$Help = $Help % 11;
1309	$Checksum = 11 - $Help;
1310	if ($Help == 0) {
1311	$Checksum = 1;
1312	}
1313	if ($Help == 1) {
1314	$Checksum = 0;
1315	}
1316	if ($Checksum == substr($AccountNo,-1)) {
1317	$Mark66 = 0;
1318	}
1319	}
1320	return $Mark66;
1321	} /* End of Mark66 */
1322
1323	private function Mark67($AccountNo) {
1324	$Mark67 = $this->Method00($AccountNo, '2121212', 8);
1325	return $Mark67;
1326	} /* End of Mark67 */
1327
1328	private function Mark68($AccountNo) {
1329	$Correct = 0;
1330	$Significance = '212121212';
1331	if (strlen($AccountNo) == 9) {
1332	if (substr($AccountNo,1,1) == '4') {
1333	$Correct = 4;
1334	}
1335	}
1336	if (strlen($AccountNo) == 10) {
1337	$Significance = '000121212';
1338	}
1339	if ($Correct == 0) {
1340	$Correct = $this->Method00($AccountNo,$Significance,10);
1341	if ($Correct == 1) {
1342	$Correct = $this->Method00($AccountNo,'210021212',10);
1343	}
1344	}
1345	$Mark68 = $Correct;
1346	return $Mark68;
1347	} /* End of Mark68 */
1348
1349	private function Mark69($AccountNo) {
1350	$AccountNo = $this->ExpandAccount($AccountNo);
1351	$Correct = 0;
1352	if (Substr($AccountNo,0,2) == '93') {
1353	$Correct = 2;
1354	}
1355	if ($Correct == 0) {
1356	$Correct = $this->Mark28($AccountNo);
1357	if ($Correct == 1) {
1358	$Correct = $this->Mark29($AccountNo);
1359	} elseif (Substr($AccountNo,0,2) == '97'){
1360	$Correct = $this->Mark29($AccountNo);
1361	}
1362	}
1363	$Mark69 = $Correct;
1364	return $Mark69;
1365	} /* End of Mark69 */
1366
1367	private function Mark70($AccountNo) {
1368	$AccountNo = $this->ExpandAccount($AccountNo);
1369	if (substr($AccountNo,3,1) == '5'){
1370	$Mark70 = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
1371	} elseif (Substr($AccountNo,3,2) == '69') {
1372	$Mark70 = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
1373	} else {
1374	$Mark70 = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
1375	}
1376	return $Mark70;
1377	} /* End of Mark70 */
1378
1379	private function Mark71($AccountNo) {
1380	$Significance='0654321';
1381	$Help = 0;
1382	$Mark71 = 1;
1383	$AccountNo = $this->ExpandAccount($AccountNo);
1384	for ($Run = 0;$Run < strlen($Significance);$Run++) {
1385	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1386	}
1387	$Help = $Help % 11;
1388	$Checksum = 11 - $Help;
1389	if ($Help == 0) {
1390	$Checksum = 0;
1391	}
1392	if ($Help == 1) {
1393	$Checksum = 1;
1394	}
1395	if ($Checksum == substr($AccountNo,-1)) {
1396	$Mark71 = 0;
1397	}
1398	return $Mark71;
1399	} /* End of Mark71 */
1400
1401	private function Mark72($AccountNo) {
1402	$Mark72 = $this->Method00($AccountNo, '000121212', 10);
1403	return $Mark72;
1404	} /* End of Mark72 */
1405
1406	/*
1407	private function Mark73($AccountNo) {
1408	$AccountNo = $this->ExpandAccount($AccountNo);
1409	if (substr($AccountNo,2,1) == '9') {
1410	$Mark73 = $this->Method06($AccountNo, 'A98765432', TRUE, 10, 11);
1411	} else {
1412	$Mark73 = $this->Method00($AccountNo, '000121212', 10);
1413	}
1414	return $Mark73;
1415	}
1416	*/
1417
1418
1419	private function Mark73($AccountNo) {
1420	$AccountNo = $this->ExpandAccount($AccountNo);
1421	if (substr($AccountNo,2,1) != '9') {
1422	$Mark73 = $this->Method00($AccountNo, '000121212', 10); //Variante 1
1423	if ($Mark73 != 0) {
1424	$Mark73 = $this->Method00($AccountNo, '000021212', 10); //Variante 2
1425	if ($Mark73 != 0) {
1426	$Mark73 = $this->Method00($AccountNo, '000021212', 10, 7); //Variante 3
1427	}
1428	}
1429	} else {
1430	// $Mark73 = $this->Method06($AccountNo, 'A98765432', TRUE, 10, 11);
1431	$Mark73 = $this->Mark51($AccountNo);
1432	}
1433	return $Mark73;
1434	} /* End of Mark73 */
1435
1436
1437	// Letzte Ueberpruefung: 22.06.2007 FrankM
1438	private function Mark74($AccountNo) {
1439	$Help = 0;
1440	$V2 = 0;
1441	// Wenn Kontonummer sechstellig, Variante 2 beachten!
1442	if (strlen($AccountNo) == 6) {
1443	$V2 = 1;
1444	}
1445	$Correct = $this->Method00($AccountNo, '212121212', 10);
1446	if ($Correct == 1) {
1447	// Wenn Variante 2...
1448	if ($V2 == 1) {
1449	$Significance = '212121212';
1450	$Correct = 1;
1451	$AccountNo = $this->ExpandAccount($AccountNo);
1452	for ($Run = 0; $Run < strlen($Significance); $Run++) {
1453	$Help += $this->CrossSum(substr($AccountNo, $Run,1) * substr($Significance, $Run,1));
1454	}
1455	$Help = $this->OnlyOne($Help);
1456	$Help = 5 - $Help;
1457	if ($Help < 0) {
1458	$Help = 10 + $Help;
1459	}
1460	//echo "HELP = " . $Help . "<br>";
1461	//echo "PRUE = " . substr($AccountNo,-1) . "<br>";
1462	$Checksum = $Help;
1463	// Wenn Checksumme = Pruefziffer, dann richtig
1464	if ($Checksum == substr($AccountNo,-1)) {
1465	$Correct = 0;
1466	}
1467	} // Ende Variante 2
1468	}
1469	//echo "ERG = " . $Correct . "<br>";
1470	return $Correct;
1471	} /* End of Mark74 */
1472
1473
1474	/* --- Fixed FrankM 20070822 --- */
1475	private function Mark75($AccountNo) {
1476	$Help = 1;
1477	switch (strlen($AccountNo)) {
1478	case 6 :
1479	case 7 :
1480	$Help = $this->Method00($AccountNo,'000021212',10);
1481	break;
1482	case 9 :
1483	if (substr($AccountNo,0,1) == '9') {
1484	$Help = $this->Method00($AccountNo,'0021212',8);
1485	} else {
1486	$Help = $this->Method00($AccountNo,'021212',7);
1487	}
1488	break;
1489	case 10 :
1490	$Help = $this->Method00($AccountNo,'021212',7);
1491	break;
1492	}
1493	return $Help;
1494	} /* End of Mark75 */
1495
1496	private function Mark76($AccountNo) {
1497	$Help = 0;
1498	$Correct = 1;
1499	$Significance = '0765432';
1500	$AccountNo = $this->ExpandAccount($AccountNo);
1501	for ($Run = 0;$Run < strlen($Significance);$Run++) {
1502	$Help += substr($AccountNo,$Run,1) * substr($Significance,$Run,1);
1503	}
1504	$Help = $Help % 11;
1505	if ($Help == 10) {
1506	$Correct = 4;
1507	} else {
1508	if ($Help == substr($AccountNo,-3,1)) {
1509	$Correct = 0;
1510	} else {
1511	$Help=0;
1512	$Significance = '000765432';
1513	for ($Run = 0;$Run < strlen($Significance);$Run++) {
1514	$Help += substr($AccountNo,$Run,1) * substr($Significance,$Run,1);
1515	}
1516	$Help = $Help % 11;
1517	if ($Help == 10) {
1518	$Correct = 4;
1519	} else {
1520	if ($Help == substr($AccountNo,-1)) {
1521	$Correct = 0;
1522	} else {
1523	$Correct = 1;
1524	}
1525	}
1526	}
1527	}
1528	return $Correct;
1529	} /* End of Mark76 */
1530
1531	private function Mark77($AccountNo) {
1532	$Help = 0;
1533	$Mark77 = 1;
1534	$AccountNo = $this->ExpandAccount($AccountNo);
1535	$Significance = '54321';
1536	for ($Run = 4;$Run == 9;$Run++) {
1537	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1538	}
1539	$Help = $Help % 11;
1540	if ($Help <> 0) {
1541	$Help = 0;
1542	$Significance = '54345';
1543	for ($Run = 4;$Run < 10;$Run++) {
1544	$Help += (substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1545	}
1546	$Help = $Help % 11;
1547	if ($Help = 0) {
1548	$Mark77 = 0;
1549	}
1550	}
1551	return $Mark77;
1552	} /* End of Mark77 */
1553
1554	private function Mark78($AccountNo) {
1555	if (strlen($AccountNo) == 8) {
1556	$Mark78 = 4;
1557	} else {
1558	$Mark78 = $this->Method00($AccountNo, '212121212', 10);
1559	}
1560	return $Mark78;
1561	} /* End of Mark78 */
1562
1563	private function Mark79($AccountNo) {
1564	$AccountNo = $this->ExpandAccount($AccountNo);
1565	switch (substr($AccountNo,0,1)) {
1566	case '0' :
1567	case '7' :
1568	case '8' :
1569	$Mark79 = 1;
1570	break;
1571	case '1' :
1572	case '2' :
1573	case '9' :
1574	$Mark79 = $this->Method00($AccountNo, '12121212', 9);
1575	break;
1576	case '3' :
1577	case '4' :
1578	case '5' :
1579	case '6' :
1580	$Mark79 = $this->Method00($AccountNo, '212121212', 10);
1581	default :
1582	$Mark79 = 1;
1583	}
1584	return $Mark79;
1585	} /* End of Mark79 */
1586
1587	private function Mark80($AccountNo) {
1588	$AccountNo = $this->ExpandAccount($AccountNo);
1589
1590	if (substr($AccountNo,2,1) == '9') {
1591	$Mark80 = $this->Mark51($AccountNo);
1592	} else {
1593	$Mark80 = $this->Method00($AccountNo, '000021212', 10);
1594	}
1595	if ($Mark80 != 0){
1596	$Significance='000021212';
1597	$Help = 0;
1598	$Mark80 = 1;
1599
1600	for ($Run = 0; $Run < strlen($Significance); $Run++) {
1601	$Help += $this->CrossSum(substr($AccountNo,$Run,1) * substr($Significance,$Run,1));
1602	}
1603	$Help = $Help % 7;
1604	$Checksum = 7 - $Help;
1605
1606	if ($Checksum == 10) {
1607	$Checksum = 0;
1608	}
1609	if ($Checksum == substr($AccountNo,9,1)) {
1610	$Mark80 = 0;
1611	}
1612	}
1613	return $Mark80;
1614	} /* End of Mark80 */
1615
1616	private function Mark81($AccountNo) {
1617	$AccountNo = $this->ExpandAccount($AccountNo);
1618	if (substr($AccountNo,2,1) == '9') {
1619	$Mark81 = $this->Mark10($AccountNo);
1620	} else {
1621	$Mark81 = $this->Mark51($AccountNo);
1622	}
1623	return $Mark81;
1624	} /* End of Mark81 */
1625
1626	private function Mark82($AccountNo) {
1627	$AccountNo = $this->ExpandAccount($AccountNo);
1628	if (substr($AccountNo,2, 2) == '99') {
1629	$Mark82 = $this->Mark10($AccountNo);
1630	} else {
1631	$Mark82 = $this->Mark33($AccountNo);
1632	}
1633	return $Mark82;
1634	} /* End of Mark82 */
1635
1636	// --- Fix FrankM 20081208 ---
1637	private function Mark83($AccountNo) {
1638	// Methode A
1639	$Help = $this->Mark32($AccountNo);
1640	if ($Help == 1) {
1641	// Methode B
1642	$Help = $this->Mark33($AccountNo);
1643	if ($Help == 1) {
1644	// 10. Stelle 7, 8 oder 9 = ungueltig
1645	switch (substr($AccountNo, -1)) {
1646	case '7' :
1647	case '8' :
1648	case '9' :
1649	$Help = 1;
1650	break;
1651	default :
1652	// Methode C: Modulus 7, Gewichtung 2, 3, 4, 5, 6
1653	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 7);
1654	break;
1655	}
1656	}
1657	}
1658	$Mark83 = $Help;
1659	return $Mark83;
1660	} /* End of Mark83 */
1661
1662	/* --- Changed Christian Rothe 20130603 --- */
1663	private function Mark84($AccountNo) {
1664	$AccountNo = $this->ExpandAccount($AccountNo);
1665	if (substr($AccountNo, 2, 1) != '9') {
1666	// Methode A: Modulus 11, Gewichtung 2, 3, 4, 5, 6
1667	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 11);
1668	// Methode B: Modulus 7, Gewichtung 2, 3, 4, 5, 6
1669	if ($Help == 1) {
1670	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 7);
1671	}
1672	// Methode C: Modulus 10, Gewichtung 2, 1, 2, 1, 2
1673	if ($Help == 1) {
1674	$Help = $this->Method06($AccountNo, '000021212', FALSE, 10, 10);
1675	}
1676	} else {
1677	$Help = $this->Mark51($AccountNo);
1678	}
1679	return $Help;
1680	} /* End of Mark84 */
1681
1682	// --- Fix FrankM 20080717 ---
1683	private function Mark85($AccountNo) {
1684	$AccountNo = $this->ExpandAccount($AccountNo);
1685	// Zuerst Typ A = Modifizierte Methode 6.
1686	$Help = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
1687	if ($Help == 0) {
1688	return $Help;
1689	} else {
1690	// Wenn falsch, dann Typ B = Methode 33 (Modifizierte Methode 6).
1691	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 11);
1692	}
1693	if ($Help == 0) {
1694	return $Help;
1695	} else {
1696	// Wenn falsch, dann Typ C.
1697	// Wenn zehnte Stelle = 7, 8, oder 9 dann Kontonummer ungueltig.
1698	if ($AccountNo[9] == '7' or $AccountNo[9] == '8' or $AccountNo[9] == '9') {
1699	return $Help;
1700	} else {
1701	// Methode 33 (Modifizierte Methode 6 mit Divisor 7).
1702	if (substr($AccountNo, 2, 2) != '99') {
1703	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 7);
1704	// Wenn 3. und 4. Stelle = 99, dann Modifizierte Methode 2.
1705	} else {
1706	$Help = $this->Method02($AccountNo, '008765432', FALSE);
1707	}
1708	}
1709	}
1710	return $Help;
1711	} /* End of Mark85 */
1712
1713	private function Mark86($AccountNo) {
1714	$Help = $this->Method00($AccountNo, '000121212', 10);
1715	if ($Help == 1) {
1716	if (substr($AccountNo,2,1) == '9') {
1717	$Help = $this->Method06($AccountNo, 'A98765432', TRUE, 10, 11);
1718	} else {
1719	$Help = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
1720	}
1721	}
1722	$Mark86 = $Help;
1723	return $Mark86;
1724	} /* End of Mark86 */
1725
1726	private function Mark87($AccountNo) {
1727	$Tab1[0] = 0;
1728	$Tab1[1] = 4;
1729	$Tab1[2] = 3;
1730	$Tab1[3] = 2;
1731	$Tab1[4] = 6;
1732
1733	$Tab2[0] = 7;
1734	$Tab2[1] = 1;
1735	$Tab2[2] = 5;
1736	$Tab2[3] = 9;
1737	$Tab2[4] = 8;
1738
1739	$Result = 1;
1740	$AccountNo = $this->ExpandAccount($AccountNo);
1741	if (substr($AccountNo,2,1) == '9') {
1742	$Result = $this->Mark10($AccountNo);
1743	} else {
1744	for ($Run = 0; $Run < strlen($AccountNo); $Run++) {
1745	// $AccountNoTemp[$Run + 1] = (int) substr($AccountNo,$Run,1);
1746	$AccountNoTemp[$Run] = (int) substr($AccountNo,$Run,1);
1747	}
1748
1749	$i = 4;
1750	while ($AccountNoTemp[$i] == 0) {
1751	$i++;
1752	}
1753
1754	$C2 = $i % 2;
1755	$D2 = 0;
1756	$A5 = 0;
1757	while ($i < 10) {
1758	switch ($AccountNoTemp[$i]) {
1759	case 0 :
1760	$AccountNoTemp[$i] = 5;
1761	break;
1762	case 1 :
1763	$AccountNoTemp[$i] = 6;
1764	break;
1765	case 5:
1766	$AccountNoTemp[$i] = 10;
1767	break;
1768	case 6:
1769	$AccountNoTemp[$i] = 1;
1770	break;
1771	}
1772	if ($C2 == $D2) {
1773	if ($AccountNoTemp[$i] > 5) {
1774	if(($C2 == 0) AND ($D2 == 0)) {
1775	$C2 = 1;
1776	$D2 = 1;
1777	$A5 = $A5 + 6 - ($AccountNoTemp[$i] - 6);
1778	} else {
1779	$C2 = 0;
1780	$D2 = 0;
1781	$A5 = $A5 + $AccountNoTemp[$i];
1782	} //end if(($C2 == 0) AND ($D2 == 0))
1783	} else {
1784	if (($C2 == 0) AND ($D2 == 0)) {
1785	$C2 = 1;
1786	$A5 = $A5 + $AccountNoTemp[$i];
1787	} else {
1788	$C2 = 0;
1789	$A5 = $A5 + $AccountNoTemp[$i];
1790	}
1791	}
1792	} else {
1793	if ($AccountNoTemp[$i] > 5) {
1794	if ($C2 == 0) {
1795	$C2 = 1;
1796	$D2 = 0;
1797	$A5 = $A5 - 6 + ($AccountNoTemp[$i] - 6);
1798	} else {
1799	$C2 = 0;
1800	$D2 = 1;
1801	$A5 = $A5 - $AccountNoTemp[$i];
1802	}
1803	} else {
1804	if ($C2 == 0) {
1805	$C2 = 1;
1806	$A5 = $A5 - $AccountNoTemp[$i];
1807	} else {
1808	$C2 = 0;
1809	$A5 = $A5 - $AccountNoTemp[$i];
1810	}
1811	}
1812	}
1813	$i++;
1814	}
1815	while (($A5 < 0) OR ($A5 > 4)) {
1816	if ($A5 > 4) {
1817	$A5 = $A5 - 5;
1818	} else {
1819	$A5 = $A5 + 5;
1820	}
1821	}
1822	if ($D2 == 0) {
1823	$P = $Tab1[$A5];
1824	} else {
1825	$P = $Tab2[$A5];
1826	}
1827	if ($P == $AccountNoTemp[10]) {
1828	$Result = 0;
1829	} else {
1830	if ($AccountNoTemp[4] == 0) {
1831	if ($P > 4) {
1832	$P = $P - 5;
1833	} else {
1834	$P = $P + 5;
1835	}
1836	if ($P == $AccountNoTemp[10] ) {
1837	$Result = 0;
1838	}
1839	}
1840	}
1841	if ($Result <> 0 ) {
1842	$Result = $this->Mark33($AccountNo);
1843	if ($Result <> 0 ) {
1844	$Result = $this->Method06($AccountNo,'000065432',FALSE,10,7);
1845	}
1846	}
1847	}
1848	return $Result;
1849	} /* End of Mark87 */
1850
1851	private function Mark88($AccountNo) {
1852	$AccountNo = $this->ExpandAccount($AccountNo);
1853	if (substr($AccountNo,2,1) == '9') {
1854	$Mark88 = $this->Method06($AccountNo, '008765432', FALSE, 10, 11);
1855	} else {
1856	$Mark88 = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
1857	}
1858	return $Mark88;
1859	} /* End of Mark88 */
1860
1861	private function Mark89($AccountNo) {
1862	$Correct = 1;
1863	switch (strlen($AccountNo)) {
1864	case 1 :
1865	case 2 :
1866	case 3 :
1867	case 4 :
1868	case 5 :
1869	case 6 :
1870	case 10 :
1871	$Correct = 4;
1872	break;
1873	case 7 :
1874	case 9 :
1875	$AccountNo = $this->ExpandAccount($AccountNo);
1876	$Correct = $this->Method06($AccountNo,'098765432',FALSE,10,11);
1877	break;
1878	default :
1879	if ((((int)$AccountNo > 32000005) and ((int)$AccountNo < 38999995)) or (((int)$AccountNo >1999999999) AND ((int)$AccountNo <400000000))) {
1880	$Correct = $this->Mark10($AccountNo);
1881	}
1882	}
1883	return $Correct;
1884	} /* End of Mark89 */
1885
1886	private function Mark90($AccountNo) {
1887	$Help = $this->Method06($AccountNo, '000765432', FALSE, 10, 11); // Methode A
1888	if ($Help != 0) {
1889	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 11); // Methode B
1890	if ($Help != 0) {
1891	switch (substr($AccountNo,-1)) {
1892	case '7' :
1893	case '8' :
1894	case '9' :
1895	$Help = 4;
1896	break;
1897	default :
1898	$Help = $this->Method06($AccountNo, '000065432', FALSE, 10, 7); //Methode C
1899	break;
1900	}
1901	}
1902	if ($Help != 0) {
1903	$Help = $this->Method06($AccountNo, '000065432',FALSE, 10, 9); //Methode D
1904	}
1905	if ($Help != 0) {
1906	$Help = $this->Method06($AccountNo, '000021212',FALSE, 10, 10); //Methode E
1907	}
1908	}
1909	return $Help;
1910	} /* End of Mark90 */
1911
1912	private function Mark91($AccountNo) {
1913	$Help = $this->Method06($AccountNo, '765432', FALSE, 7, 11);
1914	if ($Help == 1) {
1915	$Help = $this->Method06($AccountNo, '234567', FALSE, 7, 11);
1916	if ($Help == 1) {
1917	$Help = $this->Method06($AccountNo, 'A987650432', TRUE, 7, 11);
1918	if ($Help == 1) {
1919	$Help = $this->Method06($AccountNo, '9A5842', TRUE, 7, 11);
1920	}
1921	}
1922	}
1923	return $Help;
1924	} /* End of Mark91 */
1925
1926	private function Mark92($AccountNo) {
1927	$Mark92 = $this->Method01($AccountNo, '000173173');
1928	return $Mark92;
1929	} /* End of Mark92 */
1930
1931	private function Mark93($AccountNo) {
1932	$AccountNo = $this->ExpandAccount($AccountNo);
1933	$Correct = 1;
1934	if (substr($AccountNo,0,4) == '0000') {
1935	$Correct = $this->Method06($AccountNo,'000065432',FALSE,10,11);
1936	} else {
1937	$Correct = $this->Method06($AccountNo,'65432',FALSE,10,11);
1938	}
1939	if ($Correct == 1) {
1940	if (substr($AccountNo,0,4) == '0000') {
1941	$Correct = $this->Method06($AccountNo,'000065432',FALSE,10,7);
1942	} else {
1943	$Correct = $this->Method06($AccountNo,'65432',FALSE,10,7);
1944	}
1945	}
1946	$Mark93 = $Correct;
1947	return $Mark93;
1948	} /* End of Mark93 */
1949
1950	private function Mark94($AccountNo) {
1951	$Mark94 = $this->Method00($AccountNo, '121212121', 10);
1952	return $Mark94;
1953	} /* End of Mark94 */
1954
1955	/* --- Changed Christian Rothe 20130909 --- */
1956	private function Mark95($AccountNo) {
1957	$AccountNo = $this->ExpandAccount($AccountNo);
1958
1959	switch($AccountNo) {
1960	case ($AccountNo >= '0000000001' && $AccountNo <= '0001999999'):
1961	case ($AccountNo >= '0009000000' && $AccountNo <= '0025999999'):
1962	case ($AccountNo >= '0396000000' && $AccountNo <= '0499999999'):
1963	case ($AccountNo >= '0700000000' && $AccountNo <= '0799999999'):
1964	case ($AccountNo >= '0910000000' && $AccountNo <= '0989999999'):
1965	$Mark95 = 4;
1966	break;
1967	default:
1968	$Mark95 = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
1969	}
1970
1971	return $Mark95;
1972	} /* End of Mark95 */
1973
1974	private function Mark96($AccountNo) {
1975	$AccountNo = $this->ExpandAccount($AccountNo);
1976	$Help = $this->Mark19($AccountNo);
1977	if ($Help == 1) {
1978	$Help = $this->Method00($AccountNo, '212121212', 10);
1979	if ($Help == 1) {
1980	if ((int) $AccountNo >1299999) {
1981	if ((int) $AccountNo < 99400000) {
1982	$Help = 0;
1983	}
1984	}
1985	}
1986	}
1987	return $Help;
1988	} /* End of Mark96 */
1989
1990	private function Mark97($AccountNo) {
1991	$AccountNo = $this->ExpandAccount($AccountNo);
1992	$Help = (int) substr($AccountNo, 0, 9) % 11;
1993	if ($Help == 10) {
1994	$Help = 0;
1995	}
1996	if (substr($AccountNo,-1) == $Help) {
1997	$Mark97 = 0;
1998	} else {
1999	$Mark97 = 1;
2000	}
2001	return $Mark97;
2002	} /* End of Mark97 */
2003
2004	private function Mark98($AccountNo) {
2005	$AccountNo = $this->ExpandAccount($AccountNo);
2006	$Correct = $this->Method01($AccountNo,'003713713');
2007	if ($Correct == 1) {
2008	$Correct = $this->Mark32($AccountNo);
2009	}
2010	$Mark98 = $Correct;
2011	return $Mark98;
2012	} /* End of Mark98 */
2013
2014	private function Mark99($AccountNo) {
2015	$Mark99 = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
2016	if ((int) $AccountNo >= 396000000 && (int) $AccountNo <= 499999999) {
2017	$Mark99 = 4;
2018	}
2019	return $Mark99;
2020	} /* End of Mark99 */
2021
2022	private function MarkA1($AccountNo) {
2023	if (strlen($AccountNo) == 8 OR strlen($AccountNo)==10){
2024	$AccountNo = $this->ExpandAccount($AccountNo);
2025	$MarkA1 = $this->Method00($AccountNo, '002121212', 10);
2026	} else {
2027	$MarkA1 = 1;
2028	}
2029	return $MarkA1;
2030	} /* End of MarkA1 */
2031
2032	private function MarkA2($AccountNo) {
2033	$AccountNo = $this->ExpandAccount($AccountNo);
2034	$MarkA2 = $this->Method00($AccountNo, '212121212', 10);
2035	if ($MarkA2 != 0){
2036	$MarkA2 = $this->Mark04($AccountNo);
2037	}
2038	return $MarkA2;
2039	} /* End of MarkA2 */
2040
2041	private function MarkA3($AccountNo) {
2042	$AccountNo = $this->ExpandAccount($AccountNo);
2043	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2044	if ($RetVal != 0){
2045	$RetVal = $this->Mark10($AccountNo);
2046	}
2047	return $RetVal;
2048	} /* End of MarkA3 */
2049
2050	private function MarkA4($AccountNo) {
2051	$AccountNo = $this->ExpandAccount($AccountNo);
2052	if ((int) substr($AccountNo, 2,2) != 99){
2053	/* Variante 1 */
2054	$MarkA4 = $this->Method06($AccountNo,'000765432',FALSE, 10,11);
2055	if ($MarkA4 !=0){
2056	/* Variante 2 */
2057	$Significance='000765432';
2058	$MarkA4 = 1;
2059	$Help = 0;
2060	for ($Run = 0; $Run < strlen($Significance); $Run++) {
2061	$Help += substr($AccountNo,$Run,1) * substr($Significance,$Run,1);
2062	}
2063	$Help = $Help % 7;
2064	$Checksum = 7 - $Help;
2065
2066	if ($Help == 0) {
2067	$Checksum = 0;
2068	}
2069	if ($Checksum == substr($AccountNo,-1)) {
2070	$MarkA4 = 0;
2071	}
2072	}
2073	if ($MarkA4 != 0){
2074	/* Variante 4 */
2075	$MarkA4 = $this->Mark93($AccountNo);
2076	}
2077	} else {
2078	/* Variante 3 */
2079	$MarkA4 = $this->Method06($AccountNo,'000065432',FALSE,10,11);
2080	if ($MarkA4 != 0){
2081	/* Variante 4 */
2082	$MarkA4 = $this->Mark93($AccountNo);
2083	}
2084	}
2085	return $MarkA4;
2086	} /* End of MarkA4 */
2087
2088	private function MarkA5($AccountNo) {
2089	$AccountNo = $this->ExpandAccount($AccountNo);
2090	$MarkA5 = $this->Method00($AccountNo, '212121212', 10);
2091	if ($MarkA5 != 0){
2092	if (substr($AccountNo,1,1) != "9"){
2093	$MarkA5 = $this->Mark10($AccountNo);
2094	} else {
2095	$MarkA5 = 1;
2096	}
2097	}
2098	return $MarkA5;
2099	} /* End of MarkA5 */
2100
2101	private function MarkA6($AccountNo) {
2102	$AccountNo = $this->ExpandAccount($AccountNo);
2103	if (substr($AccountNo,1,1) != "8"){
2104	$RetVal = $this->Method01($AccountNo, '173173173');
2105	} else {
2106	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2107	}
2108	return $RetVal;
2109	} /* End of MarkA6 */
2110
2111	private function MarkA7($AccountNo) {
2112	$AccountNo = $this->ExpandAccount($AccountNo);
2113	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2114	if ($RetVal != 0){
2115	$RetVal = $this->Mark03($AccountNo);
2116	}
2117	return $RetVal;
2118	} /* End of MarkA7 */
2119
2120	private function MarkA8($AccountNo) {
2121	$AccountNo = $this->ExpandAccount($AccountNo);
2122	$RetVal = $this->Mark81($AccountNo);
2123	if ($RetVal != 0){
2124	if (substr($AccountNo,2,1) != "9"){
2125	$RetVal = $this->Mark73($AccountNo);
2126	} else {
2127	$RetVal = 1;
2128	}
2129	}
2130	return $RetVal;
2131	} /* End of MarkA8 */
2132
2133	/* --- Fixed FrankM 20050408 --- */
2134	private function MarkA9($AccountNo) {
2135	$AccountNo = $this->ExpandAccount($AccountNo);
2136	$RetVal = $this->Method01($AccountNo, '173173173');
2137	if ($RetVal != 0){
2138	$RetVal = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
2139	}
2140	return $RetVal;
2141	} /* End of MarkA9 */
2142
2143
2144	/* --- Added FrankM 20050408 --- */
2145	/* --- Wird aktuell von keiner Bank benutzt (09/2007 - 12/2007) ---*/
2146	private function MarkB0($AccountNo) {
2147	if (strlen($AccountNo) != 10 OR substr($AccountNo,0,1) == "8"){
2148	$RetVal = 1;
2149	} else {
2150	if (substr($AccountNo,9,1) == "1" OR substr($AccountNo,9,1) == "2" OR substr($AccountNo,9,1) == "3" OR substr($AccountNo,9,1) == "6"){
2151	$RetVal = 0;
2152	} else {
2153	$RetVal = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
2154	}
2155	}
2156	return $RetVal;
2157	} /* End of MarkB0 */
2158
2159	/* --- Added FrankM 20050413 --- */
2160	private function MarkB1($AccountNo) {
2161	$AccountNo = $this->ExpandAccount($AccountNo);
2162	$RetVal = $this->Method01($AccountNo, '137137137');
2163	if ($RetVal != 0){
2164	$RetVal = $this->Method01($AccountNo, '173173173');
2165	}
2166	return $RetVal;
2167	} /* End of MarkB1 */
2168
2169	/* --- Added FrankM 20050415 --- */
2170	private function MarkB2($AccountNo) {
2171	$AccountNo = $this->ExpandAccount($AccountNo);
2172	if (substr($AccountNo,0,1) <= "7"){
2173	$RetVal = $this->Method02($AccountNo, '298765432', FALSE);
2174	} else {
2175	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2176	}
2177	return $RetVal;
2178	} /* End of MarkB2 */
2179
2180	/* --- Added FrankM 20050415 --- */
2181	private function MarkB3($AccountNo) {
2182	$AccountNo = $this->ExpandAccount($AccountNo);
2183	if (substr($AccountNo,0,1) <= "8"){
2184	$RetVal = $this->Method06($AccountNo, '000765432', FALSE, 10, 11);
2185	} else {
2186	$RetVal = $this->Method06($AccountNo, '432765432', FALSE, 10, 11);
2187	}
2188	return $RetVal;
2189	} /* End of MarkB3 */
2190
2191	/* --- Added FrankM 20050415 --- */
2192	private function MarkB4($AccountNo) {
2193	$AccountNo = $this->ExpandAccount($AccountNo);
2194	if (substr($AccountNo,0,1) == "9"){
2195	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2196	} else {
2197	$RetVal = $this->Method02($AccountNo, '298765432', FALSE);
2198	}
2199	return $RetVal;
2200	} /* End of MarkB4 */
2201
2202	/* --- Added FrankM 20050727 --- */
2203	private function MarkB5($AccountNo) {
2204	$AccountNo = $this->ExpandAccount($AccountNo);
2205	$RetVal = $this->Method01($AccountNo, '137137137');
2206	if ($RetVal != 0){
2207	if ((substr($AccountNo,0,1) == '8') Or (substr($AccountNo,0,1) == '9')) {
2208	return $RetVal;
2209	}
2210	$RetVal = $this->Method00($AccountNo, '212121212', 10);
2211	}
2212	return $RetVal;
2213	} /* End of MarkB5 */
2214
2215	/* --- Added FrankM 20060112 ---
2216	--- Hotfix 20070717 ---
2217	--- Hotfix FrankM 20080110 --- */
2218	/* --- Changed Christian Rothe 20110901 --- */
2219
2220	private function MarkB6($AccountNo, $BLZ) {
2221	// Wenn Laenge = 9 dann Kontonummer fuer Methode 53 merken, Hotfix 20080110.
2222	if (strlen($AccountNo) == 9) {
2223	$AccountNoShort = $AccountNo;
2224	}
2225	// Mit fuehrenden Nullen auf 10 erweitern.
2226	$AccountNo = $this->ExpandAccount($AccountNo);
2227	// Kontonummern, die an der 1. Stelle den Wert 1-9 beinhalten, nach Methode 20 pruefen.
2228	// Ebenso Kontonummern, die an den Stellen 15 die Werte 02691-02699 beinhalten, nach Methode 20 pruefen.
2229	if (((int)(substr($AccountNo,0 ,1)) <= 9 && (int)(substr($AccountNo,0 ,1)) > 0 ) \|\| (substr($AccountNo,0 ,5) <= '02699' && substr($AccountNo,0 ,5) >= '02691' )){ //franky_n
2230	$RetVal = $this->Mark20($AccountNo);
2231	} else {
2232	// Fuer Methode 53 muss die Laenge der Kontonummer = 9 sein
2233	if (strlen($AccountNoShort) == 9) {
2234	$RetVal = $this->Mark53($AccountNoShort, $BLZ);
2235	} else {
2236	$RetVal = 1;
2237	}
2238	}
2239	return $RetVal;
2240	} /* End of MarkB6 */
2241
2242	/* --- Added FrankM 20060112 --- */
2243	private function MarkB7($AccountNo) {
2244	$AccountNo = $this->ExpandAccount($AccountNo);
2245	$AccountFloat = doubleval($AccountNo);
2246	if (($AccountFloat >= 1000000) And ($AccountFloat <= 5999999)) {
2247	$RetVal = $this->Method01($AccountNo, '173173173');
2248	} elseif (($AccountFloat >= 700000000) And ($AccountFloat <= 899999999)) {
2249	$RetVal = $this->Method01($AccountNo, '173173173');
2250	} else {
2251	$RetVal = 2;
2252	}
2253	return $RetVal;
2254	} /* End of MarkB7 */
2255
2256	/* --- Added FrankM 20060112 --- */
2257	/* --- Changed Christian Rothe 20110606 --- */
2258	/* --- 20110606: Aenderung des Verfahrens durch die Bundesbank --- */
2259	private function MarkB8($AccountNo) {
2260	$AccountNo = $this->ExpandAccount($AccountNo);
2261	$RetVal = $this->Mark20($AccountNo);
2262	if ($RetVal != 0){
2263	$RetVal = $this->Mark29($AccountNo);
2264	}
2265	if ($RetVal != 0){
2266	if (($AccountNo >= 5100000000) And ($AccountNo <= 5999999999)) {
2267	$RetVal = $this->Mark09($AccountNo);
2268	} elseif (($AccountNo >= 9010000000) And ($AccountNo <= 9109999999)) {
2269	$RetVal = $this->Mark09($AccountNo);
2270	}
2271	}
2272	return $RetVal;
2273	} /* End of MarkB8 */
2274
2275	/* --- Added FrankM 20060124 --- */
2276	/* --- Benutzt von Hanseatic Bank, Hamburg --- */
2277	private function MarkB9($AccountNo) {
2278	$AccountNo = $this->ExpandAccount($AccountNo);
2279	$RetVal = 1;
2280
2281	// Variante 1 - Zwei führende Nullen
2282	if ((substr($AccountNo,0,2) == "00")And (substr($AccountNo,2,1) != "0")){
2283	$Significance = '1231231';
2284	$Step3 = 0;
2285	for ($Run = 0;$Run < strlen($Significance);$Run++) {
2286	$Step1 = (substr($AccountNo,$Run + 2,1) * substr($Significance,$Run,1));
2287	$Step2 = $Step1 + substr($Significance,$Run,1);
2288	$Step3 += $Step2 % 11;
2289	}
2290	$Checksum = $Step3 % 10;
2291	if ($Checksum == substr($AccountNo,-1)) {
2292	$RetVal = 0;
2293	} else {
2294	$Checksum = $Checksum + 5;
2295	if ($Checksum > 10) {
2296	$Checksum = $Checksum - 10;
2297	}
2298	if ($Checksum == substr($AccountNo,-1)) {
2299	$RetVal = 0;
2300	}
2301	}
2302
2303	// Variante 2 - Drei führende Nullen
2304	} elseif ((substr($AccountNo,0,3) == "000")And (substr($AccountNo,3,1) != "0")){
2305	$Significance = '654321';
2306	$Step1 = 0;
2307	for ($Run = 0;$Run < strlen($Significance);$Run++) {
2308	$Step1 += (substr($AccountNo,$Run + 3,1) * substr($Significance,$Run,1));
2309	}
2310	$Checksum = $Step1 % 11;
2311	if ($Checksum == substr($AccountNo,-1)) {
2312	$RetVal = 0;
2313	} else {
2314	$Checksum = $Checksum + 5;
2315	if ($Checksum > 10) {
2316	$Checksum = $Checksum - 10;
2317	}
2318	if ($Checksum == substr($AccountNo,-1)) {
2319	$RetVal = 0;
2320	}
2321	}
2322	}
2323	return $RetVal;
2324	} /* End of MarkB9 */
2325
2326	/* --- Added FrankM 20060112 ---
2327	--- Fix FrankM 20061103 ---
2328	--- Hotfix FrankM 20080110 --- */
2329	private function MarkC0($AccountNo, $BLZ) {
2330	// Wenn Laenge = 8 dann Kontonummer fuer Methode 52 merken, Hotfix 20080110.
2331	if (strlen($AccountNo) == 8) {
2332	$AccountNoShort = $AccountNo;
2333	}
2334	// Mit fuehrenden Nullen auf 10 erweitern.
2335	$AccountNo = $this->ExpandAccount($AccountNo);
2336	// Pruefen nach Methode 52 (achtstellig)
2337	if ((substr($AccountNo,0,2) == "00") And (substr($AccountNo,0,3)!= "000")) {
2338	// Fuer Methode 52 muss die Laenge der Kontonummer = 8 sein.
2339	if (strlen($AccountNoShort) == 8) {
2340	$RetVal = $this->Mark52($AccountNoShort, $BLZ);
2341	} else {
2342	$RetVal = 1;
2343	}
2344	// Wenn falsch, dann Methode 20
2345	if ($RetVal != 0){
2346	$RetVal = $this->Mark20($AccountNo);
2347	}
2348	// Alles andere nach Methode 20
2349	} else {
2350	$RetVal = $this->Mark20($AccountNo);
2351	}
2352	return $RetVal;
2353	} /* End of MarkC0 */
2354
2355	/* --- Added 20060703 --- */
2356	private function MarkC1($AccountNo) {
2357	$AccountNo = $this->ExpandAccount($AccountNo);
2358	$markC1 = 1;
2359	if($AccountNo{0} != '5') { // Variante 1
2360	// Methode 17, Modulus 11, Gewichtung 1, 2, 1, 2, 1, 2
2361	$markC1 = $this->Mark17($AccountNo);
2362	} else { // Variante 2
2363	$weights = '121212121';
2364	$sum = 0;
2365	for($i = 0; $i < 9; $i++) {
2366	$sum += $this->CrossSum($AccountNo{$i} * $weights{$i});
2367	}
2368	$sum--;
2369	$prz = $sum % 11;
2370	if(0 < $prz) {
2371	$prz = 10 - $prz;
2372	}
2373	if($prz == $AccountNo{9}) { // 10. Stelle ist PRZ
2374	$markC1 = 0;
2375	}
2376	}
2377	return $markC1;
2378	}
2379
2380	/* --- Added 20060703 --- */
2381	private function MarkC2($AccountNo) {
2382	$AccountNo = $this->ExpandAccount($AccountNo);
2383	$markC2 = $this->Mark22($AccountNo);
2384	if($markC2 != 0) {
2385	$markC2 = $this->Mark00($AccountNo);
2386	}
2387	return $markC2;
2388	}
2389
2390	/* --- Added FrankM 20070305 --- */
2391	private function MarkC3($AccountNo) {
2392	$AccountNo = $this->ExpandAccount($AccountNo);
2393	if (substr($AccountNo,0,1) != "9") {
2394	$markC3 = $this->Mark00($AccountNo);
2395	} else {
2396	$markC3 = $this->Mark58($AccountNo);
2397	}
2398	return $markC3;
2399	}
2400
2401	/* --- Added FrankM 20070305 --- */
2402	private function MarkC4($AccountNo) {
2403	$AccountNo = $this->ExpandAccount($AccountNo);
2404	if (substr($AccountNo,0,1) != "9") {
2405	$markC4 = $this->Mark15($AccountNo);
2406	} else {
2407	$markC4 = $this->Mark58($AccountNo);
2408	}
2409	return $markC4;
2410	}
2411
2412	/* --- Added FrankM 20070822 --- */
2413	private function MarkC5($AccountNo) {
2414	$aAccountNo = $this->ExpandAccountExtended($AccountNo);
2415	$AccountNo = $aAccountNo['AccountNoLong'];
2416
2417	// Berechnungsvariante nach Kontonummernlaenge.
2418	switch ($aAccountNo['AccountNoShortLen']) {
2419	case 6:
2420	// Variante 1, sechsstellige Kontonummer
2421	if ((int)(substr($AccountNo,4 ,1)) <= 8 && (int)(substr($AccountNo,4 ,1)) >= 1 ){ //franky_n
2422	$markC5 = $this->Mark75($aAccountNo['AccountNoShort']);
2423	} else {
2424	$markC5 = 1;
2425	}
2426	break;
2427	case 8:
2428	// Variante 4, achtstellige Kontonummer.
2429	if ((substr($AccountNo,2,1) == "3") or (substr($AccountNo,2,1) == "4") or (substr($AccountNo,2,1) == "5")) {
2430	$markC5 = $this->Mark09($AccountNo);
2431	} else {
2432	$markC5 = 1;
2433	}
2434	break;
2435	case 9:
2436	// Variante 1, neunstellige Kontonummer
2437	if (intval(substr($AccountNo,1 ,1)) <= 8 && intval(substr($AccountNo,1 ,1)) >= 1 ){
2438	$markC5 = $this->Mark75($aAccountNo['AccountNoShort']);
2439	} else {
2440	$markC5 = 1;
2441	}
2442	break;
2443	case 10:
2444	// Variante 4, zehnstellige Kontonummer.
2445	if ((substr($AccountNo,0,2) == "70") or (substr($AccountNo,0,2) == "85")) {
2446	$markC5 = $this->Mark09($AccountNo);
2447	return $markC5;
2448	// Variante 2, zehnstellige Kontonummer.
2449	} elseif ((substr($AccountNo,0,1) == "1") or (substr($AccountNo,0,1) == "4") or (substr($AccountNo,0,1) == "5") or (substr($AccountNo,0,1) == "6") or (substr($AccountNo,0,1) == "9")) {
2450	$markC5 = $this->Mark29($AccountNo);
2451	// Variante 3, zehnstellige Kontonummer.
2452	} elseif ((substr($AccountNo,0,1) == "3")) {
2453	$markC5 = $this->Mark00($AccountNo);
2454	} else {
2455	$markC5 = 1;
2456	}
2457	break;
2458	default:
2459	$markC5 = 1;
2460	} // End switch.
2461	return $markC5;
2462	}
2463
2464	/* --- Added FrankM 20070822 ---
2465	--- Changed FrankM 20090206, 20100602 --- */
2466	/* --- Changed Christian Rothe 20110606 --- */
2467	/* --- Changed Christian Rothe 20130309 --- */
2468	/* --- 20110606: Aenderung des Verfahrens durch die Bundesbank --- */
2469	private function MarkC6($AccountNo) {
2470	$AccountNo = $this->ExpandAccount($AccountNo);
2471	$FirstLeftDigit = substr($AccountNo, 0, 1);
2472
2473	// Je nach vorhandener erster Stelle von links die Konstante zuordnen.
2474	switch ($FirstLeftDigit) {
2475	case 0:
2476	$Help = '4451970';
2477	break;
2478	case 1:
2479	$Help = '4451981';
2480	break;
2481	case 2:
2482	$Help = '4451992';
2483	break;
2484	case 3:
2485	$Help = '4451993';
2486	break;
2487	case 4:
2488	$Help = '4344992';
2489	break;
2490	case 5:
2491	$Help = '4344990';
2492	break;
2493	case 6:
2494	$Help = '4344991';
2495	break;
2496	case 7:
2497	$Help = '5499570';
2498	break;
2499	case 8:
2500	$Help = '4451994';
2501	break;
2502	case 9:
2503	$Help = '5499579';
2504	break;
2505	} /* end switch */
2506	// Fuer Berechnung der Pruefziffer die Konstante
2507	// zur Kontonummer hinzu fuegen.
2508	$Help .= substr($AccountNo, 1);
2509
2510	// Methode 00, 16. Stelle Pruefziffer, Modulator 10,
2511	// Pruefziffer NICHT verschieben, ExpandAccount NICHT anwenden.
2512	$markC6 = $this->Method00($Help, '212121212121212', 16, 10, 0, 1);
2513
2514	return $markC6;
2515	}
2516
2517	/* --- Added FrankM 20071009 --- */
2518	private function MarkC7($AccountNo) {
2519	$AccountNo = $this->ExpandAccount($AccountNo);
2520	// Zuerst mit Methode 63 pruefen.
2521	$markC7 = $this->Mark63($AccountNo);
2522	// Wenn Pruefzifferfehler, dann Methode 06
2523	if ($markC7 == 1) {
2524	$markC7 = $this->Mark06($AccountNo);
2525	}
2526	return $markC7;
2527	}
2528
2529	/* --- Added FrankM 20080519 --- */
2530	private function MarkC8($AccountNo) {
2531	$AccountNo = $this->ExpandAccount($AccountNo);
2532	// Zuerst mit Methode 00 pruefen.
2533	$markC8 = $this->Mark00($AccountNo);
2534	// Wenn Pruefzifferfehler, dann Methode 04
2535	if ($markC8 == 1) {
2536	$markC8 = $this->Mark04($AccountNo);
2537	// Wenn Pruefzifferfehler, dann Methode 07
2538	if ($markC8 == 1) {
2539	$markC8 = $this->Mark07($AccountNo);
2540	}
2541	}
2542	return $markC8;
2543	}
2544
2545	/* --- Added FrankM 20080519 --- */
2546	private function MarkC9($AccountNo) {
2547	$AccountNo = $this->ExpandAccount($AccountNo);
2548	// Zuerst mit Methode 00 pruefen.
2549	$markC9 = $this->Mark00($AccountNo);
2550	// Wenn Pruefzifferfehler, dann Methode 07
2551	if ($markC9 == 1) {
2552	$markC9 = $this->Mark07($AccountNo);
2553	}
2554	return $markC9;
2555	}
2556
2557	/* --- Added FrankM 20080717 --- */
2558	private function MarkD0($AccountNo) {
2559	$AccountNo = $this->ExpandAccount($AccountNo);
2560	// Wenn die erste und zweite Stelle = 57, dann keine Pruefung.
2561	if (substr($AccountNo, 0, 2) == "57") {
2562	$markD0 = $this->Mark09($AccountNo);
2563	// Andernfalls Methode 20 (modifizierte Methode 06).
2564	} else {
2565	$markD0 = $this->Method06($AccountNo, '398765432', FALSE, 10, 11);
2566	}
2567	return $markD0;
2568	}
2569
2570	/* --- Added FrankM 20080717 ---
2571	--- Changed FrankM 20100602 ---
2572	--- Changed Nico Sommer 20110120 ---
2573	--- Changed Christian Rothe 20110901 ---
2574	--- Changed Christian Rothe 20130309 --- */
2575
2576	private function MarkD1($AccountNo) {
2577	$AccountNo = $this->ExpandAccount($AccountNo);
2578	$FirstLeftDigit = substr($AccountNo, 0, 1);
2579	$AccountSequence = substr($AccountNo, 1, 9);
2580	if (substr($AccountNo, 0, 1) == "8") {
2581	$markD1 = 1;
2582	} else {
2583	// Je nach vorhandener erster Stelle von links die Konstante zuordnen.
2584	switch ($FirstLeftDigit) {
2585	case 0:
2586	$Help = '4363380' . $AccountSequence;
2587	break;
2588	case 1:
2589	$Help = '4363381' . $AccountSequence;
2590	break;
2591	case 2:
2592	$Help = '4363382' . $AccountSequence;
2593	break;
2594	case 3:
2595	$Help = '4363383' . $AccountSequence;
2596	break;
2597	case 4:
2598	$Help = '4363384' . $AccountSequence;
2599	break;
2600	case 5:
2601	$Help = '4363385' . $AccountSequence;
2602	break;
2603	case 6:
2604	$Help = '4363386' . $AccountSequence;
2605	break;
2606	case 7:
2607	$Help = '4363387' . $AccountSequence;
2608	break;
2609	case 9:
2610	$Help = '4363389' . $AccountSequence;
2611	break;
2612	} /* end switch */
2613	// Methode 00, 16. Stelle Pruefziffer, Modulator 10,
2614	// Pruefziffer NICHT verschieben, ExpandAccount NICHT anwenden.
2615	$markD1 = $this->Method00($Help, '212121212121212', 16, 10, 0, 1);
2616	}
2617	return $markD1;
2618	}
2619
2620	/* --- Added FrankM 20081208 --- */
2621	private function MarkD2($AccountNo) {
2622	// Zuerst mit Methode 95 pruefen.
2623	$markD2 = $this->Mark95($AccountNo);
2624	// Wenn Pruefzifferfehler, dann mit Methode 00 pruefen.
2625	if ($markD2 == 1) {
2626	$markD2 = $this->Mark00($AccountNo);
2627	// Wenn Pruefzifferfehler, dann mit Methode 68 pruefen.
2628	if ($markD2 == 1) {
2629	$markD2 = $this->Mark68($AccountNo);
2630	}
2631	}
2632	return $markD2;
2633	}
2634
2635	/* --- Added FrankM 20081208 --- */
2636	private function MarkD3($AccountNo) {
2637	$AccountNo = $this->ExpandAccount($AccountNo);
2638	$markD3 = $this->Mark00($AccountNo);
2639	// Wenn Pruefzifferfehler, dann mit Methode 27 pruefen.
2640	if ($markD3 == 1) {
2641	$markD3 = $this->Mark27($AccountNo);
2642	}
2643	return $markD3;
2644	}
2645
2646	/* --- Added FrankM 20100602 --- */
2647	/* --- Changed Christian Rothe 20110606 --- */
2648	/* --- 20110606: Aenderung des Verfahrens durch die Bundesbank --- */
2649	private function MarkD4($AccountNo) {
2650	$AccountNo = $this->ExpandAccount($AccountNo);
2651	if ((substr($AccountNo, 0, 1) == "0")) {
2652	$markD4 = 1;
2653	} else {
2654	$Help = '428259' . $AccountNo;
2655
2656	// Methode 00, 16. Stelle Pruefziffer, Modulator 10,
2657	// Pruefziffer NICHT verschieben, ExpandAccount NICHT anwenden.
2658	$markD4 = $this->Method00($Help, '212121212121212', 16, 10, 0, 1);
2659	}
2660	return $markD4;
2661	}
2662
2663	/* --- Added Christian Rothe 20101206 --- */
2664	private function MarkD5($AccountNo) {
2665	$AccountNo = $this->ExpandAccount($AccountNo);
2666	if (substr($AccountNo, 2, 2) == "99") {
2667	// Kontonummern mit '99' an 3. und 4. Stelle mit dieser Verfahrensvariante pruefen
2668	$markD5 = $this->Method06($AccountNo, '008765432', TRUE, 10, 11);
2669	} else {
2670	$markD5 = $this->Method06($AccountNo, '000765432', TRUE, 10, 11);
2671	// Wenn Pruefzifferfehler, dann weiter pruefen mit Modulus 7.
2672	if ($markD5) {
2673	$markD5 = $this->Method90($AccountNo, '000765432', 10, 7);
2674	}
2675	// Wenn Pruefzifferfehler, dann weiter pruefen mit Modulus 10.
2676	if ($markD5) {
2677	$markD5 = $this->Method90($AccountNo, '000765432', 10, 10);
2678	}
2679	}
2680	return $markD5;
2681	}
2682
2683	/* --- Added Christian Rothe 20110327 --- */
2684	private function MarkD6($AccountNo) {
2685	$AccountNo = $this->ExpandAccount($AccountNo);
2686	// Zunaechst pruefen mit Methode 07
2687	$markD6 = $this->Mark07($AccountNo);
2688	// Wenn Pruefzifferfehler, dann weiter pruefen mit Methode 03.
2689	if ($markD6) {
2690	$markD6 = $this->Mark03($AccountNo);
2691	}
2692	// Wenn Pruefzifferfehler, dann weiter pruefen mit Methode 00.
2693	if ($markD6) {
2694	$markD6 = $this->Mark00($AccountNo);
2695	}
2696	return $markD6;
2697	}
2698
2699	/* --- Added Christian Rothe 20110606 --- */
2700	private function MarkD7($AccountNo) {
2701	$AccountNo = $this->ExpandAccount($AccountNo);
2702	$markD7 = $this->Method00($AccountNo, '212121212', 10, 10, 0, 0, 'D7');
2703	return $markD7;
2704	}
2705
2706	/* --- Added Christian Rothe 20110606 --- */
2707	private function MarkD8($AccountNo) {
2708	$AccountNo = $this->ExpandAccount($AccountNo);
2709	// Kontonummern aus dem Nummernkreis 1000000000 bis 9999999999 mit Methode 00 pruefen
2710	$markD8 = 1;
2711	if (($AccountNo >= 1000000000) And ($AccountNo <= 9999999999)) {
2712	$markD8 = $this->Mark00($AccountNo);
2713	} elseif (($AccountNo >= '0010000000') And ($AccountNo <= '0099999999')) {
2714	// Fuer Kontonummernkreis 0010000000 bis 0099999999 mit Methode 09 pruefen
2715	$markD8 = $this->Mark09($AccountNo);
2716	}
2717	return $markD8;
2718	}
2719
2720	/* --- Added Christian Rothe 20120606 --- */
2721	private function MarkD9($AccountNo) {
2722	$AccountNo = $this->ExpandAccount($AccountNo);
2723	$markD9 = $this->Method00($AccountNo, '212121212', 10, 10, 0, 0, 'D9');
2724	// Wenn Pruefzifferfehler, dann weiter pruefen mit Methode 10.
2725	if ($markD9) {
2726	$markD9 = $this->Mark10($AccountNo);
2727	}
2728	// Wenn Pruefzifferfehler, dann weiter pruefen mit Methode 18.
2729	if ($markD9) {
2730	$markD9 = $this->Mark18($AccountNo);
2731	}
2732	return $markD9;
2733	}
2734
2735	/* --- Added Christian Rothe 20130309 --- */
2736	private function MarkE0($AccountNo) {
2737	$AccountNo = $this->ExpandAccount($AccountNo);
2738	$markE0 = $this->Method00($AccountNo, '212121212', strlen($AccountNo), 10, 0, 0, 'E0');
2739	return $markE0;
2740	}
2741
2742	/* --- Added Christian Rothe 20131209 --- */
2743	private function MarkE1($AccountNo) {
2744	$markE1 = 1;
2745	$AccountNo = $this->ExpandAccount($AccountNo);
2746	$Help = 0;
2747	$Significance = array(9, 10, 11, 6, 5, 4, 3, 2, 1);
2748	// Rechnen mit ASCII-Repräsentation der Zahlen
2749	for ($Run = 0; $Run < sizeof($Significance);$Run++) {
2750	$Help += ((substr($AccountNo,$Run,1) + 48) * $Significance[$Run]);
2751	}
2752	$Checksum = $Help % 11;
2753	if ($Checksum < 10 && $Checksum == substr($AccountNo,-1)) {
2754	$markE1 = 0;
2755	}
2756	return $markE1;
2757	}
2758
2759	/* ----- Ende Endgueltige Funktionen der einzelnen Berechnungsmethoden. ---- */
2760
2761	/* -------- Dies ist die wichtigste function ---------- */
2762	function CheckAccount($banktransfer_number, $banktransfer_blz) {
2763	$KontoNR = preg_replace('/[^0-9]/', '', $banktransfer_number); // Hetfield - 2009-08-19 - replaced deprecated function ereg_replace with preg_replace to be ready for PHP >= 5.3
2764	$BLZ = preg_replace('/[^0-9]/', '', $banktransfer_blz); // Hetfield - 2009-08-19 - replaced deprecated function ereg_replace with preg_replace to be ready for PHP >= 5.3
2765
2766	$Result = 0;
2767	if ((int)$BLZ == 0 \|\| strlen($BLZ) < 8) {
2768	return 8; /* Keine BLZ übergeben */
2769	}
2770	if ((int) $KontoNR == 0) {
2771	return 9; /* Keine Kontonummer übergeben */
2772	}
2773
2774	/* Beginn Implementierung */
2775	$adata = $this->query($BLZ);
2776	if ($adata == -1) {
2777	$Result = 5; // BLZ nicht gefunden;
2778	$PRZ = -1;
2779	$this->PRZ = $PRZ;
2780	$this->banktransfer_number=ltrim($banktransfer_number,"0");
2781	$this->banktransfer_blz=$banktransfer_blz;
2782	} else {
2783	$this->Bankname = $adata['bankname'];
2784	$this->PRZ = str_pad ($adata['prz'], 2, "0", STR_PAD_LEFT);
2785	$this->banktransfer_number=ltrim($banktransfer_number,"0");
2786	//$this->banktransfer_number=$this->ExpandAccount($banktransfer_number);
2787	$this->banktransfer_blz=$banktransfer_blz;
2788
2789	$PRZ = $adata['prz'];
2790
2791	switch ($PRZ) {
2792	case "52" :
2793	$Result = $this->Mark52($KontoNR, $BLZ);
2794	break;
2795	case "53" :
2796	$Result = $this->Mark53($KontoNR, $BLZ);
2797	break;
2798	/* --- Added FrankM 20060112 --- */
2799	case "B6" :
2800	$Result = $this->MarkB6($KontoNR, $BLZ);
2801	break;
2802	case "C0" :
2803	$Result = $this->MarkC0($KontoNR, $BLZ);
2804	break;
2805	default:
2806	$MethodName = "Mark$PRZ";
2807	if (method_exists($this, $MethodName)){
2808	$Result = call_user_func (array($this, $MethodName), $KontoNR);
2809	} else {
2810	$Result = 3;
2811	}
2812	} /* end switch */
2813
2814	} /* end if num_rows */
2815
2816	if ($Result > 0 && $this->checkmode == 'iban') {
2817	$Result += 2000;
2818	}
2819
2820	return $Result;
2821	} /* End of CheckAccount */
2822
2823	/* --------
2824	Diese Funktion liefert eine Beurteilung, ob eine Kontonummer grundsätzlich
2825	angenommen und für Zahlungen verwendet werden kann
2826	---------- */
2827
2828	function account_acceptable($check_result) {
2829	$result = false;
2830	if ( $check_result == 0 \|\|
2831	$check_result == 2 \|\|
2832	$check_result == 3 \|\|
2833	$check_result == 4 \|\|
2834	$check_result == 2002 \|\|
2835	$check_result == 2003 \|\|
2836	$check_result == 2004) {
2837	$result = true;
2838	}
2839	return $result;
2840	}
2841
2842	/*
2843	// Funktionen zu Testen einzelner Methoden mit von Bundesbank angegebenen Testkontonummern
2844	// Für Produktivbetrieb auskommentieren
2845
2846	function devTest($KontoNR, $PRZ) {
2847
2848	$MethodName = "Mark$PRZ";
2849	$Result = call_user_func (array($this, $MethodName), $KontoNR);
2850
2851	return $Result;
2852
2853	}
2854	*/
2855
2856	} /* End Class AccountCheck */
2857
2858
2859
2860	class IbanAccountCheck extends AccountCheck {
2861	private $ibanstructure = Array();
2862
2863	/*
2864	-----------------------------------------------------------------------------------------
2865	Copyright (c) 2013 Christian Rothe
2866	-----------------------------------------------------------------------------------------
2867	*/
2868
2869	/* Folgende Returncodes werden übergeben */
2870	/* */
2871	/* 0 -> IBAN ist okay */
2872	/* 1000 -> Länderkennung ist unbekannt */
2873	/* 1010 -> Länge der IBAN ist falsch: Zu viele Stellen */
2874	/* 1020 -> Länge der IBAN ist falsch: Zu wenige Stellen */
2875	/* 1030 -> IBAN entspricht nicht dem für das Land festgelegten Format */
2876	/* 1040 -> Prüfsumme der IBAN ist nicht korrekt -> Tippfehler */
2877	/* 1050 -> BIC ist ungültig */
2878	/* 1060 -> Länge des BIC ist falsch: Zu viele Stellen */
2879	/* 1070 -> Länge des BIC ist falsch: Zu wenige Stellen */
2880	/* 1080 -> Länge des BIC ist ungültig */
2881
2882	/* Zusätzlich werden für Deutsche Konten folgende Returncodes übergeben */
2883	/* 2001 -> Deutsche Kontonummer & deutsche BLZ passen nicht */
2884	/* 2002 -> Für diese Kontonummer kein deutsches Prüfziffernverfahren definiert */
2885	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
2886	/* 2003 -> Dieses Deutsche Prüfziffernverfahren ist noch nicht implementiert */
2887	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
2888	/* 2004 -> Diese Kontonummer ist mit deutschen Methoden im Detail nicht prüfbar */
2889	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
2890	/* 2005 -> Deutsche BLZ nicht gefunden */
2891	/* 2008 -> Keine deutsche BLZ übergeben */
2892	/* 2009 -> Keine deutsche Kontonummer übergeben */
2893	/* 2010 -> Kein Kontoinhaber übergeben */
2894	/* 2020 -> BIC ist ungültig */
2895	/* 2128 -> interner Fehler, der zeigt, dass eine Methode nicht implementiert ist */
2896	/* */
2897
2898	function __construct() {
2899
2900	parent::__construct();
2901
2902	$this->banktransfer_iban = ''; // Enthält nach der Prüfung die geprüfte IBAN
2903	$this->banktransfer_bic = ''; // Enthält nach der Prüfung den geprüften BIC
2904	$this->IBAN_country = ''; // Enthält nach der Prüfung das Land der geprüften IBAN
2905
2906	// Basis-Informationen / Definition zu IBAN-Kontonummern der einzelnen Länder einlesen
2907	$this->init();
2908	$this->checkmode = 'iban';
2909	}
2910
2911	function IbanCheckAccount($iban, $bic = null) {
2912
2913	$result = $this->is_valid_iban($iban);
2914
2915	// Keine BIC-Überprüfung / keine BIC-Fehlermeldungen bei deutschen Shops,
2916	// wenn IBAN eine deutsche IBAN ist und BIC nicht eingegebn
2917	if ($this->get_store_ctryiso2() == 'DE' && $this->iban_get_ctryiso2($iban) == 'DE' && $bic == '') {
2918	$bic = null;
2919	}
2920
2921	if ($result == 0 && isset($bic)) {
2922	$result = $this->is_valid_bic($bic,$iban);
2923	}
2924
2925	// IBAN und BIC für spätere Verwendung nach außen verfügbar machen
2926	$this->banktransfer_iban = $this->iban_trim($iban);
2927	$this->banktransfer_bic = $this->bic_trim($bic);
2928	$this->IBAN_country = $this->iban_get_ctryiso2($iban);
2929
2930	return $result;
2931
2932	}
2933
2934	function is_valid_iban($iban, $use_german_check = true) {
2935
2936	$result = 0;
2937
2938	if (!$this->iban_check_country($iban)) {
2939	$result = 1000;
2940	}
2941
2942	// Länge der IBAN prüfen
2943	if ($result == 0) {
2944	$temp_result = $this->iban_check_length($iban);
2945	if ($temp_result) {
2946	$result = $temp_result;
2947	}
2948	}
2949
2950	// Format der IBAN anhand von regulären Ausdrücken prüfen
2951	if ($result == 0 && !$this->iban_check_format($iban)) {
2952	$result = 1030;
2953	}
2954
2955	// IBAN-Fehler über Prüfsumme aufdecken
2956	if ($result == 0 && !$this->iban_check_checksum($iban)) {
2957	$result = 1040;
2958	}
2959
2960	// Detail-Check für deutsche IBAN-Nummern
2961	if ($result == 0 && $this->iban_get_ctryiso2($iban) == 'DE' && $use_german_check) {
2962	$result = $this->iban_check_german_account($iban);
2963	}
2964
2965	return $result;
2966
2967	}
2968
2969	function is_valid_bic($bic, $iban = null) {
2970
2971	$result = 0;
2972
2973	$temp_result = $this->bic_check_length($bic);
2974	if ($temp_result) {
2975	$result = $temp_result;
2976	}
2977
2978	if ($result == 0 && !$this->bic_validate($bic)) {
2979	$result = 1050;
2980	}
2981
2982	// Detail-Check für deutsche Konto: Existiert BIC?
2983	if ($result == 0 && isset($iban) && $this->iban_get_ctryiso2($iban) == 'DE') {
2984	$result = $this->bic_check_german_account($bic, $iban);
2985	}
2986
2987	return $result;
2988	}
2989
2990	function iban_check_country($iban) {
2991
2992	// Länge der IBAN prüfen
2993	$iban = $this->iban_trim($iban);
2994	$ctry_iso_2 = $this->iban_get_ctryiso2($iban);
2995
2996	if (isset($this->ibanstructure[$ctry_iso_2])) {
2997	return true;
2998	}
2999
3000	return false;
3001
3002	}
3003
3004	function iban_check_length($iban) {
3005
3006	// Länge der IBAN prüfen
3007	$iban = $this->iban_trim($iban);
3008	$ctry_iso_2 = $this->iban_get_ctryiso2($iban);
3009
3010	if (strlen($iban) > $this->ibanstructure[$ctry_iso_2]['length']) {
3011	return 1010;
3012	} elseif (strlen($iban) < $this->ibanstructure[$ctry_iso_2]['length']) {
3013	return 1020;
3014	}
3015
3016	return false;
3017
3018	}
3019
3020	function iban_check_format($iban) {
3021
3022	// Format der IBAN anhand von regulären Ausdrücken prüfen
3023	$result = true;
3024
3025	$iban = $this->iban_trim($iban);
3026	$ctry_iso_2 = $this->iban_get_ctryiso2($iban);
3027
3028	if (isset($this->ibanstructure[$ctry_iso_2]['regex'])) {
3029	if (!preg_match('/^' . $this->ibanstructure[$ctry_iso_2]['regex'] . '$/', $iban)) {
3030	$result = false;
3031	}
3032	}
3033
3034	return $result;
3035
3036	}
3037
3038	function iban_get_ctryiso2($iban) {
3039
3040	// Land aus IBAN extrahieren
3041
3042	$iban = $this->iban_trim($iban);
3043	$ctry_iso_2 = substr($iban,0,2);
3044
3045	return $ctry_iso_2;
3046	}
3047
3048	function iban_check_checksum($iban) {
3049
3050	// IBAN-Fehler über Prüfsumme aufdecken
3051
3052	$result = false;
3053
3054	$iban = $this->iban_trim($iban);
3055
3056	$iban1 = substr($iban, 4) . substr($iban, 0, 4);
3057	$iban1 = str_replace(
3058	array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
3059	'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'),
3060	array('10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22',
3061	'23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35'),
3062	$iban1);
3063
3064	$help = intval(substr($iban1, 0, 1));
3065	$len = strlen($iban1);
3066	for ($x = 1; $x < $len; ++$x) {
3067	$help *= 10;
3068	$help += intval(substr($iban1, $x, 1));
3069	$help %= 97;
3070	}
3071
3072	if ($help == 1) {
3073	$result = true;
3074	}
3075
3076	return $result;
3077
3078	}
3079
3080	function iban_check_german_account($iban) {
3081
3082	// Überprüfe deutsche Kontonummern mit den Prüfziffern-Methoden der Deutschen Bundesbank
3083
3084	$iban = $this->iban_trim($iban);
3085	$kontonr = substr($iban, 12, 10);
3086	$blz = substr($iban, 4, 8);
3087
3088	$result = $this->CheckAccount($kontonr,$blz);
3089
3090	return $result;
3091
3092	}
3093
3094	function is_sepa_country($ctry_iso2) {
3095
3096	$result = false;
3097
3098	if ($this->ibanstructure[$ctry_iso2]['sepa_ctry']) {
3099	$result = true;
3100	}
3101
3102	return $result;
3103
3104	}
3105
3106	function iban_trim($iban) {
3107
3108	// IBAN auf einheitliches Format mit Großbuchstaben und ohne Leerstellen bringen
3109	// Swift (BIC) können damit ebenfalls formatiert werden
3110	$iban = trim($iban);
3111	$iban = strtoupper($iban);
3112	$iban = preg_replace('/[^A-Z0-9]/','',$iban);
3113
3114	return $iban;
3115
3116	}
3117
3118	function iban_format_human($iban) {
3119
3120	// IBAN in durch Leerzeichen getrennte Vierergruppen formatieren
3121
3122	$iban = $this->iban_trim($iban);
3123
3124	$quadrupel_count = ceil(strlen($iban)/4);
3125	$iban_formatted = substr($iban,0,4);
3126
3127	for ($i = 1, $n = $quadrupel_count; $i < $n; $i++) {
3128	$iban_formatted .= ' '.substr($iban,($i*4),4);
3129	}
3130
3131	return $iban_formatted;
3132
3133	}
3134
3135	function bic_trim($bic) {
3136
3137	$bic = $this->iban_trim($bic);
3138
3139	return $bic;
3140
3141	}
3142
3143	function init() {
3144
3145	/*
3146	Dabei bedeutet:
3147	AD, BE, ... Länderkennzeichen
3148	pp zweistellige Prüfsumme
3149	b Stelle der Bankleitzahl
3150	d Kontotyp
3151	k Stelle der Kontonummer
3152	K Kontrollziffern
3153	r Regionalcode
3154	s Stelle der Filialnummer (Branch Code / code guichet)
3155	X sonstige Funktionen
3156	*/
3157
3158	$this->ibanstructure = array(
3159	// Albanien
3160	'AL' => array( 'scheme' => 'ALpp bbbs sssK kkkk kkkk kkkk kkkk',
3161	'regex' => 'AL[0-9]{2}[0-9]{8}[A-Z0-9]{16}',
3162	'length' => 28,
3163	'sepa_ctry' => false,
3164	'bank_start_pos' => 5,
3165	'bank_length' => 8),
3166	// Andorra
3167	'AD' => array( 'scheme' => 'ADpp bbbb ssss kkkk kkkk kkkk',
3168	'regex' => 'AD[0-9]{2}[0-9]{4}[0-9]{4}[A-Z0-9]{12}',
3169	'length' => 24,
3170	'sepa_ctry' => false,
3171	'bank_start_pos' => 5,
3172	'bank_length' => 8),
3173	// Aserbaidschan
3174	'AZ' => array( 'scheme' => 'AZpp bbbb kkkk kkkk kkkk kkkk kkkk',
3175	'regex' => 'AZ[0-9]{2}[A-Z]{4}[A-Z0-9]{20}',
3176	'length' => 28,
3177	'sepa_ctry' => false,
3178	'bank_start_pos' => 5,
3179	'bank_length' => 5),
3180	// Bahrain
3181	'BH' => array( 'scheme' => 'BHpp bbbb kkkk kkkk kkkk kk',
3182	'regex' => 'BH[0-9]{2}[A-Z]{4}[A-Z0-9]{14}',
3183	'length' => 22,
3184	'sepa_ctry' => false,
3185	'bank_start_pos' => 5,
3186	'bank_length' => 4),
3187	// Belgien
3188	'BE' => array( 'scheme' => 'BEpp bbbk kkkk kkKK',
3189	'regex' => 'BE[0-9]{2}[0-9]{3}[0-9]{7}[0-9]{2}',
3190	'length' => 16,
3191	'sepa_ctry' => true,
3192	'bank_start_pos' => 5,
3193	'bank_length' => 3),
3194	// Bosnien und Herzegowina
3195	'BA' => array( 'scheme' => 'BApp bbbs sskk kkkk kkKK',
3196	'regex' => 'BA[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{8}[0-9]{2}',
3197	'length' => 20,
3198	'sepa_ctry' => false,
3199	'bank_start_pos' => 5,
3200	'bank_length' => 7),
3201	// Brasilien
3202	'BR' => array( 'scheme' => 'BRpp bbbb bbbb ssss skkk kkkk kkkk k',
3203	'regex' => 'BR[0-9]{2}[0-9]{8}[0-9]{5}[0-9]{10}[A-Z][A-Z0-9]',
3204	'length' => 29,
3205	'sepa_ctry' => false,
3206	'bank_start_pos' => 5,
3207	'bank_length' => 13),
3208	// Bulgarien
3209	'BG' => array( 'scheme' => 'BGpp bbbb ssss ddkk kkkk kk',
3210	'regex' => 'BG[0-9]{2}[A-Z]{4}[0-9]{4}[0-9]{2}[A-Z0-9]{8}',
3211	'length' => 22,
3212	'sepa_ctry' => true,
3213	'bank_start_pos' => 5,
3214	'bank_length' => 8),
3215	// Costa Rica
3216	'CR' => array( 'scheme' => 'CRpp bbbk kkkk kkkk kkkk k',
3217	'regex' => 'CR[0-9]{2}[0-9]{3}[0-9]{14}',
3218	'length' => 21,
3219	'sepa_ctry' => false,
3220	'bank_start_pos' => 5,
3221	'bank_length' => 3),
3222	// Dänemark
3223	'DK' => array( 'scheme' => 'DKpp bbbb kkkk kkkk kK',
3224	'regex' => 'DK[0-9]{2}[0-9]{14}',
3225	'length' => 18,
3226	'sepa_ctry' => true,
3227	'bank_start_pos' => 5,
3228	'bank_length' => 4),
3229	// Deutschland
3230	'DE' => array( 'scheme' => 'DEpp bbbb bbbb kkkk kkkk kk',
3231	'regex' => 'DE[0-9]{2}[0-9]{8}[0-9]{10}',
3232	'length' => 22,
3233	'sepa_ctry' => true,
3234	'bank_start_pos' => 5,
3235	'bank_length' => 8),
3236	// Dominikanische Republik
3237	'DO' => array( 'scheme' => 'DOpp bbbb kkkk kkkk kkkk kkkk kkkk',
3238	'regex' => 'DO[0-9]{2}[A-Z0-9]{4}[0-9]{20}',
3239	'length' => 28,
3240	'sepa_ctry' => false,
3241	'bank_start_pos' => 5,
3242	'bank_length' => 4),
3243	// Estland
3244	'EE' => array( 'scheme' => 'EEpp bbkk kkkk kkkk kkkK',
3245	'regex' => 'EE[0-9]{2}[0-9]{2}[0-9]{2}[0-9]{11}[0-9]{1}',
3246	'length' => 20,
3247	'sepa_ctry' => true,
3248	'bank_start_pos' => 5,
3249	'bank_length' => 4),
3250	// Faröer Insel
3251	'FO' => array( 'scheme' => 'FOpp bbbb kkkk kkkk kK',
3252	'regex' => 'FO[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}',
3253	'length' => 18,
3254	'sepa_ctry' => true,
3255	'bank_start_pos' => 5,
3256	'bank_length' => 4),
3257	// Finnland
3258	'FI' => array( 'scheme' => 'FIpp bbbb bbkk kkkk kK',
3259	'regex' => 'FI[0-9]{2}[0-9]{6}[0-9]{7}[0-9]{1}',
3260	'length' => 18,
3261	'sepa_ctry' => true,
3262	'bank_start_pos' => 5,
3263	'bank_length' => 6),
3264	// Frankreich
3265	'FR' => array( 'scheme' => 'FRpp bbbb bsss sskk kkkk kkkk kKK',
3266	'regex' => 'FR[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}',
3267	'length' => 27,
3268	'sepa_ctry' => true,
3269	'bank_start_pos' => 5,
3270	'bank_length' => 10),
3271	// Georgien
3272	'GE' => array( 'scheme' => 'GEpp bbkk kkkk kkkk kkkk kk',
3273	'regex' => 'GE[0-9]{2}[A-Z]{2}[0-9]{16}',
3274	'length' => 22,
3275	'sepa_ctry' => false,
3276	'bank_start_pos' => 5,
3277	'bank_length' => 2),
3278	// Gibraltar
3279	'GI' => array( 'scheme' => 'GIpp bbbb kkkk kkkk kkkk kkk',
3280	'regex' => 'GI[0-9]{2}[A-Z]{4}[A-Z0-9]{15}',
3281	'length' => 23,
3282	'sepa_ctry' => true,
3283	'bank_start_pos' => 5,
3284	'bank_length' => 4),
3285	// Griechenland
3286	'GR' => array( 'scheme' => 'GRpp bbbs sssk kkkk kkkk kkkk kkk',
3287	'regex' => 'GR[0-9]{2}[0-9]{3}[0-9]{4}[A-Z0-9]{16}',
3288	'length' => 27,
3289	'sepa_ctry' => true,
3290	'bank_start_pos' => 5,
3291	'bank_length' => 7),
3292	// Grönland
3293	'GL' => array( 'scheme' => 'GLpp bbbb kkkk kkkk kK',
3294	'regex' => 'GL[0-9]{2}[0-9]{4}[0-9]{9}[0-9]{1}',
3295	'length' => 18,
3296	'sepa_ctry' => true,
3297	'bank_start_pos' => 5,
3298	'bank_length' => 4),
3299	// Großbritannien
3300	'GB' => array( 'scheme' => 'GBpp bbbb ssss sskk kkkk kk',
3301	'regex' => 'GB[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}',
3302	'length' => 22,
3303	'sepa_ctry' => true,
3304	'bank_start_pos' => 5,
3305	'bank_length' => 4),
3306	// Guadeloupe
3307	'GP' => array( 'scheme' => 'GPpp bbbb bsss sskk kkkk kkkk kKK',
3308	'regex' => null,
3309	'length' => 27,
3310	'sepa_ctry' => false,
3311	'bank_start_pos' => 5,
3312	'bank_length' => 10),
3313	// Guatemala
3314	'GT' => array( 'scheme' => 'GTpp bbbb kkkk kkkk kkkk kkkk kkkk',
3315	'regex' => 'GT[0-9]{2}[A-Z0-9]{4}[A-Z0-9]{20}',
3316	'length' => 28,
3317	'sepa_ctry' => false,
3318	'bank_start_pos' => 5,
3319	'bank_length' => 4),
3320	// Hongkong
3321	'HK' => array( 'scheme' => 'HKpp bbbb kkkk kkkk',
3322	'regex' => null,
3323	'length' => 16,
3324	'sepa_ctry' => false,
3325	'bank_start_pos' => 5,
3326	'bank_length' => 4),
3327	// Irland
3328	'IE' => array( 'scheme' => 'IEpp bbbb ssss sskk kkkk kk',
3329	'regex' => 'IE[0-9]{2}[A-Z]{4}[0-9]{6}[0-9]{8}',
3330	'length' => 22,
3331	'sepa_ctry' => true,
3332	'bank_start_pos' => 5,
3333	'bank_length' => 10),
3334	// Island
3335	'IS' => array( 'scheme' => 'ISpp bbbb sskk kkkk XXXX XXXX XX',
3336	'regex' => 'IS[0-9]{2}[0-9]{4}[0-9]{2}[0-9]{6}[0-9]{10}',
3337	'length' => 26,
3338	'sepa_ctry' => true,
3339	'bank_start_pos' => 5,
3340	'bank_length' => 6),
3341	// Israel
3342	'IL' => array( 'scheme' => 'ILpp bbbs sskk kkkk kkkk kkk',
3343	'regex' => 'IL[0-9]{2}[0-9]{3}[0-9]{3}[0-9]{13}',
3344	'length' => 23,
3345	'sepa_ctry' => false,
3346	'bank_start_pos' => 5,
3347	'bank_length' => 6),
3348	// Italien
3349	'IT' => array( 'scheme' => 'ITpp Kbbb bbss sssk kkkk kkkk kkk',
3350	'regex' => 'IT[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}',
3351	'length' => 27,
3352	'sepa_ctry' => true,
3353	'bank_start_pos' => 6,
3354	'bank_length' => 10),
3355	// Jordanien
3356	'JO' => array( 'scheme' => 'JOpp bbbb ssss kkkk kkkk kkkk kkkk kk',
3357	'regex' => null,
3358	'length' => 30,
3359	'sepa_ctry' => false,
3360	'bank_start_pos' => 5,
3361	'bank_length' => 8),
3362	// Jungferninseln
3363	'VG' => array( 'scheme' => 'VGpp bbbb kkkk kkkk kkkk kkkk',
3364	'regex' => 'VG[0-9]{2}[A-Z]{4}[0-9]{16}',
3365	'length' => 24,
3366	'sepa_ctry' => false,
3367	'bank_start_pos' => 5,
3368	'bank_length' => 4),
3369	// Kasachstan
3370	'KZ' => array( 'scheme' => 'KZpp bbbk kkkk kkkk kkkk',
3371	'regex' => 'KZ[0-9]{2}[0-9]{3}[A-Z0-9]{13}',
3372	'length' => 20,
3373	'sepa_ctry' => false,
3374	'bank_start_pos' => 5,
3375	'bank_length' => 3),
3376	// Katar
3377	'QA' => array( 'scheme' => 'QApp bbbb kkkk kkkk kkkk kkkk kkkk k',
3378	'regex' => null,
3379	'length' => 29,
3380	'sepa_ctry' => false,
3381	'bank_start_pos' => 5,
3382	'bank_length' => 4),
3383	// Kroatien
3384	'HR' => array( 'scheme' => 'HRpp bbbb bbbk kkkk kkkk k',
3385	'regex' => 'HR[0-9]{2}[0-9]{7}[0-9]{10}',
3386	'length' => 21,
3387	'sepa_ctry' => false,
3388	'bank_start_pos' => 5,
3389	'bank_length' => 7),
3390	// Kuwait
3391	'KW' => array( 'scheme' => 'KWpp bbbb kkkk kkkk kkkk kkkk kkkk kk',
3392	'regex' => 'KW[0-9]{2}[A-Z]{4}[0-9]{22}',
3393	'length' => 30,
3394	'sepa_ctry' => false,
3395	'bank_start_pos' => 5,
3396	'bank_length' => 4),
3397	// Lettland
3398	'LV' => array( 'scheme' => 'LVpp bbbb kkkk kkkk kkkk k',
3399	'regex' => 'LV[0-9]{2}[A-Z]{4}[A-Z0-9]{13}',
3400	'length' => 21,
3401	'sepa_ctry' => true,
3402	'bank_start_pos' => 5,
3403	'bank_length' => 4),
3404	// Libanon
3405	'LB' => array( 'scheme' => 'LBpp bbbb kkkk kkkk kkkk kkkk kkkk',
3406	'regex' => 'LB[0-9]{2}[0-9]{4}[A-Z0-9]{20}',
3407	'length' => 28,
3408	'sepa_ctry' => false,
3409	'bank_start_pos' => 5,
3410	'bank_length' => 4),
3411	// Liechtenstein
3412	'LI' => array( 'scheme' => 'LIpp bbbb bkkk kkkk kkkk k',
3413	'regex' => 'LI[0-9]{2}[0-9]{5}[A-Z0-9]{12}',
3414	'length' => 21,
3415	'sepa_ctry' => true,
3416	'bank_start_pos' => 5,
3417	'bank_length' => 5),
3418	// Litauen
3419	'LT' => array( 'scheme' => 'LTpp bbbb bkkk kkkk kkkk',
3420	'regex' => 'LT[0-9]{2}[0-9]{5}[0-9]{11}',
3421	'length' => 20,
3422	'sepa_ctry' => true,
3423	'bank_start_pos' => 5,
3424	'bank_length' => 5),
3425	// Luxemburg
3426	'LU' => array( 'scheme' => 'LUpp bbbk kkkk kkkk kkkk',
3427	'regex' => 'LU[0-9]{2}[0-9]{3}[A-Z0-9]{13}',
3428	'length' => 20,
3429	'sepa_ctry' => true,
3430	'bank_start_pos' => 5,
3431	'bank_length' => 3),
3432	// Malta
3433	'MT' => array( 'scheme' => 'MTpp bbbb ssss skkk kkkk kkkk kkkk kkk',
3434	'regex' => 'MT[0-9]{2}[A-Z]{4}[0-9]{5}[A-Z0-9]{18}',
3435	'length' => 31,
3436	'sepa_ctry' => true,
3437	'bank_start_pos' => 5,
3438	'bank_length' => 9),
3439	// Marokko
3440	'MT' => array( 'scheme' => 'MApp bbba aakk kkkk kkkk kkKK',
3441	'regex' => null,
3442	'length' => 24,
3443	'sepa_ctry' => false,
3444	'bank_start_pos' => 5,
3445	'bank_length' => 3),
3446	// Martinique
3447	'MQ' => array( 'scheme' => 'MQpp bbbb bsss sskk kkkk kkkk kKK',
3448	'regex' => null,
3449	'length' => 27,
3450	'sepa_ctry' => false,
3451	'bank_start_pos' => 5,
3452	'bank_length' => 10),
3453	// Mauretanien
3454	'MR' => array( 'scheme' => 'MRpp bbbb bsss sskk kkkk kkkk kKK',
3455	'regex' => 'MR13[0-9]{5}[0-9]{5}[0-9]{11}[0-9]{2}',
3456	'length' => 27,
3457	'sepa_ctry' => false,
3458	'bank_start_pos' => 5,
3459	'bank_length' => 10),
3460	// Mauritius
3461	'MU' => array( 'scheme' => 'MUpp bbbb bbss kkkk kkkk kkkk kkkK KK',
3462	'regex' => 'MU[0-9]{2}[A-Z]{4}[0-9]{2}[0-9]{2}[0-9]{12}[0-9]{3}[A-Z]{3}',
3463	'length' => 30,
3464	'sepa_ctry' => false,
3465	'bank_start_pos' => 5,
3466	'bank_length' => 7),
3467	// Mazedonien
3468	'MK' => array( 'scheme' => 'MKpp bbbk kkkk kkkk kKK',
3469	'regex' => 'MK[0-9]{2}[0-9]{3}[A-Z0-9]{10}[0-9]{2}',
3470	'length' => 19,
3471	'sepa_ctry' => false,
3472	'bank_start_pos' => 5,
3473	'bank_length' => 3),
3474	// Moldawien
3475	'MD' => array( 'scheme' => 'MDpp bbkk kkkk kkkk kkkk kkkk',
3476	'regex' => 'MD[0-9]{2}[A-Z0-9]{20}',
3477	'length' => 24,
3478	'sepa_ctry' => false,
3479	'bank_start_pos' => 5,
3480	'bank_length' => 2),
3481	// Monaco
3482	'MC' => array( 'scheme' => 'MCpp bbbb bsss sskk kkkk kkkk kKK',
3483	'regex' => 'MC[0-9]{2}[0-9]{5}[0-9]{5}[A-Z0-9]{11}[0-9]{2}',
3484	'length' => 27,
3485	'sepa_ctry' => true,
3486	'bank_start_pos' => 5,
3487	'bank_length' => 10),
3488	// Montenegro
3489	'ME' => array( 'scheme' => 'MEpp bbbk kkkk kkkk kkkk KK',
3490	'regex' => 'ME[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',
3491	'length' => 20,
3492	'sepa_ctry' => false,
3493	'bank_start_pos' => 5,
3494	'bank_length' => 3),
3495	// Neukaledonien
3496	'NC' => array( 'scheme' => 'NCpp bbbb bsss sskk kkkk kkkk kKK',
3497	'regex' => null,
3498	'length' => 30,
3499	'sepa_ctry' => false,
3500	'bank_start_pos' => 5,
3501	'bank_length' => 10),
3502	// Niederlande
3503	'NL' => array( 'scheme' => 'NLpp bbbb kkkk kkkk kk',
3504	'regex' => 'NL[0-9]{2}[A-Z]{4}[0-9]{10}',
3505	'length' => 18,
3506	'sepa_ctry' => true,
3507	'bank_start_pos' => 5,
3508	'bank_length' => 4),
3509	// Norwegen
3510	'NO' => array( 'scheme' => 'NOpp bbbb kkkk kkK',
3511	'regex' => 'NO[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{1}',
3512	'length' => 15,
3513	'sepa_ctry' => true,
3514	'bank_start_pos' => 5,
3515	'bank_length' => 4),
3516	// Österreich
3517	'AT' => array( 'scheme' => 'ATpp bbbb bkkk kkkk kkkk',
3518	'regex' => 'AT[0-9]{2}[0-9]{5}[0-9]{11}',
3519	'length' => 20,
3520	'sepa_ctry' => true,
3521	'bank_start_pos' => 5,
3522	'bank_length' => 5),
3523	// Pakistan
3524	'PK' => array( 'scheme' => 'PKpp bbbb rrkk kkkk kkkk kkkk',
3525	'regex' => 'PK[0-9]{2}[A-Z]{4}[A-Z0-9]{16}',
3526	'length' => 24,
3527	'sepa_ctry' => false,
3528	'bank_start_pos' => 5,
3529	'bank_length' => 6),
3530	// Polen
3531	'PL' => array( 'scheme' => 'PLpp bbbs sssK kkkk kkkk kkkk kkkk',
3532	'regex' => 'PL[0-9]{2}[0-9]{8}[0-9]{16}',
3533	'length' => 28,
3534	'sepa_ctry' => true,
3535	'bank_start_pos' => 5,
3536	'bank_length' => 8),
3537	// Palästinensische Autonomiegebiete
3538	'PS' => array( 'scheme' => 'PSpp bbbb rrrr rrrr rkkk kkkk kkkk k',
3539	'regex' => 'PS[0-9]{2}[A-Z]{4}[A-Z0-9]{21}',
3540	'length' => 29,
3541	'sepa_ctry' => false,
3542	'bank_start_pos' => 5,
3543	'bank_length' => 13),
3544	// Portugal
3545	'PT' => array( 'scheme' => 'PTpp bbbb ssss kkkk kkkk kkkK K',
3546	'regex' => 'PT[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{11}[0-9]{2}',
3547	'length' => 25,
3548	'sepa_ctry' => true,
3549	'bank_start_pos' => 5,
3550	'bank_length' => 8),
3551	// Réunion
3552	'RE' => array( 'scheme' => 'REpp bbbb bsss sskk kkkk kkkk kKK',
3553	'regex' => null,
3554	'length' => 27,
3555	'sepa_ctry' => false,
3556	'bank_start_pos' => 5,
3557	'bank_length' => 10),
3558	// Rumänien*
3559	'RO' => array( 'scheme' => 'ROpp bbbb kkkk kkkk kkkk kkkk',
3560	'regex' => 'RO[0-9]{2}[A-Z]{4}[A-Z0-9]{16}',
3561	'length' => 24,
3562	'sepa_ctry' => true,
3563	'bank_start_pos' => 5,
3564	'bank_length' => 4),
3565	// San Marino
3566	'SM' => array( 'scheme' => 'SMpp Kbbb bbss sssk kkkk kkkk kkk',
3567	'regex' => 'SM[0-9]{2}[A-Z]{1}[0-9]{5}[0-9]{5}[A-Z0-9]{12}',
3568	'length' => 27,
3569	'sepa_ctry' => false,
3570	'bank_start_pos' => 6,
3571	'bank_length' => 10),
3572	// Saudi-Arabien
3573	'SA' => array( 'scheme' => 'SApp bbkk kkkk kkkk kkkk kkkk',
3574	'regex' => 'SA[0-9]{2}[0-9]{2}[A-Z0-9]{18}',
3575	'length' => 24,
3576	'sepa_ctry' => false,
3577	'bank_start_pos' => 5,
3578	'bank_length' => 2),
3579	// Schweden
3580	'SE' => array( 'scheme' => 'SEpp bbbk kkkk kkkk kkkk kkkK',
3581	'regex' => 'SE[0-9]{2}[0-9]{3}[0-9]{16}[0-9]{1}',
3582	'length' => 24,
3583	'sepa_ctry' => true,
3584	'bank_start_pos' => 5,
3585	'bank_length' => 3),
3586	// Schweiz
3587	'CH' => array( 'scheme' => 'CHpp bbbb bkkk kkkk kkkk k',
3588	'regex' => 'CH[0-9]{2}[0-9]{5}[A-Z0-9]{12}',
3589	'length' => 21,
3590	'sepa_ctry' => true,
3591	'bank_start_pos' => 5,
3592	'bank_length' => 5),
3593	// Serbien
3594	'RS' => array( 'scheme' => 'RSpp bbbk kkkk kkkk kkkk KK',
3595	'regex' => 'RS[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',
3596	'length' => 22,
3597	'sepa_ctry' => false,
3598	'bank_start_pos' => 5,
3599	'bank_length' => 3),
3600	// Slowakei
3601	'SK' => array( 'scheme' => 'SKpp bbbb ssss sskk kkkk kkkk',
3602	'regex' => 'SK[0-9]{2}[0-9]{4}[0-9]{6}[0-9]{10}',
3603	'length' => 24,
3604	'sepa_ctry' => true,
3605	'bank_start_pos' => 5,
3606	'bank_length' => 4),
3607	// Slowenien
3608	'SI' => array( 'scheme' => 'SIpp bbss skkk kkkk kKK',
3609	'regex' => 'SI[0-9]{2}[0-9]{5}[0-9]{8}[0-9]{2}',
3610	'length' => 19,
3611	'sepa_ctry' => true,
3612	'bank_start_pos' => 5,
3613	'bank_length' => 5),
3614	// Spanien
3615	'ES' => array( 'scheme' => 'ESpp bbbb ssss KKkk kkkk kkkk',
3616	'regex' => 'ES[0-9]{2}[0-9]{4}[0-9]{4}[0-9]{1}[0-9]{1}[0-9]{10}',
3617	'length' => 24,
3618	'sepa_ctry' => true,
3619	'bank_start_pos' => 5,
3620	'bank_length' => 8),
3621	// Tschechien
3622	'CZ' => array( 'scheme' => 'CZpp bbbb kkkk kkkk kkkk kkkk',
3623	'regex' => 'CZ[0-9]{2}[0-9]{20}',
3624	'length' => 24,
3625	'sepa_ctry' => true,
3626	'bank_start_pos' => 5,
3627	'bank_length' => 4),
3628	// Türkei
3629	'TR' => array( 'scheme' => 'TRpp bbbb brkk kkkk kkkk kkkk kk',
3630	'regex' => 'TR[0-9]{2}[0-9]{5}[A-Z0-9]{1}[A-Z0-9]{16}',
3631	'length' => 26,
3632	'sepa_ctry' => false,
3633	'bank_start_pos' => 5,
3634	'bank_length' => 6),
3635	// Tunesien
3636	'TN' => array( 'scheme' => 'TNpp bbss skkk kkkk kkkk kkKK',
3637	'regex' => 'TN59[0-9]{2}[0-9]{3}[0-9]{13}[0-9]{2}',
3638	'length' => 24,
3639	'sepa_ctry' => false,
3640	'bank_start_pos' => 5,
3641	'bank_length' => 5),
3642	// Ungarn
3643	'HU' => array( 'scheme' => 'HUpp bbbs sssK kkkk kkkk kkkk kkkK',
3644	'regex' => 'HU[0-9]{2}[0-9]{3}[0-9]{4}[0-9]{1}[0-9]{15}[0-9]{1}',
3645	'length' => 28,
3646	'sepa_ctry' => true,
3647	'bank_start_pos' => 5,
3648	'bank_length' => 7),
3649	// Vereinigte Arabische Emirate
3650	'AE' => array( 'scheme' => 'AEpp bbbk kkkk kkkk kkkk kkk',
3651	'regex' => 'AE[0-9]{2}[0-9]{3}[0-9]{16}',
3652	'length' => 23,
3653	'sepa_ctry' => false,
3654	'bank_start_pos' => 5,
3655	'bank_length' => 3),
3656	// Zypern
3657	'CY' => array( 'scheme' => 'CYpp bbbs ssss kkkk kkkk kkkk kkkk',
3658	'regex' => 'CY[0-9]{2}[0-9]{3}[0-9]{5}[A-Z0-9]{16}',
3659	'length' => 28,
3660	'sepa_ctry' => true,
3661	'bank_start_pos' => 5,
3662	'bank_length' => 8),
3663	);
3664
3665
3666
3667
3668
3669	}
3670
3671
3672	function bic_check_length($bic) {
3673
3674	// Länge des BIC prüfen
3675	if (strlen($bic) > 11) {
3676	return 1060;
3677	} elseif (strlen($bic) < 8) {
3678	return 1070;
3679	} elseif (strlen($bic) != 8 && strlen($bic) != 11) {
3680	return 1080;
3681	};
3682
3683	return false;
3684
3685	}
3686
3687
3688	function bic_validate($bic) {
3689
3690	/*
3691	Der BIC oder SWIFT-Code hat eine Länge von 8 oder 11 alphanumerischen Zeichen und folgenden Aufbau: BBBBCCLLbbb
3692	Bedeutung
3693	BBBB: nur Buchstaben 4-stelliger Bankcode, vom Geldinstitut frei wählbar
3694	CC: nur Buchstaben 2-stelliger Ländercode nach ISO 3166-1
3695	LL: Buchstaben/Ziffern 2-stellige Codierung des Ortes in zwei Zeichen.
3696	Das erste Zeichen darf nicht die Ziffer "0" oder "1" sein.
3697	Wenn das zweite Zeichen kein Buchstabe, sondern eine Ziffer ist, so bedeutet dies:
3698	0 es handelt sich um eine Test-BIC
3699	1 es handelt sich um einen passiven SWIFT-Teilnehmer
3700	2 der Empfänger zahlt die Transaktionskosten
3701	Der Buchstabe 'O' ist als zweites Zeichen nicht gestattet.
3702	bbb: Buchstaben/Ziffern 3-stellige Kennzeichnung (Branch-Code) der Filiale oder Abteilung (optional)
3703	Ein 8-stelliger BIC kann um "XXX" auf einen 11-stelligen ergänzt werden, entsprechend kann "XXX" auch weggelassen werden,
3704	andere Kennzeichen nicht. Der Branch-Code darf nicht mit "X" anfangen, es sei denn, es ist "XXX".
3705	*/
3706
3707	$bic = $this->bic_trim($bic);
3708
3709	$result = false;
3710	if(preg_match('/^([A-Z]){4}([A-Z]){2}([0-9A-Z]){2}([0-9A-Z]{3})?$/', $bic)) {
3711	$result = true;
3712	}
3713	// Stellen 7 und 8: 2-stellige Codierung des Ortes in zwei Zeichen. Das erste Zeichen davon darf nicht die Ziffer "0" oder "1" sein. Der Buchstabe 'O' ist als zweites Zeichen nicht gestattet.
3714	if (substr($bic,6,1) == '0' \|\| substr($bic,6,1) == '1') {
3715	$result = false;
3716	}
3717	if (substr($bic,7,1) == 'O') {
3718	$result = false;
3719	}
3720	// Der Branch-Code darf nicht mit "X" anfangen, es sei denn, es ist "XXX".
3721	if (substr($bic,8,1) == 'X' && substr($bic,8,3) != 'XXX') {
3722	$result = false;
3723	}
3724
3725	return $result;
3726
3727	}
3728
3729	function get_bic($blz) {
3730	$result = false;
3731	$check_blz = $this->query($blz);
3732	if ($check_blz != -1 && isset($check_blz['bic'])) {
3733	$result = $check_blz['bic'];
3734	}
3735	return $result;
3736	}
3737
3738	function get_bankname($blz) {
3739	$result = false;
3740	$check_blz = $this->query($blz);
3741	if ($check_blz != -1 && isset($check_blz['bankname'])) {
3742	$result = $check_blz['bankname'];
3743	}
3744	return $result;
3745	}
3746
3747	function bic_check_german_account($bic, $iban) {
3748
3749	// Überprüfe, ob BIC in BLZ-Daten der Deutschen Bundesbank vorhanden ist.
3750
3751	$result = 0;
3752
3753	if (MODULE_PAYMENT_BANKTRANSFER_DATABASE_BLZ == 'true' && defined(MODULE_PAYMENT_BANKTRANSFER_DATABASE_BLZ)) {
3754	// Zunächst prüfen, ob BIC-Spalte in Bankleitzahlen-Tabelle enthalten
3755	$table_query = xtc_db_query("SHOW COLUMNS from ".TABLE_BANKTRANSFER_BLZ." where Field = 'bic'");
3756	if (xtc_db_num_rows($table_query) > 0) {
3757
3758	// Okay: BIC-Spalte existiert
3759	// Wir prüfen also den BIC
3760	$result = 2020;
3761
3762	$bic = $this->bic_trim($bic);
3763	$bic_padded = str_pad($bic, 11, "X", STR_PAD_RIGHT);
3764
3765	$german_bank_query = xtc_db_query("select * from ".TABLE_BANKTRANSFER_BLZ." where bic = '".xtc_db_input($bic)."' or bic = '".xtc_db_input($bic_padded)."' limit 1");
3766
3767	if ($german_bank = xtc_db_fetch_array($german_bank_query)) {
3768	$result = 0;
3769	}
3770
3771	}
3772	}
3773
3774	return $result;
3775
3776	}
3777
3778	function bban_to_iban($bban, $ctry_iso2) {
3779
3780	// Leerzeichen entfernen und Buchstaben in Großbuchstaben verwandeln
3781	$ctry_iso2 = $this->iban_trim($ctry_iso2);
3782	$bban = $this->iban_trim($bban);
3783
3784	$iban_tmp = $bban . $ctry_iso2.'00';
3785
3786	$iban_tmp = str_replace(
3787	array('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
3788	'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'),
3789	array('10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22',
3790	'23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35'),
3791	$iban_tmp);
3792
3793
3794	$modulo = (bcmod($iban_tmp,"97"));
3795	$pruefziffer = str_pad ( 98 - $modulo, 2, "0",STR_PAD_LEFT);
3796	$iban = $ctry_iso2 . $pruefziffer . $bban;
3797
3798	// Ergebnis überprüfen
3799	$checkresult = $this->is_valid_iban($iban, false);
3800	if ($checkresult > 0) {
3801	$iban = false;
3802	}
3803
3804	return $iban;
3805
3806	}
3807
3808
3809	function message($error_code) {
3810
3811	/* Folgende Error-Codes werden berücksichtigt */
3812	/* */
3813
3814	/* 0 -> Bankverbindung ist okay */
3815
3816	/* 1 -> Kontonummer & BLZ passen nicht */
3817	/* 2 -> Für diese Kontonummer ist kein Prüfziffernverfahren definiert */
3818	/* 3 -> Dieses Prüfziffernverfahren ist noch nicht implementiert */
3819	/* 4 -> Diese Kontonummer ist technisch nicht prüfbar */
3820	/* 5 -> BLZ nicht gefunden */
3821	/* 8 -> Keine BLZ übergeben */
3822	/* 9 -> Keine Kontonummer übergeben */
3823	/* 10 -> Kein Kontoinhaber übergeben */
3824	/* 128 -> interner Fehler, der zeigt, dass eine Methode nicht implementiert ist */
3825
3826	/* 1000 -> Länderkennung ist unbekannt */
3827	/* 1010 -> Länge der IBAN ist falsch: Zu viele Stellen */
3828	/* 1020 -> Länge der IBAN ist falsch: Zu wenige Stellen */
3829	/* 1030 -> IBAN entspricht nicht dem für das Land festgelegten Format */
3830	/* 1040 -> Prüfsumme der IBAN ist nicht korrekt -> Tippfehler */
3831	/* 1050 -> BIC ist ungültig */
3832	/* 1060 -> Länge des BIC ist falsch: Zu viele Stellen */
3833	/* 1070 -> Länge des BIC ist falsch: Zu wenige Stellen */
3834	/* 1080 -> Länge des BIC ist ungültig */
3835
3836	/* 2001 -> Deutsche Kontonummer & deutsche BLZ passen nicht */
3837	/* 2002 -> Für diese Kontonummer kein deutsches Prüfziffernverfahren definiert */
3838	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
3839	/* 2003 -> Dieses Deutsche Prüfziffernverfahren ist noch nicht implementiert */
3840	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
3841	/* 2004 -> Diese Kontonummer ist mit deutschen Methoden im Detail nicht prüfbar */
3842	/* Da die IBAN-Prüfung klappte, ist die Nr. wahrscheinlich trotzdem okay */
3843	/* 2005 -> Deutsche BLZ nicht gefunden */
3844	/* 2008 -> Keine deutsche BLZ übergeben */
3845	/* 2009 -> Keine deutsche Kontonummer übergeben */
3846	/* 2010 -> Kein Kontoinhaber übergeben */
3847	/* 2020 -> BIC ist ungültig */
3848	/* 2128 -> interner Fehler, der zeigt, dass eine Methode nicht implementiert ist */
3849	/* */
3850
3851
3852	if (defined('BANKACCOUNT_CHECK_TEXT_BANK_ERROR_'.(int)$error_code)) {
3853	$result = constant('BANKACCOUNT_CHECK_TEXT_BANK_ERROR_'.(int)$error_code);
3854	} else {
3855	$result = BANKACCOUNT_CHECK_TEXT_BANK_ERROR_UNKNOWN;
3856	}
3857
3858	return $result;
3859
3860	}
3861
3862	function get_store_ctryiso2() {
3863
3864	$country_query = xtc_db_query("select countries_iso_code_2 from ".TABLE_COUNTRIES." where countries_id = '".(int)STORE_COUNTRY."'");
3865	$country = xtc_db_fetch_array($country_query);
3866
3867	return $country['countries_iso_code_2'];
3868
3869	}
3870
3871
3872	} /* End Class IbanAccountCheck */
3873

Download in other formats:

Original Format