diff --git a/src/test/java/eu/mulk/aendggner/EndToEndTest.java b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
index ea014b0..2466d4c 100644
--- a/src/test/java/eu/mulk/aendggner/EndToEndTest.java
+++ b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
@@ -7,6 +7,7 @@
 
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Ersetzung;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Neufassung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Sammelbefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.StrukturEinfuegung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.UnbekannterBefehl;
@@ -2311,4 +2312,151 @@
     assertThat(abgleich.abweichungen()).isEmpty();
     assertThat(abgleich.gehtAuf()).as(abgleich.kurzbericht()).isTrue();
   }
+
+  /**
+   * Saarland, Artikel 1: Gesetz Nr. 2211 zur Änderung des Gesetzes über den Saarlandpakt (Amtsbl.
+   * des Saarlandes Teil I Nr. 31 vom 13. August 2026, S. 756). Voller Akzeptanztest — der eine
+   * Befehl wird angewandt, und alle zwanzig Normen stimmen mit der amtlichen Gesamtausgabe überein.
+   *
+   * <p>Das Portal recht.saarland.de führt wie das rheinland-pfälzische keine Fassungsliste. Die
+   * Vorfassung ist deshalb der Änderungshistorie entnommen — sie weist für das Jahr 2026 genau eine
+   * Änderung aus (§ 8a neu eingefügt) — und aus den Gesetzblättern von 2019, 2020 und 2024 Norm für
+   * Norm gegengeprüft; das Nähere sagt {@code Saarland/SOURCES}.
+   *
+   * <p>Neunzehn der zwanzig Normen stimmen zeichengenau; die zwanzigste — der eingefügte § 8a —
+   * weicht an einer Stelle ab („zuergreifen“ statt „zu ergreifen“), weil der Kopf vor dem Umbruch
+   * mit zwei Zeichen zu kurz ist, um ihn von einer Vorsilbe zu unterscheiden.
+   *
+   * <p>Zwei allgemeine Funde stammen aus diesem Heft: der Kolumnentitel des Amtsblattes, der im
+   * Inhaltsstrom steht und an der Seitenzahl klebt, und die <em>Wortfuge am markerlosen
+   * Umbruch</em> — im engen Zweispaltensatz verliert der Auszug an einer echten Wortgrenze den
+   * Zwischenraum („zusätzlich“ + „jahresbezogene“). Entschieden wird das wie beim Trennstrich am
+   * Wortbestand des Dokuments, und zwar an demjenigen ohne die zeilenletzten Wörter: Ein durch den
+   * Umbruch abgerissenes Bruchstück steht immer am Zeilenende, ein wirkliches Wort auch mitten in
+   * der Zeile.
+   */
+  @Test
+  void saarlandpaktGesetzSaarland() throws Exception {
+    var alt = SAMPLEDATA.resolve("Saarland/SPaktG-alt.txt");
+    var pdf = SAMPLEDATA.resolve("Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf");
+    assumeTrue(Files.exists(alt) && Files.exists(pdf), "Saarländische Beispieldaten fehlen");
+
+    var gesetz = new eu.mulk.aendggner.gesetz.land.LandesRechtLoader().load(alt);
+    assertThat(gesetz.jurabk()).isEqualTo("SPaktG");
+    assertThat(gesetz.normen()).hasSize(19);
+
+    var text = TextBereiniger.bereinige(new PatchTextExtraktor().extrahiere(pdf));
+    // Der Kolumnentitel ist heraus; ohne ihn steht das Zitat des eingefügten § 8a zusammenhängend
+    // da.
+    assertThat(text).doesNotContain("Amtsblatt des Saarlandes Teil I vom 13. August 2026");
+    // Die Wortfuge am markerlosen Umbruch ist geheilt.
+    assertThat(text).contains("zusätzlich jahresbezogene");
+    assertThat(text).doesNotContain("zusätzlichjahresbezogene");
+
+    var parseErgebnis = new AenderungsgesetzParser().parse(text, gesetz, null);
+    // Das Heft ändert zwei Werke; für das Gesetz wird allein Artikel 1 gewählt.
+    assertThat(parseErgebnis.artikel()).containsExactly("1");
+    assertThat(parseErgebnis.befehle()).hasSize(1);
+    assertThat(parseErgebnis.befehle()).noneMatch(b -> b instanceof UnbekannterBefehl);
+
+    var anwendung = BefehlAnwender.anwenden(gesetz, parseErgebnis.befehle());
+    assertThat(anwendung.anzahlAngewandt()).isEqualTo(1);
+    var soll =
+        new eu.mulk.aendggner.gesetz.land.LandesRechtLoader()
+            .load(SAMPLEDATA.resolve("Saarland/SPaktG-neu.txt"));
+    assertThat(soll.normen()).hasSize(20);
+    var abgleich = Nachfassungsabgleich.vergleiche(soll, anwendung.neu());
+    assertThat(abgleich.fehlende()).isEmpty();
+    assertThat(abgleich.ueberzaehlige()).isEmpty();
+    // Neunzehn der zwanzig Normen stimmen zeichengenau; allein der neu eingefügte § 8a weicht ab,
+    // und zwar an einer einzigen Stelle: „zu ergreifen“ steht dort als „zuergreifen“. Der Kopf vor
+    // dem Umbruch ist mit zwei Zeichen zu kurz, um ihn von einer Vorsilbe zu unterscheiden — und
+    // wer „aus“ + „geschlossen“ trennte, machte es schlimmer. Geraten wird nicht.
+    assertThat(abgleich.abweichungen()).hasSize(1);
+    assertThat(abgleich.abweichungen().getFirst().enbez()).isEqualTo("§ 8a");
+
+    var synopse = Pipeline.erzeugeSynopse(Pipeline.Auftrag.von(alt, List.of(pdf)));
+    assertThat(synopse.anzahlAngewandt()).isEqualTo(1);
+  }
+
+  /**
+   * Saarland, Artikel 2 desselben Heftes: die Verordnung zur Ausführung des Gesetzes über den
+   * Saarlandpakt. Ein Heft, zwei Stammwerke — und der Prüfstein für die Artikelwahl.
+   *
+   * <p>Der Fund: Die Artikelwahl streicht aus dem Vorspann die Wendung „zur Ausführung des
+   * <em>X-Gesetzes</em>“, weil ein Ausführungstitel das Stammgesetz nur als Genitiv-Attribut nennt
+   * und ein solcher Artikel nicht das Stammgesetz betrifft (so beim bayerischen AVBayJG). Ist das
+   * Ziel aber selbst eine solche Verordnung, so stand nach dem Streichen gerade ihr eigener Name
+   * nicht mehr da und <em>kein</em> Artikel wurde gewählt. Die Streichung unterbleibt nun, wenn das
+   * Ziel selbst einen Ausführungstitel führt; getroffen wird dann nur, wer den vollen Titel nennt.
+   */
+  @Test
+  void saarlandpaktVerordnungSaarland() throws Exception {
+    var alt = SAMPLEDATA.resolve("Saarland/AusfSPaktGVO-alt.txt");
+    var pdf = SAMPLEDATA.resolve("Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf");
+    assumeTrue(Files.exists(alt) && Files.exists(pdf), "Saarländische Beispieldaten fehlen");
+
+    var verordnung = new eu.mulk.aendggner.gesetz.land.LandesRechtLoader().load(alt);
+    assertThat(verordnung.jurabk()).isEqualTo("AusfSPaktGVO");
+    assertThat(verordnung.normen()).hasSize(10);
+
+    var text = TextBereiniger.bereinige(new PatchTextExtraktor().extrahiere(pdf));
+    var parseErgebnis = new AenderungsgesetzParser().parse(text, verordnung, null);
+    assertThat(parseErgebnis.artikel()).containsExactly("2");
+    assertThat(parseErgebnis.befehle()).hasSize(1);
+    assertThat(parseErgebnis.befehle()).noneMatch(b -> b instanceof UnbekannterBefehl);
+
+    pruefeGegenNachfassung(verordnung, parseErgebnis, "Saarland/AusfSPaktGVO-neu.txt");
+  }
+
+  /**
+   * Sachsen-Anhalt: der Entwurf eines Zweiten Gesetzes zur Änderung des Fischereigesetzes (Landtag
+   * von Sachsen-Anhalt, Drucksache 8/6357).
+   *
+   * <p>Wie in Rheinland-Pfalz reicht die Prüfung nur bis zur Befehlserkennung, und aus demselben
+   * Grund: Das Portal landesrecht.sachsen-anhalt.de führt keine Fassungsliste, der Stamm ist
+   * deshalb die <em>Nachfassung</em> (die Vorlage ist am 21. März 2026 Gesetz geworden). Das
+   * Gesetz- und Verordnungsblatt des Landes ist überdies nicht frei; frei ist allein die
+   * Parlamentsdokumentation, weshalb hier die Drucksache das Änderungsdokument ist.
+   *
+   * <p>Der Fund liegt in der Gliederung: Sachsen-Anhalt setzt unter die Nummern nicht „a)“ und
+   * „aa)“, sondern <b>„a.“ und kleine römische Zahlen „i.“, „ii.“</b>. Beide Formen sind den
+   * Klammerformen wesensgleich; nur das Satzzeichen unterscheidet sie. „i.“ ist dabei zweideutig —
+   * als Buchstabe die neunte, als Zahl die erste Marke; entschieden wird es aus dem Stand der
+   * Gliederung. Dazu kommt die Nebenform „erhält die Fassung“ und der wahlfreie Doppelpunkt vor dem
+   * Zitat.
+   *
+   * <p>Nicht erkannt bleiben zwei Formen, und zwar zu Recht: „In § 31 Abs. 2 wie folgt geändert:“ —
+   * dem Satz fehlt das Verb, ein Verkündungsfehler der Vorlage — und die auslassende Anfügung „Als
+   * Abs. 2 neu angefügt: „…““. Geraten wird nicht.
+   */
+  @Test
+  void fischereigesetzSachsenAnhalt() throws Exception {
+    var stamm = SAMPLEDATA.resolve("SachsenAnhalt/FischG-LSA-neu.txt");
+    var pdf = SAMPLEDATA.resolve("SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf");
+    assumeTrue(Files.exists(stamm) && Files.exists(pdf), "Beispieldaten Sachsen-Anhalts fehlen");
+
+    var gesetz = new eu.mulk.aendggner.gesetz.land.LandesRechtLoader().load(stamm);
+    assertThat(gesetz.jurabk()).isEqualTo("FischG");
+    assertThat(gesetz.normen()).hasSize(59);
+
+    var text = TextBereiniger.bereinige(new PatchTextExtraktor().extrahiere(pdf));
+    var parseErgebnis = new AenderungsgesetzParser().parse(text, gesetz, null);
+    assertThat(parseErgebnis.artikel()).containsExactly("1");
+    assertThat(parseErgebnis.befehle()).hasSize(14);
+
+    // Die Buchstabengliederung mit Punkt und die römische Unterebene sind aufgeschlossen: Nummer 1
+    // trägt fünf Buchstaben, und unter b. und e. stehen je zwei römische Punkte.
+    assertThat(befehlAn(parseErgebnis, "1. b) i)")).isNotNull();
+    assertThat(befehlAn(parseErgebnis, "1. b) ii)")).isNotNull();
+    assertThat(befehlAn(parseErgebnis, "1. e) ii)")).isNotNull();
+
+    // Die Nebenform „erhält die Fassung“ ohne Doppelpunkt wird als Neufassung gelesen.
+    assertThat(befehlAn(parseErgebnis, "1. a)")).isInstanceOf(Neufassung.class);
+
+    // Dass die meisten Befehle ihr Ziel nicht mehr finden, liegt am Stand des Stammes und nicht am
+    // Erzeugnis: Die Vorlage ist bereits Gesetz geworden.
+    var anwendung = BefehlAnwender.anwenden(gesetz, parseErgebnis.befehle());
+    assertThat(anwendung.anzahlAngewandt()).isEqualTo(4);
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java
index 4ef441d..34678f5 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java
@@ -136,6 +136,33 @@
         .isEqualTo("unterhalb eines Schwellenwertes von 50\nWohnungen.");
   }
 
+  /**
+   * Amtsbl. des Saarlandes: Im engen Zweispaltensatz verliert der Auszug auch an einer echten
+   * Wortfuge den Zwischenraum. Der Wortbestand entscheidet — und zwar derjenige <em>ohne</em> die
+   * zeilenletzten Wörter, denn ein durch den Umbruch abgerissenes Bruchstück steht immer am
+   * Zeilenende.
+   */
+  @Test
+  void setztAnDerWortfugeEinenZwischenraum() {
+    var roh =
+        "Abweichend werden zusätzlich Fehlbeträge in Höhe zugelassen. \n"
+            + "Bei jeder Gemeinde werden in Planung und Ausführung zusätzlich\n"
+            + "jahresbezogene Fehlbeträge in Höhe der Ergebnisse zugelassen. ";
+
+    assertThat(TextBereiniger.bereinige(roh)).contains("zusätzlich jahresbezogene Fehlbeträge");
+  }
+
+  /** Ein Kopf von weniger als vier Zeichen ist von einer Vorsilbe nicht zu unterscheiden. */
+  @Test
+  void laesstKurzeKoepfeAmUmbruchZusammengezogen() {
+    var roh =
+        "Als Gutachterin darf nicht bestellt werden, wer aus \n"
+            + "dem Amt des ehrenamtlichen Richters ist davon aus\n"
+            + "geschlossen und wird deshalb nicht berufen werden. ";
+
+    assertThat(TextBereiniger.bereinige(roh)).contains("ausgeschlossen und wird");
+  }
+
   @Test
   void ziehtOhneTrailingSpaceKonventionKeineMarkerlosenTrennungenZusammen() {
     // Handgeschriebene Klartextdateien: kein Trailing-Space-Signal → kein Join.
diff --git a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
index 3ed028b..8eed3f7 100644
--- a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
+++ b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
@@ -90,6 +90,31 @@
     assertThat(ergebnis.protokoll().get(0).begruendung()).contains("mehrdeutig");
   }
 
+  /**
+   * Die Aufzählungsmarke am Anfang einer Einheit ist deren Kennzeichnung und nicht ihr Wortlaut:
+   * Wer „in Nummer 3 den Punkt durch ein Komma ersetzt“, meint den Schlusspunkt und nicht den Punkt
+   * der Marke. Ohne diese Schranke stünde der Punkt zweimal da und der Befehl bliebe als mehrdeutig
+   * liegen (Amtsbl. des Saarlandes 2020 S. 1339, Artikel 2 Nummer 1).
+   */
+  @Test
+  void zaehltDieAufzaehlungsmarkeNichtZumWortlaut() {
+    var befehl =
+        new Ersetzung(
+            stelle(new Stelle.Paragraph("1"), new Stelle.AbsatzNr("2"), new Stelle.NummerNr("3")),
+            ".",
+            ",",
+            false,
+            false,
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(gesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "§ 1", 1))
+        .contains("3. die Ausgabe von Synopsen,")
+        .doesNotContain("3, die Ausgabe");
+  }
+
   @Test
   void wendetJeweilsErsetzungAufAlleVorkommenAn() {
     var befehl =
diff --git a/src/test/resources/sampledata/Landesrecht-Beispiele.adoc b/src/test/resources/sampledata/Landesrecht-Beispiele.adoc
index fa1f7b7..b433d94 100644
--- a/src/test/resources/sampledata/Landesrecht-Beispiele.adoc
+++ b/src/test/resources/sampledata/Landesrecht-Beispiele.adoc
@@ -156,6 +156,34 @@
 *Einleitung*" als Ziel, und die Verweisung auf einen anderen Punkt („entsprechend der vorstehenden
 Nummer 8 Buchst. a").
 
+|Saarland
+|`Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf` — Amtsbl. des Saarlandes Teil I Nr. 31 vom
+13.08.2026 (Gesetz Nr. 2211 zur Änderung des Gesetzes über den Saarlandpakt)
+|Voller Belegfall, und zwar für *zwei* Stammwerke aus einem Heft: Artikel 1 das Gesetz (SPaktG,
+19 → 20 Normen, 19 davon zeichengenau), Artikel 2 die Verordnung zu seiner Ausführung
+(AusfSPaktGVO, 10/10). Das Portal führt keine Fassungsliste; die Vorfassung ist der
+*Änderungshistorie* entnommen — sie weist für 2026 je genau eine Änderung aus — und aus den
+Gesetzblättern von 2019, 2020 und 2024 gegengeprüft. Das Amtsblatt selbst ist frei und
+skriptlesbar (`amtsblatt.saarland.de`, kein Einseitenprogramm), zurück bis Ausgabe 48/2009.
+Drei allgemeine Funde: der *Kolumnentitel* des Amtsblattes im Inhaltsstrom, die *Artikelwahl bei
+Ausführungsverordnungen* (die Genitiv-Streichung darf nicht greifen, wenn das Ziel selbst eine
+solche Verordnung ist) und die *Wortfuge am markerlosen Umbruch* (Wortbestand ohne die
+zeilenletzten Wörter). Offen bleibt der Kopf von weniger als vier Zeichen, der von einer Vorsilbe
+nicht zu unterscheiden ist — daran hängt die eine Abweichung in § 8a.
+
+|Sachsen-Anhalt
+|`SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf` — Landtag von Sachsen-Anhalt,
+Drs. 8/6357 vom 11.12.2025 (Entwurf eines Zweiten Gesetzes zur Änderung des Fischereigesetzes)
+|Nur bis zur *Befehlserkennung* belegt (14 Befehle), und zwar doppelt begründet: Das Portal führt
+keine Vorfassung, und das GVBl. LSA ist überhaupt nicht frei — abrufbar sind nur die
+Inhaltsverzeichnisse der letzten Hefte. Frei ist die Parlamentsdokumentation
+(`padoka.landtag.sachsen-anhalt.de`), weshalb hier die *Drucksache* das Änderungsdokument ist.
+Fund: die *Buchstabengliederung mit Punkt* („a.“) und die *kleinen römischen Zahlen* („i.“, „ii.“)
+als dritte Ebene; „i.“ ist zweideutig und wird aus dem Stand der Gliederung entschieden. Dazu die
+Nebenform „erhält die Fassung“ und der wahlfreie Doppelpunkt vor dem Zitat. Offen: die auslassende
+Anfügung („Als Abs. 2 neu angefügt: …“) und, an der Vorlage, das fehlende Verb in „In § 31 Abs. 2
+wie folgt geändert:“.
+
 |Thüringen
 |`Thueringen/GVBl-TH-2026-02_KiGaFinanzVO-AendVO-ua.pdf` — GVBl. Freistaat Thüringen Nr. 2 vom
 13.02.2026 (u. a. Vierte Verordnung zur Änderung der Thüringer Kindergartenfinanzierungs-
@@ -350,10 +378,18 @@
 * *Vorfassungen bei knapp gehaltenen juris-Portalen* — Rheinland-Pfalz, Saarland und
   Sachsen-Anhalt führen nur die aktuelle Gesamtausgabe nebst einer Aufzählung der Änderungen; die
   Schaltfläche „Gesamtausgaben-Liste", über die Hessen, Schleswig-Holstein, Berlin und
-  Baden-Württemberg jede Fassung datierbar ausgeben, fehlt dort. Ohne Vorfassung ist kein
-  Akzeptanzfall möglich, sondern nur die Prüfung bis zur Befehlserkennung. Ein Ausweg wäre, die
-  Vorfassung aus den *Einzelnormen* mit ihren Stichtagen zusammenzusetzen.
-* Saarland und Sachsen-Anhalt: noch nicht erfasst.
+  Baden-Württemberg jede Fassung datierbar ausgeben, fehlt dort. Für das Saarland hilft seit
+  Welle 27 die *Änderungshistorie* aus: Weist sie für das fragliche Jahr genau eine Änderung aus,
+  so ist die Vorfassung die Gesamtausgabe ohne diese eine — gegengeprüft an den Gesetzblättern.
+  Für Rheinland-Pfalz und Sachsen-Anhalt hat sich kein solcher Fall gefunden; dort bleibt es bei
+  der Prüfung bis zur Befehlserkennung. Ein weiterer Ausweg wäre, die Vorfassung aus den
+  *Einzelnormen* mit ihren Stichtagen zusammenzusetzen.
+* *Die kurze Wortfuge* — ein Kopf von weniger als vier Zeichen vor einem markerlosen Umbruch ist
+  von einer Vorsilbe nicht zu unterscheiden („aus" + „geschlossen" gegen „zu" + „ergreifen"). Ein
+  Wörterbuch fehlt, der Wortbestand des Dokuments trägt hier nicht, und geraten wird nicht.
+* *Zwei Befehlsformen Sachsen-Anhalts* — die auslassende Anfügung („Als Abs. 2 neu angefügt: …")
+  und, aus dem saarländischen Heft von 2024, die Anfügung an die Überschrift des Werkes selbst
+  sowie der Verbund aus Bereichsumnummerierung und Wortstreichung.
 
 == Wo weitermachen
 
@@ -364,8 +400,9 @@
 Klartext aus. Ein weiteres Land kostet damit Stammfassung, Heft und Nachfassung — keinen eigenen
 Prüfcode mehr. Nach absteigendem Nutzen:
 
-. *Weitere Länder erfassen* — Saarland und Sachsen-Anhalt (Bremen und Mecklenburg-Vorpommern sind
-  seit Welle 25 erfasst). Die Beschaffungswege sind für alle geprüft (26./27.08.2026):
+. *Weitere Länder erfassen* — **erledigt in Welle 27**: Mit dem Saarland und Sachsen-Anhalt ist
+  der Länderkreis geschlossen; alle sechzehn Länder sind erfasst. Die Beschaffungswege im
+  einzelnen:
 +
 --
 Mecklenburg-Vorpommern:: *Gegangen* (Welle 25). Das Gesetzblatt liegt vollständig und
@@ -389,9 +426,22 @@
 `gesetzblatt.bremen.de/fastmedia/218/<JJJJ_MM_TT>_GBl_Nr_<NNNN>_signed.pdf`, die Heftliste
 (`gesetzblatt.bremen.de/?skip=<N>&max=100`) nennt zu jedem den geänderten Gegenstand. Siehe
 `Bremen/SOURCES`.
-Saarland und Sachsen-Anhalt:: unverändert ohne Vorfassungen (siehe „Noch offen“); dort bleibt es
-bei der Prüfung bis zur Befehlserkennung, es sei denn, die Einzelnormen mit ihren Stichtagen
-tragen.
+Saarland:: *Gegangen* (Welle 27). Das Verkündungsportal `amtsblatt.saarland.de` ist ein
+gewöhnliches, skriptlesbares jportal; die fünf jüngsten Hefte hängen an der Startseite
+(`/jportal/docs/news_anlage/sl/pdf/VerkBl/ABl/ads_<Nr>-<Jahr>_teil_I_signed.pdf`), die älteren
+liegen unter `/jportal/docs/anlage/…` und verlangen die Sitzungskennung, die die Dokumentseite
+mitgibt. Die Dokumentkennung ist `VB-SL-ABlI<Jahr><erste Seite des Heftes>`; zu einer Fundstelle
+findet man das Heft, indem man von der Seitenzahl abwärts zählt. Das Landesrechtsportal
+`recht.saarland.de` (`bssl`) bleibt eine Einseitenanwendung ohne Fassungsliste — die Vorfassung
+kommt aus der Änderungshistorie. Siehe `Saarland/SOURCES`.
+Sachsen-Anhalt:: *Gegangen* (Welle 27), aber nur bis zur Befehlserkennung. Das GVBl. LSA ist nicht
+frei: `landesrecht-sachsen-anhalt.info/down/aletztg.pdf` gibt allein die Inhaltsverzeichnisse der
+letzten vierunddreißig Hefte aus, und der Wirt verlangt dafür eine Browserkennung (sonst 403). Das
+Änderungsdokument ist deshalb die Drucksache des Landtags:
+`padoka.landtag.sachsen-anhalt.de/files/drs/wp<WP>/drs/d<Nummer><Kürzel>.pdf`, gefunden über
+`/portal/browse.tt.html` (die Suchmaske lädt ihre Ergebnisse verzögert nach). Das
+Landesrechtsportal `landesrecht.sachsen-anhalt.de` (`bsst`) führt gleichfalls keine
+Fassungsliste. Siehe `SachsenAnhalt/SOURCES`.
 --
 
 *Erledigt in Welle 23:* Die Frage nach den _Anlagen-Nummern im gii-XML_ war falsch gestellt. Eine
diff --git a/src/test/resources/sampledata/Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf b/src/test/resources/sampledata/Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf
new file mode 100644
index 0000000..0039336
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf
Binary files differ
diff --git a/src/test/resources/sampledata/Saarland/AusfSPaktGVO-alt.txt b/src/test/resources/sampledata/Saarland/AusfSPaktGVO-alt.txt
new file mode 100644
index 0000000..5d5bf8d
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/AusfSPaktGVO-alt.txt
@@ -0,0 +1,50 @@
+Verordnung zur Ausführung des Gesetzes über den Saarlandpakt
+(AusfSPaktGVO)
+Vom 8. Januar 2020
+(Amtsbl. I S. 10)
+Aufgrund des § 17 Absatz 2 des Gesetzes über den Saarlandpakt vom 30. Oktober 2019 (Amtsbl. I S. 1033) verordnet die Landesregierung:
+§ 1  Anwendungsbereich
+Diese Verordnung regelt die Einzelheiten nach § 17 Absatz 2 des Gesetzes über den Saarlandpakt.
+§ 2  Strukturelle Liquiditätskredite zur Übernahme durch das Land
+(1) Für die Übernahme durch das Land nach den §§ 2 und 3 des Gesetzes über den Saarlandpakt errechnen sich die strukturellen Liquiditätskredite der Gemeinden zum 31. Dezember 2017 aus dem Bestand der bilanzierten Liquiditätskredite im Kernhaushalt
+1. zuzüglich der bei Eigenbetrieben und kommunalen Gesellschaften aufgenommenen Liquiditätskredite, sofern sie nicht im Bestand der Liquiditätskredite enthalten sind,
+2. abzüglich des Bestandes der liquiden Mittel,
+3. abzüglich der an Eigenbetriebe und privatrechtliche Gesellschaften gewährten Liquiditätskredite,
+4. zuzüglich des Standes der Finanzmittel aus Investitionstätigkeit,
+5. abzüglich der Mittel aus dem Kommunalen Entlastungsfonds, die zur Tilgung investiver Kredite verwendet wurden, im Jahr der Verwendung,
+6. zuzüglich der passiven Rechnungsabgrenzungsposten für die Pflege von Rasengrabstellen.
+(2) Die passiven Rechnungsabgrenzungsposten nach Absatz 1 Nummer 6 werden nur anerkannt, soweit sie nachgewiesen sind und sich die hierauf entfallenden Gebühreneinnahmen in der Höhe der bilanzierten Kassenkredite oder der liquiden Mittel niedergeschlagen haben. Hierbei kann eine pauschale Berechnung zugrunde gelegt werden. Den Rasengrabstellen stehen vergleichbare Grabstellen mit einheitlicher, nicht auf die Einzelgrabstelle bezogener Bepflanzung von Grabfeldern gleich.
+(3) Die strukturellen Liquiditätskredite der Gemeinden im Landkreis Neunkirchen zum Stand 31. Dezember 2017 werden um die über die Kreisumlage 2019 umgelegten Fehlbeträge aus abweisbaren Ausgaben des Landkreises erhöht. Die strukturellen Liquiditätskredite des Landkreises Neunkirchen werden auf null gesetzt.
+(4) Endgültig maßgeblich sind die bei den Gemeinden erhobenen und zum Stand 18. November 2019 durch die Gemeinden bestätigten Daten. Auf dieser Grundlage werden die maßgeblichen Liquiditätskredite der Gemeinden und Gemeindeverbände nach den Absätzen 1 bis 3 in Höhe der Beträge nach der Anlage zu dieser Verordnung endgültig und verbindlich festgesetzt. Soweit der Bestand der strukturellen Liquiditätskredite aufgrund einer fehlerhaften Bestätigung einer Gemeinde oder eines Gemeindeverbandes zu hoch festgesetzt wurde, ist der Unterschiedsbetrag zu dem sich bei korrekter Berechnung ergebenden Anteil vom Land übernommener Liquiditätskredite zurückzuübernehmen. Wurden die strukturellen Liquiditätskredite hierdurch zu niedrig festgesetzt, bleibt der Anteil der Gemeinde unverändert.
+(5) Die prozentualen Anteile nach § 3 Absatz 1 Satz 2 des Gesetzes über den Saarlandpakt sind auf vier Nachkommastellen zu runden.
+§ 3  Rückführung der strukturellen Liquiditätskredite der Gemeinden
+(1) Der nach § 4 des Gesetzes über den Saarlandpakt für die Rückführung maßgebliche Bestand der strukturellen Liquiditätskredite der Gemeinden zum 31. Dezember 2019 wird aus dem Bestand nach § 2, abzüglich der vom Land nach § 3 des Gesetzes über den Saarlandpakt zu übernehmenden strukturellen Liquiditätskredite, errechnet. Abweichend von § 2 Absatz 4 sind Korrekturen am Ausgangsbestand in jedem Fall zu berücksichtigen. Der Ausgangsbestand ist um Konsolidierungshilfen, die bis zu diesem Stichtag zur Tilgung investiver Kredite verwendet wurden, zu erhöhen. Die Fortschreibung für die Jahre 2018 und 2019 erfolgt mittels des Saldos aus Einzahlungen und Auszahlungen auslaufender Verwaltungstätigkeit, abzüglich der um Tilgungserstattungen bereinigten Tilgung der Kredite für Investitionen.
+(2) Der Berechnung nach Absatz 1 sind zunächst die Daten der Haushaltsplanung zugrunde zu legen. Sie sind spätestens im zweitfolgenden Jahr anhand der Daten des Jahresergebnisses zu korrigieren.
+§ 4  Tilgungsplan
+(1) Das Ministerium für Inneres, Bauen und Sport erstellt zur Rückführung der strukturellen Liquiditätskredite nach § 4 Absatz 1 und § 5 Absatz 1 Satz 3 des Gesetzes über den Saarlandpakt einen verbindlichen Tilgungsplan mit den Vorgaben für die jährlich zu erwirtschaftende Mindesttilgung, für die zur Tilgung von Krediten anzusammelnden und zu verwendenden Mittel und für den höchstzulässigen Betrag der strukturellen Liquiditätskredite. Grundlage ist ein fiktives Annuitätendarlehen mit einem gleichbleibenden jährlichen Gesamtbetrag aus Zins und Tilgung über die Gesamtlaufzeit mit einer Fälligkeit der Zahlungen am Periodenende. Bei der Berechnung können vollständige Jahreszeiträume und Zahlungen zum Monats-, Quartals- oder Jahresende zugrunde gelegt werden.
+(2) Für die Berechnung nach Absatz 1 ist ein Zinssatz von 1 Prozent zugrunde zu legen.
+(3) Sondertilgungen struktureller Liquiditätskredite lassen die Mindesttilgung unverändert.
+§ 5  Sonderregelung 2020 bis 2023
+(1) Der Bestand der strukturellen Liquiditätskredite zum Stand 31. Dezember 2023 nach § 5 Absatz 1 Satz 3 des Gesetzes über den Saarlandpakt wird errechnet, indem der nach § 3 Absatz 1 ermittelte Stand zum 31. Dezember 2019 anhand der zahlungsbezogenen Ergebnisse im Sinne des § 6 des Gesetzes über den Saarlandpakt in den Jahren 2020 bis 2023 fortgeschrieben wird. Abweichend von § 6 wird der Saldo um Einzahlungen aus Konsolidierungshilfen aus dem Kommunalen Entlastungsfonds erhöht bzw. um zurückzuzahlende Konsolidierungshilfen vermindert, soweit die Konsolidierungshilfen zur Tilgung von Liquiditätskrediten verwendet wurden oder verwendet werden sollen.
+(2) Für das Jahr 2023 sind der Berechnung nach Absatz 1 zunächst die Daten der Haushaltsplanung zugrunde zu legen. Sie sind spätestens im zweitfolgenden Jahr anhand der Daten des Jahresergebnisses zu korrigieren.
+§ 6  Normalentwicklung
+(1) Die Normalentwicklung der Normalfaktoren nach § 7 Satz 1 des Gesetzes über den Saarlandpakt ergibt sich durch Fortschreibung ihrer Basiswerte. Bezugsjahr ist jeweils das Haushaltsjahr.
+(2) Die Fortschreibung der Basiswerte bestimmt sich wie folgt:
+1. Bei der Gewerbesteuer werden als Basiswerte die Grundbeträge im Mittel des mit dem zweitvorangegangenen Jahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau der Grundbeträge aller Gemeinden im Vierjahresdurchschnitt und dem entsprechenden Wert des zweitvorangegangenen Jahres (angepasste Grundbeträge), vervielfacht mit dem Hebesatz im zweitvorangegangenen Jahr, angesetzt. Die Fortschreibung erfolgt mittels der Ergebnisse der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+2. Bei der Gewerbesteuerumlage werden als Basiswerte die angepassten Grundbeträge nach Nr. 2, vervielfacht mit dem für die Ermittlung der Gewerbesteuerumlage maßgeblichen Vomhundertsatz im zweitvorangegangenen Jahr, angesetzt. Die Fortschreibung erfolgt mittels der Ergebnisse der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+3. Bei dem Gemeindeanteil an der Einkommensteuer werden als Basiswerte die Einzahlungen des zweitvorangegangenen Jahres angesetzt. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres unter Berücksichtigung eines Abschlags aufgrund der demografischen Entwicklung in Höhe von 0,3 Prozent auf das Gesamtergebnis.
+4. Bei dem Gemeindeanteil an der Umsatzsteuer werden als Basiswerte die Einzahlungen des zweitvorangegangenen Jahres angesetzt. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres unter Berücksichtigung eines Abschlags aufgrund der demografischen Entwicklung in Höhe von 0,3 Prozent auf das Gesamtergebnis.
+5. Bei den Schlüsselzuweisungen und bei den Sonderschlüsselzuweisungen werden als Basiswerte die Ist-Zahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau aller Gemeinden im Vierjahresdurchschnitt und dem entsprechenden Wert des letzten Jahres, angesetzt. Maßgeblich ist die erste Festsetzung der Schlüsselzuweisungen für das jeweilige Jahr, auch wenn diese nur vorläufig erfolgt, unabhängig vom Zeitpunkt der Auszahlung. Die Auswirkungen des jeweiligen Zensus sind in geeigneter Weise zu berücksichtigen. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+6. Bei der Finanzausgleichsumlage werden als Basiswerte die Ist-Zahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren angesetzt. Maßgeblich ist die erste Festsetzung der Finanzausgleichsumlage für das jeweilige Jahr, auch wenn diese nur vorläufig erfolgt, unabhängig vom Zeitpunkt der Zahlung. Die Fortschreibung erfolgt mittels der Steigerungsraten nach der mittelfristigen Finanzplanung des Saarlandes des Vorjahres.
+7. Bei der Kreisumlage und bei der Regionalverbandsumlage werden als Basiswerte die Ist-Auszahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau aller Gemeinden eines Gemeindeverbandes im Vierjahresdurchschnitt und dem entsprechenden Wert des letzten Jahres, angesetzt. Maßgeblich ist die Festsetzung für das jeweilige Jahr, unabhängig vom Zeitpunkt der Auszahlung. Die Fortschreibung erfolgt mit einer vom Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium für Finanzen und Europa und im Benehmen mit dem Kommunalen Sanierungsrat festzulegenden, an der erwarteten Entwicklung orientierten Rate, die in der Regel nicht weniger als 2 Prozent beträgt.
+Im Fall einer drohenden oder bereits eingetretenen außergewöhnlichen Notsituation, von der die Gesamtheit aller Gemeinden betroffen ist, kann das Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium der Finanzen und für Wissenschaft und im Benehmen mit dem Kommunalen Sanierungsrat die Fortschreibung der Basiswerte nach den Nummern 1 bis 5 im laufenden Haushaltsjahr an die Ergebnisse der Regionalisierung der Steuerschätzung vom Mai des laufenden Haushaltsjahres anpassen.
+(3) Die Grundbeträge nach Absatz 1 ergeben sich durch Division der Gesamtsteuereinzahlungen eines Jahres durch den Hebesatz dieses Jahres.
+§ 7  Berechnung des strukturellen zahlungsbezogenen Ergebnisses
+(1) Das strukturelle zahlungsbezogene Ergebnis der Gemeinden wird errechnet, indem im zahlungsbezogenen Ergebnis nach § 6 des Gesetzes über den Saarlandpakt bei den Normalfaktoren nach § 6 dieser Verordnung die Zahlungen laut Finanzhaushalt bzw. laut Finanzrechnung durch deren Normalentwicklung nach § 6 dieser Verordnung ersetzt werden.
+(2) Bei der Grund- und Gewerbesteuer wird der Betrag nach Absatz 1 um die sich aus Hebesatzveränderungen gegenüber dem zweitvorangegangenen Haushaltsjahr ergebenden Mehr- oder Mindereinzahlungen erhöht beziehungsweise vermindert. Hierzu wird der Betrag der Normalentwicklung durch den Hebesatz des zweitvorangegangenen Jahres dividiert und mit der Differenz zum Hebesatz des laufenden Jahres multipliziert.
+§ 8  Rundungen
+Die der Berechnung zugrunde liegenden Daten und die Berechnungsergebnisse können auf 1.000 Euro gerundet werden.
+§ 9  Geltungsdauer
+Diese Verordnung gilt für die Haushaltsjahre 2020 bis 2064.
+§ 10  Inkrafttreten
+Diese Verordnung tritt mit Wirkung vom 1. Januar 2020 in Kraft.
diff --git a/src/test/resources/sampledata/Saarland/AusfSPaktGVO-neu.txt b/src/test/resources/sampledata/Saarland/AusfSPaktGVO-neu.txt
new file mode 100644
index 0000000..e33c889
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/AusfSPaktGVO-neu.txt
@@ -0,0 +1,51 @@
+Verordnung zur Ausführung des Gesetzes über den Saarlandpakt
+(AusfSPaktGVO)
+Vom 8. Januar 2020
+(Amtsbl. I S. 10)
+Aufgrund des § 17 Absatz 2 des Gesetzes über den Saarlandpakt vom 30. Oktober 2019 (Amtsbl. I S. 1033) verordnet die Landesregierung:
+§ 1  Anwendungsbereich
+Diese Verordnung regelt die Einzelheiten nach § 17 Absatz 2 des Gesetzes über den Saarlandpakt.
+§ 2  Strukturelle Liquiditätskredite zur Übernahme durch das Land
+(1) Für die Übernahme durch das Land nach den §§ 2 und 3 des Gesetzes über den Saarlandpakt errechnen sich die strukturellen Liquiditätskredite der Gemeinden zum 31. Dezember 2017 aus dem Bestand der bilanzierten Liquiditätskredite im Kernhaushalt
+1. zuzüglich der bei Eigenbetrieben und kommunalen Gesellschaften aufgenommenen Liquiditätskredite, sofern sie nicht im Bestand der Liquiditätskredite enthalten sind,
+2. abzüglich des Bestandes der liquiden Mittel,
+3. abzüglich der an Eigenbetriebe und privatrechtliche Gesellschaften gewährten Liquiditätskredite,
+4. zuzüglich des Standes der Finanzmittel aus Investitionstätigkeit,
+5. abzüglich der Mittel aus dem Kommunalen Entlastungsfonds, die zur Tilgung investiver Kredite verwendet wurden, im Jahr der Verwendung,
+6. zuzüglich der passiven Rechnungsabgrenzungsposten für die Pflege von Rasengrabstellen.
+(2) Die passiven Rechnungsabgrenzungsposten nach Absatz 1 Nummer 6 werden nur anerkannt, soweit sie nachgewiesen sind und sich die hierauf entfallenden Gebühreneinnahmen in der Höhe der bilanzierten Kassenkredite oder der liquiden Mittel niedergeschlagen haben. Hierbei kann eine pauschale Berechnung zugrunde gelegt werden. Den Rasengrabstellen stehen vergleichbare Grabstellen mit einheitlicher, nicht auf die Einzelgrabstelle bezogener Bepflanzung von Grabfeldern gleich.
+(3) Die strukturellen Liquiditätskredite der Gemeinden im Landkreis Neunkirchen zum Stand 31. Dezember 2017 werden um die über die Kreisumlage 2019 umgelegten Fehlbeträge aus abweisbaren Ausgaben des Landkreises erhöht. Die strukturellen Liquiditätskredite des Landkreises Neunkirchen werden auf null gesetzt.
+(4) Endgültig maßgeblich sind die bei den Gemeinden erhobenen und zum Stand 18. November 2019 durch die Gemeinden bestätigten Daten. Auf dieser Grundlage werden die maßgeblichen Liquiditätskredite der Gemeinden und Gemeindeverbände nach den Absätzen 1 bis 3 in Höhe der Beträge nach der Anlage zu dieser Verordnung endgültig und verbindlich festgesetzt. Soweit der Bestand der strukturellen Liquiditätskredite aufgrund einer fehlerhaften Bestätigung einer Gemeinde oder eines Gemeindeverbandes zu hoch festgesetzt wurde, ist der Unterschiedsbetrag zu dem sich bei korrekter Berechnung ergebenden Anteil vom Land übernommener Liquiditätskredite zurückzuübernehmen. Wurden die strukturellen Liquiditätskredite hierdurch zu niedrig festgesetzt, bleibt der Anteil der Gemeinde unverändert.
+(5) Die prozentualen Anteile nach § 3 Absatz 1 Satz 2 des Gesetzes über den Saarlandpakt sind auf vier Nachkommastellen zu runden.
+§ 3  Rückführung der strukturellen Liquiditätskredite der Gemeinden
+(1) Der nach § 4 des Gesetzes über den Saarlandpakt für die Rückführung maßgebliche Bestand der strukturellen Liquiditätskredite der Gemeinden zum 31. Dezember 2019 wird aus dem Bestand nach § 2, abzüglich der vom Land nach § 3 des Gesetzes über den Saarlandpakt zu übernehmenden strukturellen Liquiditätskredite, errechnet. Abweichend von § 2 Absatz 4 sind Korrekturen am Ausgangsbestand in jedem Fall zu berücksichtigen. Der Ausgangsbestand ist um Konsolidierungshilfen, die bis zu diesem Stichtag zur Tilgung investiver Kredite verwendet wurden, zu erhöhen. Die Fortschreibung für die Jahre 2018 und 2019 erfolgt mittels des Saldos aus Einzahlungen und Auszahlungen auslaufender Verwaltungstätigkeit, abzüglich der um Tilgungserstattungen bereinigten Tilgung der Kredite für Investitionen.
+(2) Der Berechnung nach Absatz 1 sind zunächst die Daten der Haushaltsplanung zugrunde zu legen. Sie sind spätestens im zweitfolgenden Jahr anhand der Daten des Jahresergebnisses zu korrigieren.
+§ 4  Tilgungsplan
+(1) Das Ministerium für Inneres, Bauen und Sport erstellt zur Rückführung der strukturellen Liquiditätskredite nach § 4 Absatz 1 und § 5 Absatz 1 Satz 3 des Gesetzes über den Saarlandpakt einen verbindlichen Tilgungsplan mit den Vorgaben für die jährlich zu erwirtschaftende Mindesttilgung, für die zur Tilgung von Krediten anzusammelnden und zu verwendenden Mittel und für den höchstzulässigen Betrag der strukturellen Liquiditätskredite. Grundlage ist ein fiktives Annuitätendarlehen mit einem gleichbleibenden jährlichen Gesamtbetrag aus Zins und Tilgung über die Gesamtlaufzeit mit einer Fälligkeit der Zahlungen am Periodenende. Bei der Berechnung können vollständige Jahreszeiträume und Zahlungen zum Monats-, Quartals- oder Jahresende zugrunde gelegt werden.
+(2) Für die Berechnung nach Absatz 1 ist ein Zinssatz von 1 Prozent zugrunde zu legen.
+(3) Sondertilgungen struktureller Liquiditätskredite lassen die Mindesttilgung unverändert.
+§ 5  Sonderregelung 2020 bis 2023
+(1) Der Bestand der strukturellen Liquiditätskredite zum Stand 31. Dezember 2023 nach § 5 Absatz 1 Satz 3 des Gesetzes über den Saarlandpakt wird errechnet, indem der nach § 3 Absatz 1 ermittelte Stand zum 31. Dezember 2019 anhand der zahlungsbezogenen Ergebnisse im Sinne des § 6 des Gesetzes über den Saarlandpakt in den Jahren 2020 bis 2023 fortgeschrieben wird. Abweichend von § 6 wird der Saldo um Einzahlungen aus Konsolidierungshilfen aus dem Kommunalen Entlastungsfonds erhöht bzw. um zurückzuzahlende Konsolidierungshilfen vermindert, soweit die Konsolidierungshilfen zur Tilgung von Liquiditätskrediten verwendet wurden oder verwendet werden sollen.
+(2) Für das Jahr 2023 sind der Berechnung nach Absatz 1 zunächst die Daten der Haushaltsplanung zugrunde zu legen. Sie sind spätestens im zweitfolgenden Jahr anhand der Daten des Jahresergebnisses zu korrigieren.
+§ 6  Normalentwicklung
+(1) Die Normalentwicklung der Normalfaktoren nach § 7 Satz 1 des Gesetzes über den Saarlandpakt ergibt sich durch Fortschreibung ihrer Basiswerte. Bezugsjahr ist jeweils das Haushaltsjahr.
+(2) Die Fortschreibung der Basiswerte bestimmt sich wie folgt:
+1. Bei der Gewerbesteuer werden als Basiswerte die Grundbeträge im Mittel des mit dem zweitvorangegangenen Jahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau der Grundbeträge aller Gemeinden im Vierjahresdurchschnitt und dem entsprechenden Wert des zweitvorangegangenen Jahres (angepasste Grundbeträge), vervielfacht mit dem Hebesatz im zweitvorangegangenen Jahr, angesetzt. Die Fortschreibung erfolgt mittels der Ergebnisse der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+2. Bei der Gewerbesteuerumlage werden als Basiswerte die angepassten Grundbeträge nach Nr. 2, vervielfacht mit dem für die Ermittlung der Gewerbesteuerumlage maßgeblichen Vomhundertsatz im zweitvorangegangenen Jahr, angesetzt. Die Fortschreibung erfolgt mittels der Ergebnisse der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+3. Bei dem Gemeindeanteil an der Einkommensteuer werden als Basiswerte die Einzahlungen des zweitvorangegangenen Jahres angesetzt. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres unter Berücksichtigung eines Abschlags aufgrund der demografischen Entwicklung in Höhe von 0,3 Prozent auf das Gesamtergebnis.
+4. Bei dem Gemeindeanteil an der Umsatzsteuer werden als Basiswerte die Einzahlungen des zweitvorangegangenen Jahres angesetzt. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres unter Berücksichtigung eines Abschlags aufgrund der demografischen Entwicklung in Höhe von 0,3 Prozent auf das Gesamtergebnis.
+5. Bei den Schlüsselzuweisungen und bei den Sonderschlüsselzuweisungen werden als Basiswerte die Ist-Zahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau aller Gemeinden im Vierjahresdurchschnitt und dem entsprechenden Wert des letzten Jahres, angesetzt. Maßgeblich ist die erste Festsetzung der Schlüsselzuweisungen für das jeweilige Jahr, auch wenn diese nur vorläufig erfolgt, unabhängig vom Zeitpunkt der Auszahlung. Die Auswirkungen des jeweiligen Zensus sind in geeigneter Weise zu berücksichtigen. Die Fortschreibung erfolgt mittels der Steigerungsraten aus den Ergebnissen der jüngsten verfügbaren Regionalisierung der Steuerschätzung des Vorjahres.
+6. Bei der Finanzausgleichsumlage werden als Basiswerte die Ist-Zahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren angesetzt. Maßgeblich ist die erste Festsetzung der Finanzausgleichsumlage für das jeweilige Jahr, auch wenn diese nur vorläufig erfolgt, unabhängig vom Zeitpunkt der Zahlung. Die Fortschreibung erfolgt mittels der Steigerungsraten nach der mittelfristigen Finanzplanung des Saarlandes des Vorjahres.
+7. Bei der Kreisumlage und bei der Regionalverbandsumlage werden als Basiswerte die Ist-Auszahlungen im Mittel des mit dem Vorjahr endenden Zeitraums von vier Jahren, verändert um die prozentuale Differenz zwischen dem Gesamtniveau aller Gemeinden eines Gemeindeverbandes im Vierjahresdurchschnitt und dem entsprechenden Wert des letzten Jahres, angesetzt. Maßgeblich ist die Festsetzung für das jeweilige Jahr, unabhängig vom Zeitpunkt der Auszahlung. Die Fortschreibung erfolgt mit einer vom Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium für Finanzen und Europa und im Benehmen mit dem Kommunalen Sanierungsrat festzulegenden, an der erwarteten Entwicklung orientierten Rate, die in der Regel nicht weniger als 2 Prozent beträgt.
+Im Fall einer drohenden oder bereits eingetretenen außergewöhnlichen Notsituation, von der die Gesamtheit aller Gemeinden betroffen ist, kann das Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium der Finanzen und für Wissenschaft und im Benehmen mit dem Kommunalen Sanierungsrat die Fortschreibung der Basiswerte nach den Nummern 1 bis 5 im laufenden Haushaltsjahr an die Ergebnisse der Regionalisierung der Steuerschätzung vom Mai des laufenden Haushaltsjahres anpassen.
+(3) Die Grundbeträge nach Absatz 1 ergeben sich durch Division der Gesamtsteuereinzahlungen eines Jahres durch den Hebesatz dieses Jahres.
+(4) Absatz 1 und Absatz 2 Nummer 7 gelten nicht für die Normalentwicklung der Kreisumlage oder der Regionalverbandsumlage der Jahre 2026 und 2027.
+§ 7  Berechnung des strukturellen zahlungsbezogenen Ergebnisses
+(1) Das strukturelle zahlungsbezogene Ergebnis der Gemeinden wird errechnet, indem im zahlungsbezogenen Ergebnis nach § 6 des Gesetzes über den Saarlandpakt bei den Normalfaktoren nach § 6 dieser Verordnung die Zahlungen laut Finanzhaushalt bzw. laut Finanzrechnung durch deren Normalentwicklung nach § 6 dieser Verordnung ersetzt werden.
+(2) Bei der Grund- und Gewerbesteuer wird der Betrag nach Absatz 1 um die sich aus Hebesatzveränderungen gegenüber dem zweitvorangegangenen Haushaltsjahr ergebenden Mehr- oder Mindereinzahlungen erhöht beziehungsweise vermindert. Hierzu wird der Betrag der Normalentwicklung durch den Hebesatz des zweitvorangegangenen Jahres dividiert und mit der Differenz zum Hebesatz des laufenden Jahres multipliziert.
+§ 8  Rundungen
+Die der Berechnung zugrunde liegenden Daten und die Berechnungsergebnisse können auf 1.000 Euro gerundet werden.
+§ 9  Geltungsdauer
+Diese Verordnung gilt für die Haushaltsjahre 2020 bis 2064.
+§ 10  Inkrafttreten
+Diese Verordnung tritt mit Wirkung vom 1. Januar 2020 in Kraft.
diff --git a/src/test/resources/sampledata/Saarland/SOURCES b/src/test/resources/sampledata/Saarland/SOURCES
new file mode 100644
index 0000000..6f1049e
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/SOURCES
@@ -0,0 +1,85 @@
+Änderungsgesetz:
+- Gesetz Nr. 2211 zur Änderung des Gesetzes über den Saarlandpakt vom
+  24. Juni 2026, verkündet am 13. August 2026 (Amtsbl. des Saarlandes
+  Teil I Nr. 31 S. 756), in Kraft mit Wirkung vom 1. Januar 2026
+  (ABl-2026-31_Saarlandpakt-AendG.pdf)
+- Das Gesetz ändert zwei Stammwerke: Artikel 1 das Gesetz über den
+  Saarlandpakt (SPaktG), Artikel 2 die Verordnung zur Ausführung des
+  Gesetzes über den Saarlandpakt (AusfSPaktGVO). Artikel 3 regelt das
+  Inkrafttreten. Beide Werke sind deshalb als eigene Aufträge geführt.
+
+Bezugsweg des Heftes:
+- Das Verkündungsportal des Saarlandes (amtsblatt.saarland.de) ist —
+  anders als die Landesrechtsportale — kein juris-Einseitenprogramm,
+  sondern gewöhnliches, skriptlesbares HTML. Das kostenlose Amtsblatt
+  reicht zurück bis zur Ausgabe 48 vom 3. Dezember 2009.
+- Die fünf jüngsten Hefte hängen an der Startseite:
+  /jportal/portal/page/fpverksl.psml?nid=VB-SL-ABlI<Jahr><Seite>-G&cmsuri=…
+  Das PDF liegt darunter unter /jportal/docs/news_anlage/sl/pdf/VerkBl/ABl/
+  ads_<Nr>-<Jahr>_teil_I_signed.pdf.
+- Ältere Hefte tragen denselben Dateinamen, aber den Pfad
+  /jportal/docs/anlage/… und verlangen die Sitzungskennung, die die
+  Dokumentseite mitgibt (…pdf;jsessionid=…). Die Dokumentkennung ist
+  VB-SL-ABlI<Jahr><erste Seite des Heftes>; zu einer Fundstelle findet
+  man das Heft, indem man von der Seitenzahl abwärts zählt, bis eine
+  Dokumentseite antwortet.
+
+Stammfassungen:
+- SPaktG-neu.txt — Gesetz über den Saarlandpakt (SPaktG), Gesamtausgabe
+  vom 29. August 2026 (Stand: § 8a neu eingefügt durch Artikel 1 des
+  Gesetzes vom 24. Juni 2026), 20 Normen.
+- AusfSPaktGVO-neu.txt — Verordnung zur Ausführung des Gesetzes über
+  den Saarlandpakt (AusfSPaktGVO), Gesamtausgabe vom 29. August 2026,
+  10 Normen. Die Anlage zu § 2 (Tabelle der maßgeblichen strukturellen
+  Liquiditätskredite je Gemeinde) ist nicht mitgeführt; sie wird von
+  keinem Befehl berührt.
+- Bezugsweg: recht.saarland.de (juris-Kennung bssl), Dokumentkennungen
+  jlr-NNLSL00009E79 (SPaktG) und jlr-NNLSL00009E78 (AusfSPaktGVO).
+  Das Portal ist eine Einseitenanwendung; Skripten gibt es nur die
+  5,4-kB-Hülle, einem Browser den Volltext. Eine Fassungsliste führt es
+  nicht — nur „Aktuelle Gesamtausgabe“ und „Änderungshistorie“; die
+  Adressform …@JJJJMMTT wird abgewiesen. Vorfassungen sind daher nicht
+  unmittelbar zu beschaffen.
+
+Vorfassungen (SPaktG-alt.txt, AusfSPaktGVO-alt.txt):
+- Die Änderungshistorie des Portals weist für 2026 je genau eine
+  Änderung aus: beim SPaktG „§ 8a neu eingefügt“, bei der Verordnung
+  „zuletzt geändert durch Artikel 2 des Gesetzes vom 24. Juni 2026“
+  (§ 6 Absatz 4). Die Vorfassung ist daher die Gesamtausgabe ohne den
+  § 8a bzw. ohne den § 6 Absatz 4.
+- Gegenprobe aus den Gesetzblättern: Die Ursprungsfassung des SPaktG
+  (Artikel 1 des Gesetzes Nr. 1977 vom 30. Oktober 2019, Amtsbl. I
+  S. 1033, ads_47-2019) wurde mit den beiden zwischenzeitlichen
+  Änderungen fortgeschrieben — Artikel 2 des Gesetzes vom 11. November
+  2020 (Amtsbl. I S. 1339, ads_77-2020) und Artikel 4 des Gesetzes vom
+  4. Dezember 2024 (Amtsbl. I S. 1086, ads_49-2024). Der Unterschied
+  zwischen dieser Ursprungsfassung und der heutigen Gesamtausgabe ist
+  genau: § 7 Satz 1 Nummer 1 aufgehoben nebst Umnummerierung, § 11
+  Absatz 3 Sätze 2 bis 4 aufgehoben, § 14 Absatz 2 Satz 1 „Juli“ →
+  „Dezember“, § 14 Absatz 3 Satz 1 Nummer 1 aufgehoben nebst
+  Umnummerierung — und der neue § 8a. Damit ist die abgeleitete
+  Vorfassung Norm für Norm belegt.
+- Bei dieser Gegenprobe blieben drei Befehle des Heftes von 2024 stehen
+  und sind als Grenzen benannt: die Anfügung an die Überschrift des
+  Werkes selbst („In der Überschrift wird nach dem Wort „Saarlandpakt“
+  das Wort „(SPaktG)“ angefügt“), die an eine Nummer angefügte weitere
+  Nummer, die ans Ende des Absatzes statt hinter die genannte Nummer
+  tritt, und der Verbund aus Bereichsumnummerierung und Wortstreichung
+  („Die bisherigen Nummern 2 bis 8 werden die Nummern 1 bis 7 und in
+  der neuen Nummer 7 wird das Komma gestrichen“).
+
+Aufbereitung zum kanonischen Klartext:
+1. Volltext der Gesamtausgabe aus dem Browser (div.docLayoutText).
+2. Die Portalzutaten entfernt: „zur Einzelansicht …“, das nichtamtliche
+   Inhaltsverzeichnis, die Fußnotenblöcke und die Fußnotenzeichen.
+3. Normkopf und Titel auf eine Zeile mit doppeltem Leerzeichen
+   („§ 8a  Entlastungen in den Jahren 2026 und 2027“), ebenso die
+   Abschnittsüberschriften.
+4. Aufzählungsmarke und Text auf eine Zeile („1. die Gewerbesteuer,“).
+5. Kopfzeilen: Langtitel, Kurzbezeichnung in Klammern, Ausfertigungs-
+   datum, Fundstelle.
+
+Rechtsstellung:
+- Amtliche Werke im Sinne des § 5 UrhG; wiedergegeben werden einzelne
+  Vorschriften zu Prüfzwecken, kein Massenabzug, keine Anmeldeschranke
+  umgangen. Die Quellenangabe folgt § 63 UrhG.
diff --git a/src/test/resources/sampledata/Saarland/SPaktG-alt.txt b/src/test/resources/sampledata/Saarland/SPaktG-alt.txt
new file mode 100644
index 0000000..897b422
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/SPaktG-alt.txt
@@ -0,0 +1,107 @@
+Gesetz über den Saarlandpakt
+(SPaktG)
+Vom 30. Oktober 2019
+(Amtsbl. I S. 1033)
+Abschnitt 1  Grundlagen
+§ 1  Sicherstellung der finanziellen Handlungsfähigkeit der Gemeinden
+Die Maßnahmen nach diesem Gesetz unterstützen die nachhaltige Sicherstellung der finanziellen Handlungsfähigkeit der Gemeinden im Wege der vollständigen verbindlichen Rückführung der kommunalen strukturellen Liquiditätskredite und den dauerhaften Haushaltsausgleich. Gleichzeitig tragen sie zur Deckung der kommunalen Investitionsbedarfe bei.
+§ 2  Strukturelle Liquiditätskredite
+(1) Als strukturelle Liquiditätskredite gelten Kredite zur Liquiditätssicherung, die durch zahlungsbezogene Haushaltsfehlbeträge aus laufender Verwaltungstätigkeit verursacht wurden. Ihre Ermittlung erfolgt anhand einheitlicher für alle Kommunen geltender Maßstäbe.
+(2) Bei den Gemeindeverbänden gelten nur nicht gedeckte Fehlbeträge aus abweisbaren Ausgaben als strukturelle Liquiditätskredite.
+Abschnitt 2  Abbau kommunaler Liquiditätskredite
+§ 3  Übernahme von strukturellen Liquiditätskrediten
+(1) Das Land übernimmt von den Gemeinden und Gemeindeverbänden Liquiditätskredite im Gesamtvolumen von 1 Milliarde Euro. Die Höhe des Anspruchs einer Gemeinde oder eines Gemeindeverbandes auf Übernahme durch das Land errechnet sich nach ihren prozentualen Anteilen am Gesamtvolumen der strukturellen Liquiditätskredite nach § 2 nach dem Stand vom 31. Dezember 2017.
+(2) Verzichtet eine Gemeinde auf die Übernahme durch das Land, erhöht sich das Kontingent aller übrigen teilnehmenden Gemeinden und Gemeindeverbände in entsprechendem Umfang.
+(3) Verzichtet ein Gemeindeverband auf die Übernahme durch das Land, erhöht sich das Kontingent aller teilnehmenden Gemeinden in diesem Gemeindeverband gleichmäßig in entsprechendem Umfang.
+(4) Die Gemeinden und Gemeindeverbände erklären beim Ministerium für Finanzen und Europa zum frühestmöglichen Zeitpunkt, spätestens aber bis zum 30. Juni 2020, ob sie an der Übernahme von Liquiditätskrediten in der Höhe des nach Absatz 1 errechneten Betrages durch das Land teilnehmen. Das Land und die teilnehmende Gemeinde oder der teilnehmende Gemeindeverband schließen eine Übernahmevereinbarung, die die Übernahme von fällig werdenden Krediten in Höhe des Anspruchs regelt. Die Erklärung nach Satz 1 umfasst auch nachträgliche aufgrund der Absätze 2 oder 3 eintretende Veränderungen. Sie werden durch Zusatzvereinbarungen geregelt.
+(5) Das Land tilgt die übernommenen Kredite innerhalb von 45 Jahren.
+§ 4  Rückführung der strukturellen Liquiditätskredite
+(1) Die strukturellen Liquiditätskredite der Gemeinden sind nach einem für jede einzelne Gemeinde für die gesamte Laufzeit verbindlich vorzugebenden Tilgungsplan vom 1. Januar 2020 bis zum 31. Dezember 2064 vollständig zurückzuführen. Maßgeblich ist der Stand zum 31. Dezember 2019, der um die vom Land auf Grund einer Erklärung nach § 3 Absatz 4 zu übernehmenden strukturellen Liquiditätskredite zu reduzieren ist. Der Plan gibt die jährlich zu leistende Mindesttilgung und den höchst zulässigen Betrag der strukturellen Liquiditätskredite auf der Grundlage des Schuldendienstes für ein fiktives Annuitätendarlehen verbindlich vor.
+(2) Die nach dem Tilgungsplan für die Mindesttilgung erforderlichen Beträge sind jährlich zu erwirtschaften. Ist die Tilgung in einem Haushaltsjahr aufgrund der bestehenden kreditvertraglichen Regelungen rechtlich nicht möglich oder unwirtschaftlich, ist laufend zu gewährleisten und nachzuweisen, dass die erwirtschafteten Mittel zum Zeitpunkt der Fälligkeit für die Tilgung der Liquiditätskredite zur Verfügung stehen und eingesetzt werden.
+(3) Über die Mindesttilgung nach Absatz 1 hinausgehende Tilgungsleistungen lassen die Mindesttilgungen in den Folgejahren unverändert. § 9 Absatz 3 bleibt hiervon unberührt.
+§ 5  Sonderregelung 2020 bis 2023
+(1) Zahlungsbezogene Fehlbeträge im Sinne des § 6, die in den Jahren 2020 bis 2023 infolge der Bestimmungen des § 8 Absatz 1 bis 3 in Verbindung mit § 7 entstehen können, sind zunächst durch Überschüsse in diesem Zeitraum auszugleichen. Darüber hinaus werden sie in die Folgejahre vorgetragen. Zum Stichtag 31. Dezember 2023 nicht gedeckte Fehlbeträge sind innerhalb von drei Jahren entsprechend § 9 Absatz 1 zurückzuführen oder den strukturellen Liquiditätskrediten nach § 4 Absatz 1 Satz 2 zuzuschlagen und ab dem 1. Januar 2024 über den Restzeitraum von 41 Jahren nach § 4 Absatz 1 zu tilgen.
+(2) Über Absatz 1 Satz 1 hinausgehende Fehlbeträge dürfen den strukturellen Liquiditätskrediten nach § 4 Absatz 1 Satz 2 nicht zugeschlagen werden und sind spätestens im zweitfolgenden Jahr auszugleichen.
+Abschnitt 3  Kommunaler Haushaltsausgleich
+§ 6  Zahlungsbezogenes Ergebnis
+Das zahlungsbezogene Ergebnis ist der Saldo aus Einzahlungen und Auszahlungen aus laufender Verwaltungstätigkeit
+abzüglich der um Tilgungserstattungen bereinigten Tilgung der Kredite für Investitionen und ohne Einzahlungen oder Auszahlungen von Konsolidierungshilfen aus dem Kommunalen Entlastungsfonds,
+abzüglich der Erwirtschaftung der zur Tilgung der strukturellen Liquiditätskredite nach § 4 und § 5 Absatz 1 Satz 3 erforderlichen Mittel,
+abzüglich der Erwirtschaftung der Mittel zur vorgeschriebenen Rückführung von Fehlbeträgen,
+zuzüglich der aus Vorjahren übertragenen Überschüsse.
+§ 7  Strukturelles zahlungsbezogenes Ergebnis
+Zur Ermittlung des strukturellen zahlungsbezogenen Ergebnisses wird ausgehend vom zahlungsbezogenen Ergebnis nach § 6 bei den nachfolgend benannten Zahlungsarten (Normalfaktoren) eine Normalentwicklung unterstellt:
+1. die Gewerbesteuer,
+2. die Gewerbesteuerumlage,
+3. der Gemeindeanteil an der Einkommensteuer,
+4. der Gemeindeanteil an der Umsatzsteuer,
+5. die Schlüsselzuweisungen A, B und C sowie die Sonderschlüsselzuweisungen an die Gemeinden,
+6. die Finanzausgleichsumlage nach dem Kommunalfinanzausgleichsgesetz und
+7. die Kreisumlage oder die Regionalverbandsumlage.
+Basiswerte für die Normalentwicklung sind die letzten im Jahr vor dem Haushaltsjahr verfügbaren Rechnungsergebnisse. Die Normalentwicklung wird jährlich fortgeschrieben. Die Gemeinden steuern ihr strukturelles zahlungsbezogenes Ergebnis durch die übrigen Auszahlungen und Einzahlungen.
+§ 8  Vorgaben für das strukturelle zahlungsbezogene Ergebnis
+(1) Ab dem Jahr 2024 ist der Haushalt in Planung und Ausführung strukturell zahlungsbezogen im Sinne des § 7 auszugleichen.
+(2) In den Jahren 2020 bis 2023 sind in Planung und Ausführung strukturell zahlungsbezogen im Sinne des § 7 die folgenden Fehlbeträge in Prozent des strukturellen zahlungsbezogenen Defizits 2014 (Ausgangsdefizit) zugelassen:
+2020 40 Prozent,
+2021 30 Prozent,
+2022 20 Prozent,
+2023 10 Prozent.
+(3) Zur Berechnung des Ausgangsdefizits gilt § 4 Absatz 1 bis 3 des Gesetzes über die Konsolidierungshilfen aus dem Sondervermögen „Kommunaler Entlastungsfonds“ ab dem Jahr 2015 vom 13. Oktober 2015 (Amtsbl. I S. 852), geändert durch das Gesetz vom 15. Juni 2016 (Amtsbl. I S. 656), in Verbindung mit § 2 der Verordnung über die Bewilligungsvoraussetzungen nach dem Gesetz über die Konsolidierungshilfen aus dem Sondervermögen „Kommunaler Entlastungsfonds“ ab dem Jahr 2015 vom 7. Dezember 2015 (Amtsbl. I S. 2217). Nach dieser Bestimmung oder nach dem Konsolidierungserlass des Ministeriums für Inneres und Sport vom 3. Juni 2015 bereits festgesetzte Ausgangsdefizite bleiben unverändert.
+(4) Entstehen einer Gemeinde durch nicht vorhersehbare und von ihr nicht beeinflussbare Ereignisse unabweisbare zusätzliche Belastungen, zu deren Tragung die Gemeinde verpflichtet, aber nicht in der Lage ist, kann die Vorgabe für das jahresbezogene strukturelle Ergebnis in Planung und Ausführung insoweit angepasst werden. Soweit hierdurch zahlungsbezogene Fehlbeträge entstehen, sind diese, soweit sie nicht aus nachfolgenden Überschüssen gedeckt werden können, binnen fünf Jahren zurückzuführen. Für außergewöhnliche Ereignisse größeren Ausmaßes mit mehrjähriger Wirkung kann die Dauer der Rückführung verlängert werden. Die Entscheidung über die Anerkennung und über einen längeren Rückführungszeitraum trifft das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat.
+(5) Nur im Fall einer außergewöhnlichen Notsituation, die von der jeweils betroffenen Gemeinde darzulegen ist, kann das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat von den Regelungen zum Haushaltsausgleich abweichen, wenn hierdurch die Ziele des § 1 Satz 1 gefördert werden. Hierbei ist die verbindliche Rückführung von Fehlbeträgen innerhalb eines eindeutig bestimmten Zeitraums vorzusehen.
+§ 9  Vorgaben für den Haushalt und den Jahresabschluss
+(1) Ab dem Jahr 2024 sind zahlungsbezogene Fehlbeträge im Sinne des § 6, die in Folge der Bestimmungen des § 8 in Verbindung mit § 7 entstehen, nach der Haushaltsplanung und nach dem Jahresergebnis, beginnend mit dem zweitfolgenden Haushaltsjahr, innerhalb von drei Jahren in gleichen Beträgen zurückzuführen, soweit nicht nach § 8 Absatz 4 oder 5 ein abweichender Zeitraum zugelassen ist.
+(2) Über Absatz 1 hinaus gehende Fehlbeträge sind spätestens im zweitfolgenden Jahr auszugleichen.
+(3) Überschüsse sind zunächst zur Rückführung noch bestehender Fehlbeträge nach Absatz 1 und 2 zu verwenden. Danach stehen Sie ab dem zweitfolgenden Jahr für Investitionen oder zur Tilgung von strukturellen Liquiditätskrediten zur Verfügung.
+§ 10  Nichtanwendung von haushaltsrechtlichen Vorschriften
+In den Haushaltsjahren 2020 bis 2064 finden § 82 Absatz 3 und die Absätze 5 bis 8 und § 82a des Kommunalselbstverwaltungsgesetzes sowie § 16 Absatz 2 der Kommunalhaushaltsverordnung für die Gemeinden keine Anwendung.
+Abschnitt 4  Investitionszuweisungen
+§ 11  Empfängerkreis und Mittelverteilung
+(1) Gemeinden erhalten Investitionszuweisungen, wenn sie die Vorgaben für das strukturelle zahlungsbezogene Ergebnis nach den §§ 4 bis 9 im Rahmen der Haushaltsplanung im maßgeblichen Bewilligungszeitraum beachten. Die Investitionszuweisungen können zurückgefordert werden, wenn der strukturelle zahlungsbezogene Fehlbetrag auf Basis des Jahresabschlusses die zugelassene Obergrenze übersteigt. In einem Bewilligungsjahr nicht bewilligte oder zurückgeforderte und zurückgezahlte Mittel erhöhen das verfügbare Bewilligungsvolumen spätestens im zweitfolgenden Haushaltsjahr.
+(2) Die Hilfen sind nach standardisierten finanzwissenschaftlichen Indikatoren auf den Empfängerkreis so zu verteilen, dass die Ziele nach § 1 nachhaltig gefördert werden.
+(3) Die Gemeinden erhalten ab dem Jahr 2020 bis zum Jahr 2064 jährlich mindestens 20 Millionen Euro an Investitionszuschüssen.
+§ 12  Verwendung der Mittel des Kommunalen Entlastungsfonds der Jahre 2020 bis 2022
+(1) Die Mittel nach dem Gesetz über den Kommunalen Entlastungsfonds werden den Gemeinden zur Finanzierung von Auszahlungen für Investitionen und für die Unterhaltung des Anlagevermögens wie folgt zur Verfügung gestellt:
+2020 13 Millionen Euro,
+2021 9 Millionen Euro,
+2022 4 Millionen Euro.
+(2) Die Verteilung der Mittel nach dem Gesetz über den Kommunalen Entlastungsfonds erfolgt entsprechend der Verteilung der allgemeinen Investitionszuweisungen nach § 11.
+§ 13  Mittelverwendung
+(1) Die Zuweisungen nach den §§ 11 und 12 müssen zweckentsprechend verwendet werden.
+(2) Die Verwendung zur zusätzlichen Tilgung struktureller Liquiditätskredite ist zulässig.
+(3) Die zweckentsprechende Verwendung ist dem Landesverwaltungsamt als Kommunalaufsichtsbehörde spätestens bis 31. März des zweiten auf das Bewilligungsjahr folgenden Jahres nachzuweisen.
+§ 14  Verfahren und Zuständigkeit
+(1) Bewilligungsbehörde für die Zuweisungen nach den §§ 11 und 12 ist das Ministerium für Inneres, Bauen und Sport. Die Zuweisungen werden nach Bestandskraft der Bewilligung an die Gemeinden ausgezahlt.
+(2) Anträge sind spätestens bis zum 31. Dezember des Bewilligungsjahres mit den erforderlichen Unterlagen bei der Kommunalaufsichtsbehörde vorzulegen. Dort verspätet eingegangene Anträge werden nicht berücksichtigt.
+(3) Mit dem Antrag auf Bewilligung der Zuweisungen sind folgende Unterlagen einzureichen, soweit sie nicht bereits bei der Kommunalaufsichtsbehörde vorliegen:
+1. Berechnung des strukturellen Ergebnisses und Nachweis der Einhaltung der Ergebnisvorgaben nach § 11 Absatz 1,
+2. Haushaltssatzung.
+Die Gemeinden bestätigen die Richtigkeit der Verteilung der Zuweisungen und der Berechnung der Bewilligungsvoraussetzungen zu Grunde liegenden von ihnen an die zuständigen Stellen zu meldenden Daten. Fehlerhaft gemeldete Daten gehen zu Lasten der Gemeinden.
+(4) Die Kommunalaufsichtsbehörde prüft, ob die formalen und materiellen Voraussetzungen für die Zuweisungen vorliegen. Sie leitet den Antrag mit dem Ergebnis ihrer Prüfung und einer Entscheidungsempfehlung an das Ministerium für Inneres, Bauen und Sport weiter. Das Ministerium für Inneres, Bauen und Sport entscheidet im Benehmen mit dem Kommunalen Sanierungsrat. Der kommunale Sanierungsrat kann in seiner Geschäftsordnung bestimmen, unter welchen Voraussetzungen das Ministerium für Inneres, Bauen und Sport eigenständig ohne vorherige Beteiligung des Kommunalen Sanierungsrates entscheiden kann. In diesem Fall ist der kommunale Sanierungsrat nachträglich zu informieren.
+(5) Die Gemeinde hat der Kommunalaufsichtsbehörde die Einhaltung des Sanierungszieles nach § 8 bis zum 31. Juli des dem Bewilligungsjahr folgenden Jahres nachzuweisen.
+§ 15  Rückforderung
+(1) Die Zuweisungen können zurückgefordert werden, wenn nachträglich bekannt wird, dass die Voraussetzungen für ihre Bewilligung nicht vorlagen, wenn diese nachträglich entfallen sind, wenn die sich aus den §§ 4 bis 13 ergebenden Anforderungen nicht eingehalten oder nicht nachgewiesen werden oder soweit Daten im Sinne des § 14 Absatz 3 Satz 2 fehlerhaft gemeldet wurden.
+(2) Die Entscheidung trifft das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat.
+Abschnitt 5  Kommunaler Sanierungsrat
+§ 16  Kommunaler Sanierungsrat
+(1) Für die in diesem Gesetz bestimmten Aufgaben wird beim Ministerium für Inneres, Bauen und Sport ein mit Vertreterinnen oder Vertretern des Landes und des Saarländischen Städte- und Gemeindetags paritätisch besetzter Kommunaler Sanierungsrat eingerichtet.
+(2) Die Präsidentin oder der Präsident des Rechnungshofs hat das Recht, an den Sitzungen des Kommunalen Sanierungsrates teilzunehmen
+(3) Die Grundlagen der Arbeitsweise des Kommunalen Sanierungsrates regelt das Ministerium für Inneres, Bauen und Sport durch Verwaltungsvorschrift nach Anhörung der im Kommunalen Sanierungsrat vertretenen Gruppen.
+(4) Zur Regelung der weiteren Einzelheiten gibt sich der kommunale Sanierungsrat eine Geschäftsordnung.
+Abschnitt 6  Schlussvorschriften
+§ 17  Verordnungsermächtigungen
+(1) Das Ministerium für Finanzen und Europa regelt im Einvernehmen mit dem Ministerium für Inneres, Bauen und Sport durch Rechtsverordnung die Einzelheiten zum Verfahren, zu den Fristen, zur Zuständigkeit, zur Übernahmevereinbarung und zur technischen Übernahme der Liquiditätskredite nach § 3.
+(2) Die Landesregierung regelt durch Rechtsverordnung
+1. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten hinsichtlich der Übernahme und Rückführung der strukturellen Liquiditätskredite nach den §§ 2 bis 4,
+2. die Einzelheiten zum Tilgungsplan und zu den Vorgaben zur Rückführung der strukturellen Liquiditätskredite nach § 4,
+3. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten zur Sonderregelung für zahlungsbezogene Fehlbeträge in den Jahren 2020 bis 2023 nach § 5,
+4. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten hinsichtlich des zahlungsbezogenen Ergebnisses nach § 6,
+5. die Einzelheiten der Bestimmung des strukturellen Ergebnisses und der Normalentwicklung der Zahlungsarten nach § 7.
+(3) Das Ministerium für Inneres, Bauen und Sport regelt durch Rechtsverordnung die Einzelheiten der haushaltsmäßigen Verbuchung und der haushaltsmäßigen Nachweise. Die Regelungen zur Verbuchung der Übernahme von Liquiditätskrediten nach § 3 bedürfen des Einvernehmens des Ministeriums für Finanzen und Europa.
+(4) Die Landesregierung regelt die Einzelheiten des Empfängerkreises und die Verteilungskriterien nach § 11 durch Rechtsverordnung.
+(5) Entstehen der Gesamtheit aller Gemeinden oder einzelnen Gemeinden durch Europa-, Bundes- oder Landesrecht Mindereinzahlungen oder Mehrauszahlungen, die nach Abzug damit zusammenhängender Mehreinzahlungen oder Minderauszahlungen einen Betrag von 0,1 Prozent der Auszahlungen aus laufender Verwaltungstätigkeit voraussichtlich übersteigen, kann das Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium für Finanzen und Europa und im Benehmen mit dem Kommunalen Sanierungsrat durch Rechtsverordnung entsprechende Obergrenzen für das jahresbezogene strukturelle Defizit festlegen. Voraussetzung ist, dass hierdurch die Ziele nach § 1 gefördert werden. Hierbei ist die verbindliche Rückführung von Fehlbeträgen innerhalb eines eindeutig bestimmten Zeitraums vorzusehen.
+§ 18  Verwaltungsvorschriften
+(1) Das Nähere zum Verwaltungsverfahren bestimmt das Ministerium für Inneres, Bauen und Sport durch Verwaltungsvorschriften nach Anhörung des saarländischen Städte- und Gemeindetags.
+(2) Das Ministerium für Inneres, Bauen und Sport kann die Verwendung von schriftlichen oder elektronischen Formularen und elektronischer Wege der Antrags- und Datenübermittlung verbindlich vorschreiben.
+§ 19  Evaluation
+Dieses Gesetz ist spätestens zum Stichtag 31. Dezember 2024 zu evaluieren. Der Bericht ist dem Landtag des Saarlandes spätestens zum 30. Juni 2025 vorzulegen.
diff --git a/src/test/resources/sampledata/Saarland/SPaktG-neu.txt b/src/test/resources/sampledata/Saarland/SPaktG-neu.txt
new file mode 100644
index 0000000..411ceca
--- /dev/null
+++ b/src/test/resources/sampledata/Saarland/SPaktG-neu.txt
@@ -0,0 +1,115 @@
+Gesetz über den Saarlandpakt
+(SPaktG)
+Vom 30. Oktober 2019
+(Amtsbl. I S. 1033)
+Abschnitt 1  Grundlagen
+§ 1  Sicherstellung der finanziellen Handlungsfähigkeit der Gemeinden
+Die Maßnahmen nach diesem Gesetz unterstützen die nachhaltige Sicherstellung der finanziellen Handlungsfähigkeit der Gemeinden im Wege der vollständigen verbindlichen Rückführung der kommunalen strukturellen Liquiditätskredite und den dauerhaften Haushaltsausgleich. Gleichzeitig tragen sie zur Deckung der kommunalen Investitionsbedarfe bei.
+§ 2  Strukturelle Liquiditätskredite
+(1) Als strukturelle Liquiditätskredite gelten Kredite zur Liquiditätssicherung, die durch zahlungsbezogene Haushaltsfehlbeträge aus laufender Verwaltungstätigkeit verursacht wurden. Ihre Ermittlung erfolgt anhand einheitlicher für alle Kommunen geltender Maßstäbe.
+(2) Bei den Gemeindeverbänden gelten nur nicht gedeckte Fehlbeträge aus abweisbaren Ausgaben als strukturelle Liquiditätskredite.
+Abschnitt 2  Abbau kommunaler Liquiditätskredite
+§ 3  Übernahme von strukturellen Liquiditätskrediten
+(1) Das Land übernimmt von den Gemeinden und Gemeindeverbänden Liquiditätskredite im Gesamtvolumen von 1 Milliarde Euro. Die Höhe des Anspruchs einer Gemeinde oder eines Gemeindeverbandes auf Übernahme durch das Land errechnet sich nach ihren prozentualen Anteilen am Gesamtvolumen der strukturellen Liquiditätskredite nach § 2 nach dem Stand vom 31. Dezember 2017.
+(2) Verzichtet eine Gemeinde auf die Übernahme durch das Land, erhöht sich das Kontingent aller übrigen teilnehmenden Gemeinden und Gemeindeverbände in entsprechendem Umfang.
+(3) Verzichtet ein Gemeindeverband auf die Übernahme durch das Land, erhöht sich das Kontingent aller teilnehmenden Gemeinden in diesem Gemeindeverband gleichmäßig in entsprechendem Umfang.
+(4) Die Gemeinden und Gemeindeverbände erklären beim Ministerium für Finanzen und Europa zum frühestmöglichen Zeitpunkt, spätestens aber bis zum 30. Juni 2020, ob sie an der Übernahme von Liquiditätskrediten in der Höhe des nach Absatz 1 errechneten Betrages durch das Land teilnehmen. Das Land und die teilnehmende Gemeinde oder der teilnehmende Gemeindeverband schließen eine Übernahmevereinbarung, die die Übernahme von fällig werdenden Krediten in Höhe des Anspruchs regelt. Die Erklärung nach Satz 1 umfasst auch nachträgliche aufgrund der Absätze 2 oder 3 eintretende Veränderungen. Sie werden durch Zusatzvereinbarungen geregelt.
+(5) Das Land tilgt die übernommenen Kredite innerhalb von 45 Jahren.
+§ 4  Rückführung der strukturellen Liquiditätskredite
+(1) Die strukturellen Liquiditätskredite der Gemeinden sind nach einem für jede einzelne Gemeinde für die gesamte Laufzeit verbindlich vorzugebenden Tilgungsplan vom 1. Januar 2020 bis zum 31. Dezember 2064 vollständig zurückzuführen. Maßgeblich ist der Stand zum 31. Dezember 2019, der um die vom Land auf Grund einer Erklärung nach § 3 Absatz 4 zu übernehmenden strukturellen Liquiditätskredite zu reduzieren ist. Der Plan gibt die jährlich zu leistende Mindesttilgung und den höchst zulässigen Betrag der strukturellen Liquiditätskredite auf der Grundlage des Schuldendienstes für ein fiktives Annuitätendarlehen verbindlich vor.
+(2) Die nach dem Tilgungsplan für die Mindesttilgung erforderlichen Beträge sind jährlich zu erwirtschaften. Ist die Tilgung in einem Haushaltsjahr aufgrund der bestehenden kreditvertraglichen Regelungen rechtlich nicht möglich oder unwirtschaftlich, ist laufend zu gewährleisten und nachzuweisen, dass die erwirtschafteten Mittel zum Zeitpunkt der Fälligkeit für die Tilgung der Liquiditätskredite zur Verfügung stehen und eingesetzt werden.
+(3) Über die Mindesttilgung nach Absatz 1 hinausgehende Tilgungsleistungen lassen die Mindesttilgungen in den Folgejahren unverändert. § 9 Absatz 3 bleibt hiervon unberührt.
+§ 5  Sonderregelung 2020 bis 2023
+(1) Zahlungsbezogene Fehlbeträge im Sinne des § 6, die in den Jahren 2020 bis 2023 infolge der Bestimmungen des § 8 Absatz 1 bis 3 in Verbindung mit § 7 entstehen können, sind zunächst durch Überschüsse in diesem Zeitraum auszugleichen. Darüber hinaus werden sie in die Folgejahre vorgetragen. Zum Stichtag 31. Dezember 2023 nicht gedeckte Fehlbeträge sind innerhalb von drei Jahren entsprechend § 9 Absatz 1 zurückzuführen oder den strukturellen Liquiditätskrediten nach § 4 Absatz 1 Satz 2 zuzuschlagen und ab dem 1. Januar 2024 über den Restzeitraum von 41 Jahren nach § 4 Absatz 1 zu tilgen.
+(2) Über Absatz 1 Satz 1 hinausgehende Fehlbeträge dürfen den strukturellen Liquiditätskrediten nach § 4 Absatz 1 Satz 2 nicht zugeschlagen werden und sind spätestens im zweitfolgenden Jahr auszugleichen.
+Abschnitt 3  Kommunaler Haushaltsausgleich
+§ 6  Zahlungsbezogenes Ergebnis
+Das zahlungsbezogene Ergebnis ist der Saldo aus Einzahlungen und Auszahlungen aus laufender Verwaltungstätigkeit
+abzüglich der um Tilgungserstattungen bereinigten Tilgung der Kredite für Investitionen und ohne Einzahlungen oder Auszahlungen von Konsolidierungshilfen aus dem Kommunalen Entlastungsfonds,
+abzüglich der Erwirtschaftung der zur Tilgung der strukturellen Liquiditätskredite nach § 4 und § 5 Absatz 1 Satz 3 erforderlichen Mittel,
+abzüglich der Erwirtschaftung der Mittel zur vorgeschriebenen Rückführung von Fehlbeträgen,
+zuzüglich der aus Vorjahren übertragenen Überschüsse.
+§ 7  Strukturelles zahlungsbezogenes Ergebnis
+Zur Ermittlung des strukturellen zahlungsbezogenen Ergebnisses wird ausgehend vom zahlungsbezogenen Ergebnis nach § 6 bei den nachfolgend benannten Zahlungsarten (Normalfaktoren) eine Normalentwicklung unterstellt:
+1. die Gewerbesteuer,
+2. die Gewerbesteuerumlage,
+3. der Gemeindeanteil an der Einkommensteuer,
+4. der Gemeindeanteil an der Umsatzsteuer,
+5. die Schlüsselzuweisungen A, B und C sowie die Sonderschlüsselzuweisungen an die Gemeinden,
+6. die Finanzausgleichsumlage nach dem Kommunalfinanzausgleichsgesetz und
+7. die Kreisumlage oder die Regionalverbandsumlage.
+Basiswerte für die Normalentwicklung sind die letzten im Jahr vor dem Haushaltsjahr verfügbaren Rechnungsergebnisse. Die Normalentwicklung wird jährlich fortgeschrieben. Die Gemeinden steuern ihr strukturelles zahlungsbezogenes Ergebnis durch die übrigen Auszahlungen und Einzahlungen.
+§ 8  Vorgaben für das strukturelle zahlungsbezogene Ergebnis
+(1) Ab dem Jahr 2024 ist der Haushalt in Planung und Ausführung strukturell zahlungsbezogen im Sinne des § 7 auszugleichen.
+(2) In den Jahren 2020 bis 2023 sind in Planung und Ausführung strukturell zahlungsbezogen im Sinne des § 7 die folgenden Fehlbeträge in Prozent des strukturellen zahlungsbezogenen Defizits 2014 (Ausgangsdefizit) zugelassen:
+2020 40 Prozent,
+2021 30 Prozent,
+2022 20 Prozent,
+2023 10 Prozent.
+(3) Zur Berechnung des Ausgangsdefizits gilt § 4 Absatz 1 bis 3 des Gesetzes über die Konsolidierungshilfen aus dem Sondervermögen „Kommunaler Entlastungsfonds“ ab dem Jahr 2015 vom 13. Oktober 2015 (Amtsbl. I S. 852), geändert durch das Gesetz vom 15. Juni 2016 (Amtsbl. I S. 656), in Verbindung mit § 2 der Verordnung über die Bewilligungsvoraussetzungen nach dem Gesetz über die Konsolidierungshilfen aus dem Sondervermögen „Kommunaler Entlastungsfonds“ ab dem Jahr 2015 vom 7. Dezember 2015 (Amtsbl. I S. 2217). Nach dieser Bestimmung oder nach dem Konsolidierungserlass des Ministeriums für Inneres und Sport vom 3. Juni 2015 bereits festgesetzte Ausgangsdefizite bleiben unverändert.
+(4) Entstehen einer Gemeinde durch nicht vorhersehbare und von ihr nicht beeinflussbare Ereignisse unabweisbare zusätzliche Belastungen, zu deren Tragung die Gemeinde verpflichtet, aber nicht in der Lage ist, kann die Vorgabe für das jahresbezogene strukturelle Ergebnis in Planung und Ausführung insoweit angepasst werden. Soweit hierdurch zahlungsbezogene Fehlbeträge entstehen, sind diese, soweit sie nicht aus nachfolgenden Überschüssen gedeckt werden können, binnen fünf Jahren zurückzuführen. Für außergewöhnliche Ereignisse größeren Ausmaßes mit mehrjähriger Wirkung kann die Dauer der Rückführung verlängert werden. Die Entscheidung über die Anerkennung und über einen längeren Rückführungszeitraum trifft das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat.
+(5) Nur im Fall einer außergewöhnlichen Notsituation, die von der jeweils betroffenen Gemeinde darzulegen ist, kann das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat von den Regelungen zum Haushaltsausgleich abweichen, wenn hierdurch die Ziele des § 1 Satz 1 gefördert werden. Hierbei ist die verbindliche Rückführung von Fehlbeträgen innerhalb eines eindeutig bestimmten Zeitraums vorzusehen.
+§ 8a  Entlastungen in den Jahren 2026 und 2027
+(1) Die Belastung der Gemeinden aus der Kreisumlage oder der Regionalverbandsumlage wird in den Jahren 2026 und 2027 auf dem Niveau des Jahres 2022 festgeschrieben. Hierfür gilt das nachfolgende Verfahren:
+1. Abweichend von § 7 Satz 2 und 3 wird die Normalentwicklung der Kreisumlage oder der Regionalverbandsumlage auf das Niveau des Jahres 2025 festgesetzt.
+2. Abweichend von § 8 Absatz 1 werden bei jeder Gemeinde in Planung und Ausführung zusätzlich jahresbezogene strukturelle Fehlbeträge in Höhe der Ist-Ergebnisse der Differenz der Kreisumlage oder der Regionalverbandsumlage des jeweiligen Vorjahres zum Jahr 2022 zugelassen.
+3. Im Jahr 2026 wird die Differenz nach Nummer 2 um 59 Prozent erhöht.
+4. Soweit infolge dieser Bestimmungen zahlungsbezogene Fehlbeträge im Sinne des § 6 entstehen, sind diese, beginnend mit dem Haushaltsjahr 2029, binnen 30 Jahren gleichmäßig zurückzuführen.
+(2) Soweit infolge der am 15. Juli 2024 nach § 8 Absatz 5 durch das Ministerium für Inneres, Bauen und Sport landesweit allgemein anerkannten außergewöhnlichen Notsituation und der zusätzlich zugelassenen jährlichen Fehlbeträge jährliche zahlungsbezogene Fehlbeträge entstanden sind oder entstehen, sind diese einheitlich mit den Fehlbeträgen nach Absatz 1 Nummer 4 zurückzuführen.
+(3) Die Erleichterungen nach dieser Vorschrift entbinden die Gemeinden nicht davon, die notwendigen eigenen Maßnahmen zur Haushaltskonsolidierung zu ergreifen.
+§ 9  Vorgaben für den Haushalt und den Jahresabschluss
+(1) Ab dem Jahr 2024 sind zahlungsbezogene Fehlbeträge im Sinne des § 6, die in Folge der Bestimmungen des § 8 in Verbindung mit § 7 entstehen, nach der Haushaltsplanung und nach dem Jahresergebnis, beginnend mit dem zweitfolgenden Haushaltsjahr, innerhalb von drei Jahren in gleichen Beträgen zurückzuführen, soweit nicht nach § 8 Absatz 4 oder 5 ein abweichender Zeitraum zugelassen ist.
+(2) Über Absatz 1 hinaus gehende Fehlbeträge sind spätestens im zweitfolgenden Jahr auszugleichen.
+(3) Überschüsse sind zunächst zur Rückführung noch bestehender Fehlbeträge nach Absatz 1 und 2 zu verwenden. Danach stehen Sie ab dem zweitfolgenden Jahr für Investitionen oder zur Tilgung von strukturellen Liquiditätskrediten zur Verfügung.
+§ 10  Nichtanwendung von haushaltsrechtlichen Vorschriften
+In den Haushaltsjahren 2020 bis 2064 finden § 82 Absatz 3 und die Absätze 5 bis 8 und § 82a des Kommunalselbstverwaltungsgesetzes sowie § 16 Absatz 2 der Kommunalhaushaltsverordnung für die Gemeinden keine Anwendung.
+Abschnitt 4  Investitionszuweisungen
+§ 11  Empfängerkreis und Mittelverteilung
+(1) Gemeinden erhalten Investitionszuweisungen, wenn sie die Vorgaben für das strukturelle zahlungsbezogene Ergebnis nach den §§ 4 bis 9 im Rahmen der Haushaltsplanung im maßgeblichen Bewilligungszeitraum beachten. Die Investitionszuweisungen können zurückgefordert werden, wenn der strukturelle zahlungsbezogene Fehlbetrag auf Basis des Jahresabschlusses die zugelassene Obergrenze übersteigt. In einem Bewilligungsjahr nicht bewilligte oder zurückgeforderte und zurückgezahlte Mittel erhöhen das verfügbare Bewilligungsvolumen spätestens im zweitfolgenden Haushaltsjahr.
+(2) Die Hilfen sind nach standardisierten finanzwissenschaftlichen Indikatoren auf den Empfängerkreis so zu verteilen, dass die Ziele nach § 1 nachhaltig gefördert werden.
+(3) Die Gemeinden erhalten ab dem Jahr 2020 bis zum Jahr 2064 jährlich mindestens 20 Millionen Euro an Investitionszuschüssen.
+§ 12  Verwendung der Mittel des Kommunalen Entlastungsfonds der Jahre 2020 bis 2022
+(1) Die Mittel nach dem Gesetz über den Kommunalen Entlastungsfonds werden den Gemeinden zur Finanzierung von Auszahlungen für Investitionen und für die Unterhaltung des Anlagevermögens wie folgt zur Verfügung gestellt:
+2020 13 Millionen Euro,
+2021 9 Millionen Euro,
+2022 4 Millionen Euro.
+(2) Die Verteilung der Mittel nach dem Gesetz über den Kommunalen Entlastungsfonds erfolgt entsprechend der Verteilung der allgemeinen Investitionszuweisungen nach § 11.
+§ 13  Mittelverwendung
+(1) Die Zuweisungen nach den §§ 11 und 12 müssen zweckentsprechend verwendet werden.
+(2) Die Verwendung zur zusätzlichen Tilgung struktureller Liquiditätskredite ist zulässig.
+(3) Die zweckentsprechende Verwendung ist dem Landesverwaltungsamt als Kommunalaufsichtsbehörde spätestens bis 31. März des zweiten auf das Bewilligungsjahr folgenden Jahres nachzuweisen.
+§ 14  Verfahren und Zuständigkeit
+(1) Bewilligungsbehörde für die Zuweisungen nach den §§ 11 und 12 ist das Ministerium für Inneres, Bauen und Sport. Die Zuweisungen werden nach Bestandskraft der Bewilligung an die Gemeinden ausgezahlt.
+(2) Anträge sind spätestens bis zum 31. Dezember des Bewilligungsjahres mit den erforderlichen Unterlagen bei der Kommunalaufsichtsbehörde vorzulegen. Dort verspätet eingegangene Anträge werden nicht berücksichtigt.
+(3) Mit dem Antrag auf Bewilligung der Zuweisungen sind folgende Unterlagen einzureichen, soweit sie nicht bereits bei der Kommunalaufsichtsbehörde vorliegen:
+1. Berechnung des strukturellen Ergebnisses und Nachweis der Einhaltung der Ergebnisvorgaben nach § 11 Absatz 1,
+2. Haushaltssatzung.
+Die Gemeinden bestätigen die Richtigkeit der Verteilung der Zuweisungen und der Berechnung der Bewilligungsvoraussetzungen zu Grunde liegenden von ihnen an die zuständigen Stellen zu meldenden Daten. Fehlerhaft gemeldete Daten gehen zu Lasten der Gemeinden.
+(4) Die Kommunalaufsichtsbehörde prüft, ob die formalen und materiellen Voraussetzungen für die Zuweisungen vorliegen. Sie leitet den Antrag mit dem Ergebnis ihrer Prüfung und einer Entscheidungsempfehlung an das Ministerium für Inneres, Bauen und Sport weiter. Das Ministerium für Inneres, Bauen und Sport entscheidet im Benehmen mit dem Kommunalen Sanierungsrat. Der kommunale Sanierungsrat kann in seiner Geschäftsordnung bestimmen, unter welchen Voraussetzungen das Ministerium für Inneres, Bauen und Sport eigenständig ohne vorherige Beteiligung des Kommunalen Sanierungsrates entscheiden kann. In diesem Fall ist der kommunale Sanierungsrat nachträglich zu informieren.
+(5) Die Gemeinde hat der Kommunalaufsichtsbehörde die Einhaltung des Sanierungszieles nach § 8 bis zum 31. Juli des dem Bewilligungsjahr folgenden Jahres nachzuweisen.
+§ 15  Rückforderung
+(1) Die Zuweisungen können zurückgefordert werden, wenn nachträglich bekannt wird, dass die Voraussetzungen für ihre Bewilligung nicht vorlagen, wenn diese nachträglich entfallen sind, wenn die sich aus den §§ 4 bis 13 ergebenden Anforderungen nicht eingehalten oder nicht nachgewiesen werden oder soweit Daten im Sinne des § 14 Absatz 3 Satz 2 fehlerhaft gemeldet wurden.
+(2) Die Entscheidung trifft das Ministerium für Inneres, Bauen und Sport im Benehmen mit dem Kommunalen Sanierungsrat.
+Abschnitt 5  Kommunaler Sanierungsrat
+§ 16  Kommunaler Sanierungsrat
+(1) Für die in diesem Gesetz bestimmten Aufgaben wird beim Ministerium für Inneres, Bauen und Sport ein mit Vertreterinnen oder Vertretern des Landes und des Saarländischen Städte- und Gemeindetags paritätisch besetzter Kommunaler Sanierungsrat eingerichtet.
+(2) Die Präsidentin oder der Präsident des Rechnungshofs hat das Recht, an den Sitzungen des Kommunalen Sanierungsrates teilzunehmen
+(3) Die Grundlagen der Arbeitsweise des Kommunalen Sanierungsrates regelt das Ministerium für Inneres, Bauen und Sport durch Verwaltungsvorschrift nach Anhörung der im Kommunalen Sanierungsrat vertretenen Gruppen.
+(4) Zur Regelung der weiteren Einzelheiten gibt sich der kommunale Sanierungsrat eine Geschäftsordnung.
+Abschnitt 6  Schlussvorschriften
+§ 17  Verordnungsermächtigungen
+(1) Das Ministerium für Finanzen und Europa regelt im Einvernehmen mit dem Ministerium für Inneres, Bauen und Sport durch Rechtsverordnung die Einzelheiten zum Verfahren, zu den Fristen, zur Zuständigkeit, zur Übernahmevereinbarung und zur technischen Übernahme der Liquiditätskredite nach § 3.
+(2) Die Landesregierung regelt durch Rechtsverordnung
+1. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten hinsichtlich der Übernahme und Rückführung der strukturellen Liquiditätskredite nach den §§ 2 bis 4,
+2. die Einzelheiten zum Tilgungsplan und zu den Vorgaben zur Rückführung der strukturellen Liquiditätskredite nach § 4,
+3. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten zur Sonderregelung für zahlungsbezogene Fehlbeträge in den Jahren 2020 bis 2023 nach § 5,
+4. die Einzelheiten der Berechnung, die Methodik und die der Berechnung zu Grunde zu legenden Daten hinsichtlich des zahlungsbezogenen Ergebnisses nach § 6,
+5. die Einzelheiten der Bestimmung des strukturellen Ergebnisses und der Normalentwicklung der Zahlungsarten nach § 7.
+(3) Das Ministerium für Inneres, Bauen und Sport regelt durch Rechtsverordnung die Einzelheiten der haushaltsmäßigen Verbuchung und der haushaltsmäßigen Nachweise. Die Regelungen zur Verbuchung der Übernahme von Liquiditätskrediten nach § 3 bedürfen des Einvernehmens des Ministeriums für Finanzen und Europa.
+(4) Die Landesregierung regelt die Einzelheiten des Empfängerkreises und die Verteilungskriterien nach § 11 durch Rechtsverordnung.
+(5) Entstehen der Gesamtheit aller Gemeinden oder einzelnen Gemeinden durch Europa-, Bundes- oder Landesrecht Mindereinzahlungen oder Mehrauszahlungen, die nach Abzug damit zusammenhängender Mehreinzahlungen oder Minderauszahlungen einen Betrag von 0,1 Prozent der Auszahlungen aus laufender Verwaltungstätigkeit voraussichtlich übersteigen, kann das Ministerium für Inneres, Bauen und Sport im Einvernehmen mit dem Ministerium für Finanzen und Europa und im Benehmen mit dem Kommunalen Sanierungsrat durch Rechtsverordnung entsprechende Obergrenzen für das jahresbezogene strukturelle Defizit festlegen. Voraussetzung ist, dass hierdurch die Ziele nach § 1 gefördert werden. Hierbei ist die verbindliche Rückführung von Fehlbeträgen innerhalb eines eindeutig bestimmten Zeitraums vorzusehen.
+§ 18  Verwaltungsvorschriften
+(1) Das Nähere zum Verwaltungsverfahren bestimmt das Ministerium für Inneres, Bauen und Sport durch Verwaltungsvorschriften nach Anhörung des saarländischen Städte- und Gemeindetags.
+(2) Das Ministerium für Inneres, Bauen und Sport kann die Verwendung von schriftlichen oder elektronischen Formularen und elektronischer Wege der Antrags- und Datenübermittlung verbindlich vorschreiben.
+§ 19  Evaluation
+Dieses Gesetz ist spätestens zum Stichtag 31. Dezember 2024 zu evaluieren. Der Bericht ist dem Landtag des Saarlandes spätestens zum 30. Juni 2025 vorzulegen.
diff --git a/src/test/resources/sampledata/SachsenAnhalt/FischG-LSA-neu.txt b/src/test/resources/sampledata/SachsenAnhalt/FischG-LSA-neu.txt
new file mode 100644
index 0000000..0dcad20
--- /dev/null
+++ b/src/test/resources/sampledata/SachsenAnhalt/FischG-LSA-neu.txt
@@ -0,0 +1,314 @@
+Fischereigesetz
+(FischG)
+Vom 31. August 1993
+(GVBl. LSA S. 464)
+Teil 1  Allgemeine Vorschriften
+§ 1  Sachlicher Geltungsbereich
+(1) Dieses Gesetz regelt die Fischerei in allen oberirdischen Gewässern mit Ausnahme von künstlich zu fischereiwirtschaftlichen Zwecken errichteten Anlagen sowie Teichen oder anderen geschlossenen Privatgewässern, in denen die Fische nicht herrenlos sind.
+(2) Auf die in Absatz 1 ausgenommenen Anlagen, Teiche und Gewässer finden die Vorschriften des § 3 Nr. 2, der §§ 28, 29, 34 bis 37, 40 Nrn. 1, 6, 9, 10, 18, 21 und 22, des § 47 Abs. 4, der §§ 48, 53 Abs. 1 Nrn. 7 bis 11, 15 und Abs. 3 sinngemäß Anwendung; § 3 Nr. 2 und die §§ 28, 29 finden jedoch nicht Anwendung auf Zierteiche, Hälterbecken für Speisefische und Zierfischbehälter sowie, im Hinblick auf den Bewirtschafter, auf Teiche und andere geschlossene Gewässer von insgesamt nicht mehr als 0,05 Hektar Gewässerfläche.
+(3) Dieses Gesetz findet keine Anwendung, soweit durch Staatsverträge besondere Bestimmungen über die Fischerei getroffen sind.
+§ 2  Begriffsbestimmungen
+Im Sinne dieses Gesetzes sind
+1. Fische: Fische, Neunaugen, zehnfüßige Krebse und Muscheln in allen Entwicklungsstadien und Formen einschließlich ihrem Laich;
+2. Fischnährtiere: Wirbellose Tiere (Invertebraten) der Gewässer, die als potentielle Nahrungstiere für Fische dienen können, insbesondere Zooplankton, Zoobenthos sowie die Aufwuchstiere der Uferzone (Litoral);
+3. Fischerei: das Hegen, Nachstellen, Fangen, Sichaneignen und Töten von Fischen;
+4. Fischereirecht: das auf die Fischerei von wildlebenden Fischen, einschließlich kranker und toter Fische, beschränkte ausschließliche Nutzungsrecht an einem Gewässer;
+5. Fischereiausübungsrecht: das aus dem Fischereirecht abgeleitete dingliche Recht zur tatsächlichen Ausübung der Fischerei;
+6. Fischereierlaubnis: die vom Fischereiausübungsberechtigten schuldrechtlich erteilte Gestattung zur Ausübung der Fischerei.
+§ 3  Fischereibefugnis
+Zur Ausübung der Fischerei ist nur befugt, wer
+1. als Fischereiausübungsberechtigter die volle oder als Inhaber einer Fischereierlaubnis eine beschränkte Befugnis besitzt, in einem Gewässer zu fischen und
+2. einen Fischereischein nach Maßgabe der §§ 28 und 29 besitzt.
+Teil 2  Fischereirechte
+§ 4  Inhalt des Fischereirechts
+(1) Das Fischereirecht erstreckt sich auch auf Fischnährtiere. Die Bestimmungen des Naturschutzrechts bleiben durch das Fischereirecht unberührt.
+(2) Mit dem Fischereirecht ist die Pflicht zur Hege verbunden.
+(3) Das beschränkte Fischereirecht ist das Recht an einem Gewässer, die Fischerei nur auf bestimmte Fischarten, mit bestimmten Fangmitteln, zu bestimmten Zeiten oder in anderer Weise beschränkt auszuüben. Der Inhaber des beschränkten Fischereirechts hat sich an den Besatzkosten des Hegepflichtigen angemessen zu beteiligen.
+§ 5  Eigentumsfischereirecht
+(1) Das Fischereirecht steht vorbehaltlich der Bestimmungen der §§ 6 und 7 als dingliches Recht dem Eigentümer des Gewässergrundstücks zu (Eigentumsfischereirecht). Dieses ist untrennbar mit dem Eigentum am Gewässergrundstück verbunden. Als selbständiges Recht kann es nicht begründet werden.
+(2) An Gewässern, an denen kein Eigentum begründet ist, sowie an Bundeswasserstraßen mit Ausnahme von künstlichen Wasserstraßen (Kanälen) steht das Fischereirecht vorbehaltlich anderer Eintragungen im Verzeichnis der Fischereirechte (§ 13) dem Land zu.
+§ 6  Selbständige Fischereirechte
+(1) Fischereirechte, die nicht dem Eigentümer des Gewässergrundstücks zustehen (selbständige Fischereirechte) und im Grundbuch oder im Wasserbuch eingetragen sind, bestehen als ein das Gewässergrundstück belastendes Recht fort. Selbständige Fischereirechte dürfen unbeschadet des § 7 nicht neu begründet werden.
+(2) Der Rang eines selbständigen Fischereirechts bestimmt sich nach der Zeit der Entstehung. Widersprechen sich die Eintragung im Grundbuch und die Eintragung im Wasserbuch, genießt erstere Vorrang.
+§ 7  Selbständige Fischereirechte bei Veränderungen von fließenden Gewässern
+(1) Verändert ein fließendes Gewässer durch natürliche Ereignisse sein Bett, folgt das selbständige Fischereirecht dem veränderten Bett. Bildet sich ein neuer Arm oder entsteht eine Abzweigung oder eine dauernd überstaute Wasserfläche, erstreckt sich das selbstständige Fischereirecht auch auf diese.
+(2) Bestanden am bisherigen Gewässer mehrere selbständige Fischereirechte, bestimmt sich deren räumliche Ausdehnung am veränderten Gewässer nach dem Verhältnis, in dem sie zueinander standen. Einigen sich die Fischereiberechtigten nicht, entscheidet auf Antrag die obere Fischereibehörde nach billigem Ermessen.
+(3) Vermindert die künstliche Veränderung eines fließenden Gewässers den Wert des Fischereirechts nachhaltig, so hat der Träger der baulichen Maßnahme die Inhaber des Fischereirechts zu entschädigen. Eine erhebliche Werterhöhung haben die Inhaber des Fischereirechts auszugleichen. Sie können statt dessen auf ihr Fischereirecht durch eine öffentlich beglaubigte Erklärung gegenüber dem Eigentümer des belasteten Gewässergrundstückes verzichten; in diesem Falle hat der Träger der baulichen Maßnahme den Inhaber des Fischereirechts in Höhe des Wertes des Fischereirechts vor der Veränderung zu entschädigen. Das Rechtsverhältnis zwischen dem Träger der baulichen Maßnahme und dem begünstigten Fischereiberechtigten richtet sich nach den Grundsätzen der ungerechtfertigten Bereicherung.
+§ 8  Übertragung selbständiger Fischereirechte, Vorkaufsrecht
+(1) Ein selbständiges Fischereirecht kann nur ungeteilt vererbt oder übertragen werden, es sei denn, die Übertragung erfolgt an den Eigentümer des belasteten Gewässergrundstücks. Ein Vertrag bedarf der notariellen Beurkundung. Dies gilt auch für die Verpflichtung zur Übertragung oder zum Erwerb des Fischereirechts.
+(2) Ein selbständiges Fischereirecht, das neben anderen selbständigen Fischereirechten an denselben Gewässergrundstücken besteht (Koppelfischereirecht), kann nur auf den Eigentümer des Gewässergrundstücks oder auf den Inhaber eines anderen selbständigen Fischereirechts an diesem Gewässergrundstück übertragen werden. Eine Erbengemeinschaft kann ein solches Recht auch auf einen Miterben übertragen.
+(3) Mit dem Fischereirecht verbundene Nebenrechte oder Verpflichtungen gehen auf den Erwerber über.
+(4) Bei Fischereirechten an Gewässern gemäß § 5 Abs. 2 steht dem Land, bei Fischereirechten an künstlichen Bundeswasserstraßen steht dem Bund, bei Fischereirechten an anderen Gewässern steht dem Gewässereigentümer ein Vorkaufsrecht zu. Das Vorkaufsrecht kann nur binnen eines Monats nach Mitteilung des Kaufvertrags an den Vorkaufsberechtigten ausgeübt werden. Die §§ 463 bis 469 Abs. 1, §§ 472 und 473 des Bürgerlichen Gesetzbuches sind anzuwenden.
+§ 9  Mit dem Eigentum an einem anderen Grundstück verbundene
+Fischereirechte
+(1) Steht das Fischereirecht dem jeweiligen Eigentümer eines anderen Grundstücks als dem Gewässergrundstück zu, findet § 8 Abs. 1, 2 und 4 keine Anwendung. Ist das herrschende Grundstück mit dem Recht eines Dritten belastet, kann das Fischereirecht selbständig nur mit dessen Zustimmung übertragen werden; die Zustimmungserklärung bedarf der öffentlichen Beglaubigung.
+(2) Bei der Teilung des herrschenden Grundstücks kann ein mit ihm verbundenes selbständiges Fischereirecht nur ungeteilt bei einem durch die Teilung entstandenen Grundstück verbleiben. Die Eintragung der Teilung im Grundbuch darf erst erfolgen, wenn der Eigentümer des herrschenden Grundstücks durch eine öffentlich beglaubigte Erklärung gegenüber dem Grundbuchamt bestimmt hat, bei welchem Teilgrundstück das selbständige Fischereirecht verbleiben soll. Im Zweifelsfall gilt folgendes:
+1. Gehört das Fischereirecht zu einer Haus- oder Hofstelle, besteht es für den Teil fort, auf dem sich die Gebäude befinden,
+2. gehört das Fischereirecht zu einem nicht mit einer Haus- oder Hofstelle bebauten Grundstück, besteht es für das größte Teilstück fort; ist ein größtes Teilstück nicht festzustellen, verbindet sich das Fischereirecht mit dem Gewässereigentum.
+§ 10  Aufhebung von beschränkten selbständigen Fischereirechten
+(1) Beschränkte selbständige Fischereirechte an Gewässern können gegen Entschädigung von der oberen Fischereibehörde aufgehoben werden. Die Aufhebung kann erfolgen:
+1. von Amts wegen, wenn dies im öffentlichen Interesse geboten ist,
+2. auf Antrag eines Fischereiberechtigten, wenn er nachweist, daß die Ausübung des beschränkten selbständigen Fischereirechts für die Erhaltung oder Verbesserung des Fischbestandes dauernd nachteilig ist oder einen wirtschaftlichen Fischereibetrieb des Antragstellers in dem Gewässer verhindert.
+(2) Der Begünstigte ist zur Entschädigung verpflichtet.
+§ 11  Erlöschen von beschränkten Fischereirechten
+Sind zur Ausübung eines beschränkten Fischereirechts feststehende Fischereivorrichtungen erforderlich, so kann die obere Fischereibehörde das Erlöschen des beschränkten Fischereirechts feststellen, wenn die Fischereivorrichtung während eines Zeitraumes von mindestens drei Jahren nach dem allgemeinen Inkrafttreten dieses Gesetzes zur ordnungsgemäßen Ausübung der Fischerei nicht mehr tauglich war.
+§ 12  Vereinigung von Fischereirechten
+(1) Vereinigt sich ein selbständiges Fischereirecht (§ 6) mit dem Eigentum am Gewässergrundstück oder ein beschränktes selbständiges Fischereirecht mit einem unbeschränkten Fischereirecht, erlischt es als besonderes Recht. Ist das Recht mit dem Recht eines Dritten belastet, setzt sich dessen Recht im bisherigen Umfang am Eigentum beziehungsweise am unbeschränkten Fischereirecht fort.
+(2) Stehen mehrere selbständige Fischereirechte an demselben Gewässergrundstück oder an mehreren aneinandergrenzenden Gewässergrundstücken demselben Inhaber zu, vereinigen sich diese Rechte zu einem einheitlichen Recht. Die Rechte Dritter an den einzelnen Rechten setzen sich an dem vereinigten Recht im bisherigen Umfang fort.
+§ 13  Verzeichnis der Fischereirechte
+(1) Nachgewiesene selbständige Fischereirechte sind auf Antrag in ein Verzeichnis der oberen Fischereibehörde einzutragen. Die Einsicht in das Verzeichnis ist jedem gestattet.
+(2) Das für Fischerei zuständige Ministerium wird ermächtigt, Einzelheiten über die Einrichtung und die Führung des Verzeichnisses durch Verordnung zu regeln.
+Teil 3  Fischereiausübungsrecht
+§ 14  Grundsätze
+(1) Das Fischereiausübungsrecht steht dem Fischereiberechtigten, im gemeinschaftlichen Fischereibezirk (§ 18 Abs. 2 Satz 2) der Fischereigenossenschaft zu.
+(2) Ist der Fischereiausübungsberechtigte eine Personenmehrheit oder besitzt er sonst keinen Fischereischein nach § 28 und wird die Fischerei weder durch Verpachtung noch durch angestellte Fischer ausgeübt, so wird sie von demjenigen ausgeübt, den der Verfügungsberechtigte der Fischereibehörde benennt. Wird innerhalb einer dem Verfügungsberechtigten dafür gesetzten angemessenen Frist keine geeignete Person, die im Besitz eines Fischereischeins sein muß, benannt, so kann die Fischereibehörde die zur Ausübung und zum Schutze der Fischerei erforderlichen Maßnahmen auf seine Kosten selbst treffen.
+(3) Juristische Personen, mit Ausnahme von Fischerzünften, Anglervereinigungen, Anglervereinen und Zusammenschlüssen von Berufsfischern, dürfen Fischereiausübungsrechte nur durch Verpachtung nutzen. Die obere Fischereibehörde kann anstelle der Verpachtung die Erteilung von Erlaubnissen zulassen.
+(4) Bei der Ausübung der Fischerei sind die allgemein anerkannten Grundsätze der Fischerei zu beachten. Die im und am Gewässer lebende Tier- und Pflanzenwelt einschließlich ihrer Lebensgemeinschaften darf nicht mehr als notwendig beeinträchtigt werden und der Zustand des aquatischen Ökosystems darf nicht verschlechtert werden. Nachhaltig verletzte Fische sind unverzüglich zu töten. Die Vorschriften des Wasser-, Tierschutz-, Lebensmittel- und Tierseuchenrechts bleiben unberührt.
+§ 15  Fischerei in befriedeten Bezirken
+Die Ausübung der Fischerei in Gewässern oder Gewässerstrecken, die sich innerhalb von Gebäuden, zum unmittelbaren Haus-, Wohn- und Hofbereich gehörenden Grundstücksteilen oder gewerblichen Anlagen mit Ausnahme von Campingplätzen befinden, ist nur mit Zustimmung von deren Nutzungsberechtigten zulässig.
+§ 16  Fischerei auf überfluteten Grundstücken
+(1) Tritt ein Gewässer vorübergehend über seine Ufer, sind ausschließlich der Fischereiausübungsberechtigte dieses Gewässers und seine Helfer berechtigt, auf den überfluteten Grundstücken die Fischerei auszuüben. Von der Befischung ausgeschlossen sind überflutete fremde Fischgewässer sowie ohne Zustimmung des Nutzungsberechtigten zum unmittelbaren Haus-, Wohn- und Hofbereich gehörende Grundstücksteile, Garten- und Parkanlagen, gewerbliche Anlagen und bestellte Äcker. Die überfluteten Grundstücke dürfen nur betreten werden, soweit sie nicht von Wasserfahrzeugen aus befischt werden können.
+(2) Sind mehrere berechtigt, die Fischerei auf den überfluteten Grundstücken auszuüben, gilt § 7 Abs. 2 mit der Maßgabe entsprechend, daß die Fischereibehörde zuständig ist.
+(3) Maßnahmen, die die Rückkehr der Fische in ein Gewässer oder die Fischerei auf den überfluteten Grundstücken erschweren oder verhindern, sind unzulässig.
+(4) Fische, die in Gräben oder anderen Vertiefungen, die nicht mehr in Verbindung mit den Gewässern stehen, zurückbleiben, kann sich der Fischereiausübungsberechtigte innerhalb von zwei Wochen nach Rücktritt des Wassers aneignen. Nach Ablauf dieser Frist geht das ausschließliche Aneignungsrecht auf den Eigentümer oder an seiner Stelle auf den sonstigen Nutzungsberechtigten des Grundstücks über.
+(5) Schäden, die dem Eigentümer oder den sonstigen Nutzungsberechtigten durch die Ausübung der Fischerei auf überfluteten Grundstücken entstehen, hat der Fischereiausübungsberechtigte zu ersetzen. Er haftet auch für Schäden, die durch seine Helfer verursacht werden.
+§ 17  Uferbetretungsrecht, Zugang zum Gewässer
+(1) Das Fischereiausübungsrecht umfaßt die Befugnis, die an das Gewässer angrenzenden Ufer, Anlandungen und Schiffahrtsanlagen sowie Brücken, Wehre, Schleusen und sonstige Wasserbauwerke zu benutzen, soweit dies zum Zwecke der Ausübung der Fischerei erforderlich ist und öffentlich-rechtliche Vorschriften nicht entgegenstehen. Die Befugnis erstreckt sich nicht auf Gebäude, zum unmittelbaren Haus-, Wohn- und Hofbereich gehörende Grundstücksteile und gewerbliche Anlagen mit Ausnahme von Campingplätzen. Die Befugnis ist so auszuüben, daß Schäden an angrenzenden Ufern und Anlagen vermieden, der Abfluß in den Gewässern sowie der ökologische Zustand des Gewässers nicht beeinträchtigt und die Funktionsfähigkeit der Anlagen nicht gestört werden.
+(2) Die Fischereibehörde kann im Einzelfall das Betreten von Uferflächen und Anlagen in und an Gewässern einschränken oder verbieten, soweit dies zum Schutz der Anlagen oder zur Abwehr einer Gefahr für die öffentliche Sicherheit und Ordnung erforderlich ist.
+(3) Kann der Fischereiausübungsberechtigte das Gewässer nicht auf einem öffentlichen Weg oder nur auf einem unzumutbaren Umweg erreichen und kommt eine Vereinbarung mit dem Grundstücksberechtigten zum Benutzen von Grundstücken nicht zustande, kann die Fischereibehörde auf Antrag Ort und Umfang des Benutzungsrechts sowie die Höhe des Nutzungsentgelts festsetzen.
+(4) Das Benutzen der Grundstücke erfolgt auf eigene Gefahr. § 16 Abs. 5 gilt entsprechend.
+Teil 4  Fischereibezirke
+§ 18  Fischereibezirk
+(1) Die obere Fischereibehörde kann in allen Gewässern nach § 1 Abs. 1 Fischereibezirke bilden, wenn dies zur Erhaltung des Fischbestandes und zur Sicherstellung einer ordnungsgemäßen fischereilichen Nutzung erforderlich ist. Die Abgrenzung der Fischereibezirke ist so vorzunehmen, daß der Fischereibezirk eine fischereibiologische Einheit möglichst ganz umfaßt sowie eine sinnvolle fischereiliche Bewirtschaftung zuläßt.
+(2) Steht das Fischereirecht innerhalb eines Fischereibezirks nur einer natürlichen oder juristischen Person oder einer Personengemeinschaft zu, handelt es sich um einen Eigenfischereibezirk. Die übrigen Fischereibezirke sind gemeinschaftliche Fischereibezirke.
+§ 19  Fischereigenossenschaft
+(1) Die Fischereiberechtigten eines gemeinschaftlichen Fischereibezirks bilden eine Fischereigenossenschaft.
+(2) Die Fischereigenossenschaft ist eine Körperschaft des öffentlichen Rechts. Sie untersteht der Rechtsaufsicht der Fischereibehörde. Diese hat die gleichen Befugnisse, die den Kommunalaufsichtsbehörden gegenüber den Gemeinden zustehen.
+(3) Die Fischereigenossenschaft hat sich zur Regelung ihrer Verhältnisse eine Satzung zu geben; diese bedarf der Genehmigung durch die Fischereibehörde. Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung eine Mustersatzung zu erlassen und zu bestimmen, daß die Mustersatzung für diejenigen Fischereigenossenschaften verbindlich ist, die innerhalb einer von der Fischereibehörde gesetzten Frist selbst keine ausreichende Satzung aufgestellt haben. Wird die Mustersatzung beschlossen, bedarf diese in Abweichung von Satz 1 Halbsatz 2 nur der Anzeige an die Fischereibehörde.
+(4) Die Fischereigenossenschaft wird durch den Fischereivorstand gerichtlich und außergerichtlich vertreten. Der Fischereivorstand wird von der Genossenschaftsversammlung gewählt. Solange die Fischereigenossenschaft keinen Fischereivorstand besitzt, werden deren Geschäfte von der zuständigen Fischereibehörde wahrgenommen.
+(5) Beschlüsse der Fischereigenossenschaft bedürfen der Mehrheit der anwesenden und vertretenen Fischereigenossen, die zugleich die Mehrheit der bei der Beschlußfassung vertretenen Gewässerfläche darstellen müssen. Die Inhaber beschränkter Fischereirechte nehmen nur an der Abstimmung nach Köpfen teil. Die Vollmacht zur Vertretung eines Fischereigenossen in der Versammlung der Fischereigenossen bedarf der Schriftform.
+(6) Die Fischereigenossenschaft beschließt über die Verwendung des Reinertrages der Nutzung der Fischereirechte. Beschließt die Fischereigenossenschaft, den Ertrag nicht an die Fischereigenossen nach dem Verhältnis des Flächeninhaltes ihrer beteiligten Gewässer zu verteilen, so kann jeder Fischereigenosse, der dem Beschluß nicht zugestimmt hat, die Auszahlung seines Anteils nach dem Verhältnis des Flächeninhaltes verlangen. Der Anspruch erlischt, wenn er nicht binnen einem Monat nach der Bekanntmachung der Beschlußfassung schriftlich oder mündlich zu Protokoll des Fischereivorstandes geltend gemacht wird.
+Teil 5  Fischereipacht
+§ 20  Fischereipacht
+(1) Das Fischereiausübungsrecht in seiner Gesamtheit kann verpachtet werden. Ein Teil des Fischereiausübungsrechts kann nicht Gegenstand eines Fischereipachtvertrages sein. Der Verpächter kann sich neben dem Pächter das Fischereiausübungsrecht in seiner Gesamtheit vorbehalten. Die Verpachtung des Fischereiausübungsrechts nach Teilbereichen ist zulässig. Das Fischereirecht selbst kann nicht verpachtet werden.
+(2) Der Abschluß und die Änderung eines Fischereipachtvertrages bedürfen der Schriftform. Die Pachtdauer soll mindestens zwölf Jahre betragen. Ein laufender Pachtvertrag kann auf kürzere Zeit verlängert werden. Beginn und Ende der Pachtzeit soll mit dem Kalenderjahr zusammenfallen.
+(3) Pächter können nur sein
+1. wer einen Fischereischein nach § 28 besitzt und schon vorher einen solchen oder einen Mitgliedsausweis im Sinne des § 31 Abs. 3 Nr. 2 während dreier Jahre besessen hat,
+2. die in § 14 Abs. 3 als Ausnahme genannten juristischen Personen. Für besondere Fälle können Ausnahmen von Satz 1 zugelassen werden.
+(4) Ein Fischereipachtvertrag, der bei seinem Abschluß den Vorschriften des Absatzes 1 Satz 2 oder 5 oder des Absatzes 3 Satz 1 nicht entspricht, ist nichtig. Dasselbe gilt für die Mit-, Unter- oder Weiterpacht.
+§ 21  Anzeige von Fischereipachtverträgen
+(1) Der Fischereipachtvertrag ist der zuständigen Fischereibehörde anzuzeigen; dasselbe gilt für die Mit-, Unter- oder Weiterpacht. Die Behörde kann den Vertrag binnen drei Wochen nach Eingang der Anzeige beanstanden, wenn die Vorschriften über die Pachtdauer nicht beachtet sind oder wenn zu erwarten ist, daß durch eine vertragsmäßige Fischerei die Vorschriften des § 41 Abs. 1 verletzt werden.
+(2) In dem Beanstandungsbescheid sind die Vertragspartner aufzufordern, den Vertrag bis zu einem bestimmten Zeitpunkt, der mindestens drei Wochen nach Zustellung des Bescheides liegen soll, aufzuheben oder in bestimmter Weise zu ändern.
+(3) Kommen die Vertragspartner der Aufforderung nicht nach, so gilt der Vertrag mit Ablauf der Frist als aufgehoben, sofern nicht einer der Vertragsteile binnen der Frist einen Antrag auf Entscheidung durch das Amtsgericht stellt. Das Gericht kann entweder den Vertrag aufheben oder feststellen, daß er nicht zu beanstanden ist. Die Vorschriften für die gerichtliche Entscheidung über die Beanstandung eines Landpachtvertrages gelten sinngemäß; jedoch entscheidet das Gericht ohne Zuziehung ehrenamtlicher Richter.
+(4) Vor Ablauf von drei Wochen nach Anzeige des Vertrages durch einen Beteiligten darf der Pächter die Fischerei nicht ausüben oder ausüben lassen, sofern nicht die Behörde sie zu einem früheren Zeitpunkt gestattet. Wird der Vertrag binnen der in Absatz 1 Satz 2 bezeichneten Frist beanstandet, darf der Pächter die Fischerei erst ausüben oder ausüben lassen, wenn die Beanstandungen behoben sind oder wenn durch rechtskräftige gerichtliche Entscheidung festgestellt ist, daß der Vertrag nicht zu beanstanden ist.
+§ 22  Erlöschen des Fischereipachtvertrages
+Der Fischereipachtvertrag erlischt, wenn dem fischereiausübungsberechtigten Pächter der Fischereischein unanfechtbar entzogen worden ist. Er erlischt auch dann, wenn die Gültigkeitsdauer des Fischereischeins abgelaufen ist und entweder die zuständige Behörde die Erteilung eines neuen Fischereischeins unanfechtbar abgelehnt hat oder der Pächter innerhalb einer von der Fischereibehörde gesetzten Frist keinen Fischereischein beantragt oder sonstige Voraussetzungen für die Erteilung eines neuen Fischereischeins nicht fristgemäß erfüllt. Der Pächter hat dem Verpächter den aus der Beendigung des Pachtvertrages entstehenden Schaden zu ersetzen, wenn ihn ein Verschulden trifft.
+§ 23  Erbfolge in den Fischereipachtvertrag
+(1) Stirbt der Pächter vor Ablauf der Pachtzeit, so haben seine Erben der Fischereibehörde die Person zu benennen, die die Fischerei ausüben soll. Gehört die benannte Person nicht zu den Erben, muß sie fischereipachtfähig (§ 20 Abs. 3 Satz 1 Nr. 1) sein. Im übrigen gilt § 14 Abs. 2 Satz 2 entsprechend.
+(2) Der Fischereipachtvertrag erlischt am Ende des ersten nach dem Tode des Pächters beginnenden Kalenderjahres gegenüber denjenigen Erben, die zu diesem Zeitpunkt einen Fischereischein nicht beantragt haben oder sonstige Voraussetzungen dafür nicht erfüllen.
+§ 24  Rechtsstellung von Mitpächtern
+Sind mehrere Pächter an einem Fischereipachtvertrag beteiligt (Mitpächter), so bleibt der Vertrag, wenn er im Verhältnis zu einem Mitpächter gekündigt wird oder erlischt, mit den übrigen bestehen. Ist einem der Beteiligten die Aufrechterhaltung des Vertrages infolge des Ausscheidens eines Pächters nicht zuzumuten, so kann er den Vertrag mit sofortiger Wirkung kündigen. Die Kündigung muß unverzüglich nach Erlangung der Kenntnis von dem Kündigungsgrund erfolgen.
+§ 25  Wechsel des Grundeigentümers
+(1) Wird ein Fischereirecht allein oder verbunden mit einem Fischgewässer ganz oder teilweise veräußert, finden die Vorschriften der §§ 566 bis 567b des Bürgerlichen Gesetzbuchs entsprechende Anwendung. Das gleiche gilt im Falle der Zwangsversteigerung von der Vorschrift des § 57 des Gesetzes über die Zwangsversteigerung und die Zwangsverwaltung; das Kündigungsrecht des Erstehers ist jedoch ausgeschlossen.
+(2) Wird ein zu einem gemeinschaftlichen Fischereibezirk gehörendes Fischereirecht veräußert, so hat dies auf den Pachtvertrag keinen Einfluß; der Erwerber wird vom Zeitpunkt des Erwerbes an Mitglied der Fischereigenossenschaft. Das gleiche gilt für den Fall der Zwangsversteigerung eines Grundstücks.
+Teil 6  Fischereierlaubnis
+§ 26  Fischereierlaubnis
+(1) Fischereierlaubnisse dürfen nur an natürliche Personen auf höchstens ein Jahr erteilt werden. Der Fischereiausübungsberechtigte darf Erlaubnisse nur in solchem Umfang ausgeben, daß Nachteile für den ökologischen Gewässerzustand, insbesondere die Fischfauna, nicht zu befürchten sind.
+(2) Die obere Fischereibehörde kann zur Erhaltung eines angemessenen Fischbestandes für Gewässer die Höchstzahl der Fischereierlaubnisse für das folgende Kalenderjahr festsetzen, die vom Fischereiausübungsberechtigten nicht überschritten werden darf.
+(3) Der Fischereiausübungsberechtigte hat der Fischereibehörde bis zum 15. Januar eines jeden Jahres die Zahl der im vorausgegangenen Jahr je Gewässer erteilten Fischereierlaubnisse anzuzeigen. Eine Fischereierlaubnis kann beanstandet werden, wenn sie mit den allgemein anerkannten Grundsätzen der Fischerei (§ 14 Abs. 4) nicht vereinbar ist. § 21 Abs. 2 und 3 gilt entsprechend.
+(4) Übt ein Erlaubnisinhaber die Fischerei aus, ohne daß der Fischereiausübungsberechtigte oder ein von diesem mit der Begleitung des Erlaubnisinhabers beauftragter angestellter Fischer anwesend oder ohne Schwierigkeiten zu erreichen ist, hat er eine schriftliche Fischereierlaubnis des Fischereiausübungsberechtigten (Fischereierlaubnisschein/Angelkarte) mit sich zu führen und diesen auf Verlangen Polizeibeamten und Fischereischutzberechtigten vorzuzeigen. Keines Erlaubnisscheins bedürfen angestellte Fischer und die in § 28 Abs. 2 Halbsatz 1 genannten Personen.
+(5) Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung Muster für die Erlaubnisscheine zu bestimmen.
+(6) Über die Ausgabe der Erlaubnisscheine sind vom Fischereiausübungsberechtigten Listen zu führen und auf Verlangen den Fischereibehörden vorzulegen. Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung das Nähere über das Führen der Listen zu bestimmen.
+§ 27  Erlöschen und Kündigung der Fischereierlaubnis
+(1) Die Fischereierlaubnis ist nicht übertragbar. Sie erlischt
+1. mit dem Tod des Berechtigten,
+2. wenn das Fischereiausübungsrecht des Erlaubnisgebers endet.
+(2) Eine unentgeltliche Fischereierlaubnis kann jederzeit aufgehoben werden, auch wenn sie auf bestimmte Zeit erteilt ist. Eine entgeltliche Fischereierlaubnis ist spätestens am dritten Werktag eines Kalendermonats für den Ablauf des Monats kündbar. Das Entgelt ist anteilig zu erstatten, sofern der Kündigungsgrund nicht vom Erlaubnisnehmer zu vertreten ist. Das Recht zur außerordentlichen Kündigung bleibt unberührt.
+Teil 7  Fischereischein
+§ 28  Fischereischein
+(1) Wer die Fischerei ausübt, bedarf der behördlichen Erlaubnis. Diese wird durch einen Fischereischein erteilt. Hegemaßnahmen untergeordneter Bedeutung, die Aneignung von Fischen sowie das Töten im Eigentum stehender Fische bedürfen der behördlichen Erlaubnis nicht.
+(2) Ein Fischereischein ist nicht erforderlich für Personen,
+1. die einen fischereibefugten Inhaber eines Fischereischeines nach Absatz 1 bei der Ausübung des Fischfangs unterstützen,
+2. die im Rahmen von Lehrgängen nach § 31 Abs. 1 Satz 1 unter Aufsicht des Ausbilders die Fischerei mit der Handangel ausüben.
+(3) Der Fischereischein ist bei der Ausübung der Fischerei mit sich zu führen und auf Verlangen Polizeibeamten und Fischereischutzberechtigten vorzuzeigen.
+(4) Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung zu regeln, in welchem Umfang eine Unterstützung nach Absatz 2 Nr. 1 zulässig und in welchen weiteren besonderen Fällen ein Fischereischein nicht erforderlich ist, sowie durch Verordnung die Anerkennung und Gleichstellung von Fischereischeinen anderer Bundesländer und Staaten zu regeln.
+§ 29  Friedfischfischereischein, Sonderfischereischein
+(1) Personen, die das achte Lebensjahr vollendet haben, darf ein Friedfischfischereischein erteilt werden, sofern sie die Friedfischfischerprüfung bestanden haben. Bis zur Vollendung des zwölften Lebensjahres darf ausschließlich ein Friedfischfischereischein erteilt werden.
+(2) Personen, die aufgrund einer Behinderung nicht in der Lage sind, eine ihrem Alter entsprechende Fischerprüfung abzulegen, kann ein Sonderfischereischein erteilt werden.
+(3) (aufgehoben)
+(4) Der Friedfischfischereischein und der Sonderfischereischein berechtigen nur zum Friedfischfang, der Sonderfischereischein nur in Begleitung einer volljährigen Person, die den Friedfischfischereischein oder einen Fischereischein im Sinne von § 28 besitzt.
+(5) Im übrigen gilt § 28 entsprechend.
+§ 30  Ausstellung der Fischereischeine
+(1) Die zuständige Fischereibehörde erteilt den Fischereischein oder verlängert dessen Geltungsdauer für ein bis fünf Kalenderjahre oder auf Lebenszeit nach einheitlichen, von dem für Fischerei zuständigen Ministerium bestimmten Mustern.
+(2) (aufgehoben)
+(3) Die Gebühren für Fischereischeine richten sich nach der Allgemeinen Gebührenordnung des Landes Sachsen-Anhalt. Für Friedfischfischereischeine und Fischereischeine im Sinne von § 28 für Inhaber, die das 18. Lebensjahr noch nicht vollendet haben, sowie für Sonderfischereischeine können niedrigere Gebühren erhoben werden. Für Personen, die mit der Fischerei amtlich oder beruflich befasst sind, können Gebührenbefreiung oder ermäßigte Sätze festgesetzt werden.
+(4) Mit der Gebühr für den Fischereischein erhebt die Fischereibehörde eine Fischereiabgabe. Die Abgabe steht dem Land zu und ist für Maßnahmen des Fischereischutzes, des Fischartenschutzes, der Fischereiforschung, für besondere Maßnahmen der Hege oder ähnliche fischereiliche Zwecke sowie für gebotene Ausgleichszahlungen zu verwenden. Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung die Höhe der Abgabe zu bestimmen. Absatz 3 Satz 2 und 3 gilt entsprechend.
+§ 31  Fischerprüfung
+(1) Die erste Erteilung eines Fischereischeins ist davon abhängig, daß der Antragsteller im Geltungsbereich dieses Gesetzes nach Teilnahme an einem Lehrgang mit mindestens 30 Unterrichtsstunden eine Fischerprüfung bestanden hat. In der Prüfung hat er ausreichende Kenntnisse über die Arten der Fische, die Hege der Fischbestände und die Pflege der Fischgewässer, die Fanggeräte und deren Gebrauch, die Behandlung gefangener Fische und die fischereirechtlichen sowie die einschlägigen tierschutz-, naturschutz-, wasser- und hygienerechtlichen Vorschriften nachzuweisen. § 28 Abs. 4 gilt für die Fischerprüfung entsprechend.
+(2) Die Fischerprüfung besteht aus einem schriftlichen und einem mündlich-praktischen Teil. Sie wird durch eine Prüfungskommission abgenommen. Zur Erlangung eines Friedfischfischereischeines ist eine Friedfischfischerprüfung vorzusehen. Die Friedfischfischerprüfung wird unter erleichterten Bedingungen abgelegt. Das für Fischwirtschaft zuständige Ministerium wird ermächtigt, durch Verordnung die Mindestanforderungen an den Lehrgang nach Absatz 1 Satz 1 und an die Ausbilder für diesen Lehrgang, die Zusammensetzung der Prüfungskommission und die Prüfungsordnung zu regeln und eine angemessene Vergütung für die Prüfer festzusetzen sowie die Durchführung der Friedfischfischerprüfung an Anglervereine zu übertragen. Die Durchführung der Lehrgänge nach Absatz 1 Satz 1 kann durch die obere Fischereibehörde auf Dritte übertragen werden.
+(3) Von der Ablegung der Fischerprüfung sind befreit:
+1. beruflich ausgebildete Fischer mit entsprechender Abschluß- oder Meisterprüfung sowie Personen, die hierzu ausgebildet werden,
+2. Personen, die vor dem allgemeinen In-Kraft-Treten des Gesetzes zur Änderung des Fischereigesetzes im Besitz eines Fischereischeines waren, der auf der Grundlage eines am 3. Oktober 1990 gültigen oder danach bis zum 7. September 1993 ausgestellten Mitgliedsausweises des Deutschen Anglerverbandes (DAV) oder eines gleichwertigen Dokuments mit eingetragener Raubfischqualifikation oder Sportfischerprüfung des Verbandes Deutscher Sportfischer (VDSF) erworben wurde.
+(4) Bei der Erteilung von Fischereischeinen an Personen, die keinen Wohnsitz im Geltungsbereich des Grundgesetzes haben oder dem keine deutsche Staatsangehörigkeit besitzen und nachweisen können, daß sie zur Fischereiausübung in Sachsen-Anhalt befähigt sind, können Ausnahmen von Absatz 1 gemacht werden. Die Ausnahme ist im Fischereischein zu vermerken.
+§ 32  Versagung des Fischereischeins
+(1) Der Fischereischein ist Personen zu versagen, bei denen Tatsachen die Annahme rechtfertigen, daß sie die erforderliche Zuverlässigkeit nicht besitzen.
+(2) Der Fischereischein kann Personen versagt werden,
+1. die gegen die Grundsätze des § 14 Abs. 4 Satz 1 schwer oder wiederholt verstoßen haben,
+2. denen der Fischereischein auf Grund einer Ausnahme nach § 31 Abs. 4 erteilt wurde.
+(3) Die erforderliche Zuverlässigkeit besitzen in der Regel Personen nicht, die
+1. 
+a) wegen einer Straftat gegen fischerei-, jagd-, tierschutz-, naturschutz- oder wasserrechtliche Vorschriften,
+b) wegen Beschädigung von Anlagen, Fahrzeugen, Geräten oder Vorrichtungen, die der Fischerei oder Fischzucht dienen, oder von Wasserbauten,
+c) wegen Fälschung eines Fischereischeines oder einer sonstigen zur Ausübung der Fischerei erforderlichen Bescheinigung, zu einer Freiheitsstrafe, Jugendstrafe oder Geldstrafe von mindestens 60 Tagessätzen oder mindestens zweimal zu einer geringeren Geldstrafe rechtskräftig verurteilt worden sind; dies gilt nicht, wenn seit dem Eintritt der Rechtskraft der letzten Verurteilung fünf Jahre verstrichen sind; in die Frist wird die Zeit eingerechnet, die seit der Vollziehbarkeit des Widerrufs oder der Rücknahme eines Fischereischeins wegen der Tat, die der letzten Verurteilung zugrunde liegt, verstrichen ist; in die Frist nicht eingerechnet wird die Zeit, in welcher der Beteiligte auf behördliche oder richterliche Anordnung in einer Anstalt verwahrt worden ist;
+2. wiederholt oder gröblich gegen eine in Nummer 1 Halbsatz 1 Buchst. a genannte Vorschrift verstoßen haben.
+§ 33  Rücknahme und Widerruf
+(1) Die behördliche Erlaubnis (Fischereischein) ist zurückzunehmen, wenn nachträglich bekannt wird, daß sie hätte versagt werden müssen. Sie kann zurückgenommen werden, wenn nachträglich bekannt wird, daß die Erlaubnis hätte versagt werden können.
+(2) Die behördliche Erlaubnis (Fischereischein) ist zu widerrufen, wenn nachträglich Tatsachen eintreten, die zur Versagung hätten führen müssen. Sie kann widerrufen werden, wenn nachträglich Tatsachen eintreten, die zur Versagung hätten führen können.
+(3) Wird die Erlaubnis zurückgenommen oder widerrufen, ist der Fischereischein für ungültig zu erklären und einzuziehen. Ein Anspruch auf Rückerstattung der Fischereischeingebühren oder der Fischereiabgabe besteht nicht. Die Behörde kann eine Sperrfrist für die Wiedererteilung des Fischereischeins festsetzen.
+Teil 8  Fischereischutz und Schutz der Fischbestände
+§ 34  Fischereischutzberechtigte
+Der Fischereischutz obliegt neben den Fischereibehörden dem Inhaber unbeschränkter Fischereiausübungsrechte, sofern er im Besitz eines Fischereischeins ist, und den von der Fischereibehörde bestätigen Fischereiaufsehern. Das für Fischwirtschaft zuständige Ministerium wird ermächtigt, durch Verordnung die Voraussetzungen und das Verfahren der Bestätigung von Fischereiaufsehern und eine Entschädigung für deren Tätigkeit aus Mitteln der Fischereiabgabe zu bestimmen.
+§ 35  Inhalt des Fischereischutzes
+(1) Der Fischereischutz dient dem Schutz des Fischereiausübungsrechts und der Fische insbesondere vor Wilderei, Fischdiebstahl und Fischseuchen sowie der Sorge für die Einhaltung der zum Schutz der Fische und der Fischerei erlassenen Vorschriften.
+(2) Der Fischereischutz umfaßt die Befugnis, Personen, die in Gewässern unberechtigt fischen, eine sonstige Zuwiderhandlung gegen fischereirechtliche Vorschriften begehen oder an oder auf Gewässern, in denen sie nicht zur Fischerei berechtigt sind, Fischereigeräte und sonstige Fangmittel fangfertig mitführen, anzuhalten, ihnen gefangene Fische und Fanggeräte abzunehmen und die Identität ihrer Person festzustellen. Die §§ 46 bis 48 des Gesetzes über die öffentliche Sicherheit und Ordnung des Landes Sachsen-Anhalt gelten entsprechend.
+(3) Die zuständigen öffentlichen Stellen sind verpflichtet, in vertrauensvoller Zusammenarbeit bei allen Maßnahmen nach diesem Gesetz die Erfordernisse des Arten- und Biotopschutzes zu berücksichtigen und insbesondere für solche Fischarten, deren Bestand bedroht erscheint, den erforderlichen Schutz zu sichern.
+§ 36  Anzeige von Fischsterben
+(1) Die Fischereiberechtigten und Fischereiausübungsberechtigten sind verpflichtet, Fischsterben unverzüglich der Fischereibehörde oder einer Polizeidienststelle anzuzeigen. Die Anzeigepflicht nach § 9 Abs. 1 und 2 des Tierseuchengesetzes bleibt unberührt.
+(2) Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung die Mitwirkungspflichten der Fischereiausübungsberechtigten bei der Bekämpfung eines Fischsterbens zu regeln.
+§ 37  Verbote
+(1) Bei der Fischerei ist die Verwendung künstlichen Lichts als Lockmittel, elektrischen Stroms, explodierender, betäubender oder giftiger Mittel oder verletzenden Geräts mit Ausnahme von Angelhaken verboten. Die obere Fischereibehörde kann im Einzelfall Ausnahmen vom Verbot der Verwendung künstlichen Lichts, elektrischen Stroms oder betäubender Mittel zu fischereiwirtschaftlichen oder wissenschaftlichen Zwecken zulassen.
+(2) Niemand darf an oder auf Gewässern, in denen er nicht zur Fischerei berechtigt ist, Fischereigeräte und sonstige Fangmittel fangfertig mitführen. Das Mitführen unerlaubter Fischereigeräte und unerlaubter sonstiger Fangmittel an oder auf Gewässern ist untersagt.
+(3) Der Einsatz seuchenkranker oder seuchenverdächtiger sowie ansteckungsverdächtiger Fische ist verboten. Die Bestimmungen des Tierseuchengesetzes sowie der Fischseuchen-Verordnung in der Fassung der Bekanntmachung vom 3. November 2004 (BGBl. I S. 2754), in der jeweils geltenden Fassung bleiben unberührt.
+§ 38  Schadenverhütende Maßnahmen an Anlagen zur Wasserentnahme
+und an Triebwerken
+Wer Anlagen zur Wasserentnahme oder Triebwerke errichtet oder betreibt, hat auf seine Kosten durch geeignete Vorrichtungen das Eindringen von Fischen zu verhindern und für die schadlose Ableitung der Fische in das Unterwasser zu sorgen; § 46 Abs. 3 bleibt unberührt. Die obere Fischereibehörde kann bei neu zu errichtenden Anlagen im Einzelfall die Mindestanforderungen an die Schutzvorrichtung und die Ableitung, insbesondere an die lichte Durchlassweite, die Anströmgeschwindigkeit, den Winkel zur Hauptströmung und die für die Ableitung notwendige Wassermenge, festsetzen. Dies gilt auf Antrag des Betreibers auch für bestehende Anlagen. Für unvermeidbare Schädigungen des Fischbestandes haben die nach Satz 1 Verpflichteten den betroffenen Fischereiausübungsberechtigten Ersatz zu leisten. Weitergehende Ansprüche nach anderen Vorschriften bleiben unberührt.
+§ 39  Absenken von Gewässern
+(1) Der zum Absenken eines Gewässers wasserrechtlich Berechtigte hat den Fischereiausübungsberechtigten an diesem Gewässer den Beginn und die voraussichtliche Dauer des Absenkens mindestens zehn Tage vorher schriftlich mitzuteilen. Bei Gefahr im Verzug, insbesondere bei Hochwasser, Eisgang oder unvorhergesehenen Ausbesserungen einer Betriebseinrichtung, darf sofort abgesenkt werden; der Fischereiausübungsberechtigte und die Fischereibehörde sind hiervon unverzüglich zu unterrichten.
+(2) Zwischen Maßnahmen der Gewässerunterhaltung, die mit einer vorübergehenden erheblichen Absenkung des Wasserstandes verbunden sind, muß ein Zeitraum von mindestens drei Jahren liegen. Ausnahmen bedürfen der Genehmigung der Fischereibehörde.
+(3) Einem Gewässer darf nicht so viel Wasser entzogen werden, daß es hierdurch als Lebensraum nachhaltig geschädigt wird. Die obere Fischereibehörde kann hiervon aus besonderen Gründen Ausnahmen zulassen. Der Begünstigte oder mangels eines solchen das Land haben eine Entschädigung zu leisten.
+(4) Bei Talsperren, Hochwasserrückhaltebecken und Wasserspeichern regelt sich das Anstauen und Ablassen nach den wasserrechtlichen Benutzungsentscheidungen oder Betriebsplänen, die vom Fischereiausübungsberechtigten zu beachten sind.
+§ 40  Fischereiordnung
+Das für Fischerei zuständige Ministerium wird ermächtigt, im Einvernehmen mit dem für Wasserwirtschaft zuständigen Ministerium und dem für Naturschutz zuständigen Ministerium zum Schutz der Fische, der Fischbestände und ihrer Lebensgrundlagen in Form einer artenreichen Flora und Fauna, zur Verwirklichung des Hegeziels sowie zur nachhaltigen Sicherung der Fischerei durch Verordnung Vorschriften zu erlassen über:
+1. Art und Methoden der Fischerei sowie die Beschaffenheit und zeitliche Verwendung der Fischereigeräte, Fanggeräte, Fangvorrichtungen und der Köder,
+2. Fangverbote und Mengenbeschränkungen,
+3. Schonzeiten der Fische einschließlich der Verbote oder der Beschränkungen der Fischerei während der Schonzeiten,
+4. das Mindestmaß der Fische, die Behandlung untermaßiger oder während der Schonzeit gefangener Fische,
+5. die Anlandung, die Beförderung, den Verkauf und die Verwertung untermaßiger oder während der Schonzeit gefangener Fische,
+6. Markt- und Verkehrsverbote,
+7. die Verpflichtung zur Anlandung von gefangenen Fischen bestimmter Arten, deren Vorkommen oder Vermehrung aus fischereibiologischen Gründen unerwünscht ist,
+8. Verbote oder Beschränkungen des Einsetzens von Fischarten, die einen angemessenen Fischbestand des Gewässers gefährden können,
+9. Maßnahmen, die eine Veränderung des Erbgutes von wildlebenden Fischen beinhalten oder bewirken können,
+10. die Art des Transports und der Hälterung von Fischen,
+11. den Schutz der Fischlaichplätze, des Fischlaichs, der Fischbrut und des Winterlagers der Fische,
+12. Art und Zeit der Entnahme von Wasserpflanzen oder deren Teile,
+13. den Schutz der Fischnährtiere,
+14. das Einlassen zahmen Wassergeflügels in Gewässer,
+15. Verbote der Fütterung wildlebender Fische,
+16. das Verhalten bei der Fischerei zur Vermeidung gegenseitiger Störungen der Fischer,
+17. die Kennzeichnung der in Gewässer ausliegenden Fischereifahrzeuge, Fanggeräte und Fischbehälter,
+18. den Schutz der Fischerei bei Ausbau, Regulierung und Unterhaltung der Gewässer,
+19. (aufgehoben)
+20. das Führen und Vorlegen einer Fangstatistik,
+21. die Durchführung gemeinschaftlicher Fischereiveranstaltungen,
+22. Beschränkungen oder Verbote des Einsetzens oder Inverkehrbringens von Fischen aus tierseuchenrechtlichen Gründen,
+23. die Registrierung von natürlichen und juristischen Personen und Personenvereinigungen, die den Aalfang gewerblich ausüben, und der hierfür eingesetzten Fischereifahrzeuge,
+24. die Registrierung der Einrichtungen, Stellen und Personen, die die Erstvermarktung von Aal durchführen,
+25. die Feststellung der Herkunft und die Rückverfolgbarkeit lebender Aale.
+§ 41  Hege
+(1) Die Hege hat zum Ziel, einen der Größe und Beschaffenheit des Gewässers entsprechenden artenreichen, gesunden, ausgeglichenen und naturnahen Fischbestand zu erhalten und aufzubauen. Die natürlichen Bedingungen für das Vorkommen der einzelnen Fischarten (Lebensräume) sollen erhalten und nach Möglichkeit wiederhergestellt und nicht beeinträchtigt werden. Keine Art der heimischen (§ 7 Abs. 2 Nr. 7 des Bundesnaturschutzgesetzes) Fische darf in ihrem Bestand gefährdet werden.
+(2) Der Einsatz nicht heimischer Fische bedarf der im Einvernehmen mit der obersten Wasserbehörde und der obersten Naturschutzbehörde erteilten Erlaubnis der obersten Fischereibehörde. Die Zuständigkeit kann auf einen nachgeordneten Bereich übertragen werden. Die Erlaubnis ersetzt erforderliche Genehmigungen nach dem Bundesnaturschutzgesetz und dem Naturschutzgesetz des Landes Sachsen-Anhalt.
+(3) Der Gewässereigentümer ist zur Duldung zumutbarer Hegemaßnahmen verpflichtet. Wird die Zustimmung nach § 15 versagt, geht die Pflicht für die innerhalb des befriedeten Bezirks (§ 15) vorzunehmenden Hegemaßnahmen auf den Nutzungsberechtigten über.
+(4) Die Hegepflicht kann auf Antrag des Verpflichteten durch die Fischereibehörde ausgesetzt werden, solange diesem ihre Erfüllung wegen der Beschaffenheit des Gewässers nicht zugemutet werden kann. Wird die Hegepflicht ausgesetzt, hat der Fischereiausübungsberechtigte die Vornahme von Hegemaßnahmen durch die Fischereibehörde oder den von ihr bestimmten Dritten zu dulden.
+§ 42  Hegeplan
+(1) Für einen Fischereibezirk hat der Fischereiausübungsberechtigte einen Hegeplan aufzustellen. In ihm sind Bestimmungen zu treffen über:
+1. Maßnahmen zur Ermittlung des Fischbestandes und seiner Nahrungsgrundlage sowie einer Bewertung des Gewässerzustandes aus fischereilicher Sicht,
+2. Maßnahmen zur Erhaltung, Wiederherstellung und nachhaltigen Verbesserung der Fischgewässer und des Fischbestandes sowie zur Durchführung des Fischbesatzes,
+3. das Ausmaß der Fischerei unter Berücksichtigung der nach Nummer 1 getroffenen Feststellungen,
+4. die Überwachung der Durchführung des Hegeplanes,
+5. die statistische Erfassung der Fänge,
+6. Maßnahmen nach unvorhersehbaren nachteiligen Einwirkungen auf den Fischbestand oder das Gewässer,
+7. gemeinschaftliches Hegefischen. Der Hegeplan erstreckt sich auf einen Zeitraum von mindestens einem Jahr und höchstens fünf Jahren.
+(2) Die Hegepläne sollen mit den Hegeplänen in den angrenzenden Fischereibezirken abgestimmt werden. Sie bedürfen der Genehmigung der oberen Fischereibehörde, im Falle wasserwirtschaftlicher Auswirkungen im Einvernehmen mit der oberen Wasserbehörde. Die Genehmigung ist zu versagen, wenn die in den Hegeplänen festgesetzten Maßnahmen nicht geeignet sind, den Fischbestand nachhaltig zu erhalten und eine ordnungsgemäße fischereiliche Nutzung zu sichern.
+(3) Wird nicht bis zum ersten Februar eines Jahres ein Hegeplan aufgestellt oder wird dieser aus Gründen, die von dem Fischereiausübungsberechtigten zu vertreten sind, nicht genehmigt, so kann die obere Fischereibehörde nach erfolgloser Fristsetzung von einem Monat den Hegeplan auf Kosten der Pflichtigen aufstellen.
+(4) Erfüllt ein Fischereiausübungsberechtigter seine Verpflichtungen aus den Hegeplänen trotz Fristsetzung nicht, kann die obere Fischereibehörde nach vorheriger Androhung die erforderlichen Maßnahmen im Wege der Ersatzvornahme durchführen.
+§ 43  Sicherung des Fischwechsels
+(1) In Gewässern dürfen keine Fischereivorrichtungen errichtet werden, die den Wechsel der Fische verhindern.
+(2) Ein Gewässer darf durch ständige Fischereivorrichtungen auf nicht mehr als die halbe Breite, bei Mittelwasserstand gemessen, für den Fischwechsel versperrt werden. Ständige Fischereivorrichtungen müssen voneinander so weit entfernt sein, daß sie den Fischwechsel nicht erheblich beeinträchtigen. Die wasserrechtlichen Vorschriften bleiben unberührt.
+(3) Ständige Fischereivorrichtungen sind feststehende Fischwehre, feststehende Fischzäune und feststehende Selbstfänge für Aal und für andere Fische, unabhängig davon, ob sie elektrisch betrieben werden oder das angebrachte Fanggerät entfernt werden kann.
+(4) Zum Zwecke des Aalfanges können Ausnahmen von Absatz 2 Satz 1 und 2 zugelassen werden.
+§ 44  Fischwege
+(1) Wer eine Stauanlage in einem Gewässer errichtet oder betreibt, hat durch geeignete Ausweichmöglichkeiten (Fischwege) den Fischwechsel zu gewährleisten. Das gleiche gilt bei anderen Anlagen, die den Wechsel der Fische dauernd verhindern oder erheblich beeinträchtigen.
+(2) Die für die wasserrechtliche Genehmigung der Anlage zuständige Behörde kann im Einvernehmen mit der oberen Fischereibehörde Ausnahmen von Absatz 1 zulassen, insbesondere wenn
+1. die Anlage nur einen vorübergehenden Zweck hat und ihre spätere Beseitigung gewährleistet ist oder
+2. die für die Anlegung und Unterhaltung des Fischweges entstehenden Kosten in keinem Verhältnis zu den Vorteilen für die Fischerei stehen oder sonstige Nachteile entstehen, die schwerwiegender sind als die durch die Errichtung des Fischweges für die Fischerei entstehenden Vorteile.
+(3) Ist durch die Anlage eine Verminderung des Fischbestandes zu erwarten, hat derjenige, der von der Verpflichtung zur Gewährleistung des Fischwechsels befreit worden ist, den Fischereiausübungsberechtigten die Kosten der Beschaffung von Fischbesatz in angemessenem Umfang zu erstatten.
+§ 45  Fischwege an bestehenden Anlagen
+Bei bestehenden Anlagen, die den Fischwechsel verhindern, kann die Errichtung von Fischwegen nachträglich von der oberen Fischereibehörde im Einvernehmen mit der oberen Wasserbehörde gefordert werden. Legt die Maßnahme dem Verpflichteten Lasten auf, die in keinem angemessenen Verhältnis zu seinem Nutzen und seiner Leistungsfähigkeit stehen, kann sie nur gefordert werden, wenn sich das Land oder ein sonstiger Kostenträger an der Aufbringung der Mitel angemessen beteiligt.
+§ 46  Fischerei in Fischwegen
+(1) In Fischwegen ist jede Art des Fischfangs verboten.
+(2) Während der Zeit, in der der Fischweg geöffnet sein muß, kann die obere Fischereibehörde den Fischfang auch auf Strecken oberhalb und unterhalb des Fischweges in einer den örtlichen Verhältnissen angemessenen Ausdehnung verbieten. § 47 Abs. 3 gilt entsprechend.
+(3) Die obere Fischereibehörde kann zu wissenschaftlichen und fischereiwirtschaftlichen Zwecken im Einzelfall Ausnahmen von Absatz 1 und 2 Satz 1 zulassen.
+§ 47  Schonbezirke und Schutzgebiete
+(1) Die obere Fischereibehörde wird ermächtigt, durch Verordnung Gewässer, Gewässerteile und Ufergrundstücke zu Schonbezirken zu erklären, die
+1. für die Erhaltung des Fischbestandes von besonderer Bedeutung sind (Fischschonbezirke),
+2. besonders geeignete Laich- und Abwachsplätze für Fische sind (Laichschonbezirke),
+3. als Winterlager für Fische besonders geeignet sind (Winterlager). Vor Erlaß der Verordnung ist der Entwurf in den Gemeinden, in denen die Schonbezirke liegen sollen, für die Dauer eines Monats öffentlich auszulegen. Dabei ist darauf hinzuweisen, daß Einwendungen binnen eines Monats nach Beendigung der Auslegung schriftlich oder zur Niederschrift bei der oberen Fischereibehörde erhoben werden können.
+(2) In der Verordnung können die Fischerei und die Entnahme von Fischnährtieren vollständig oder teilweise sowie Störungen, die die Fortpflanzung oder den Bestand der Fische gefährden, insbesondere die Räumung, das Mähen, die Entnahme und das Einbringen von Pflanzen, Schlamm, Erde, Sand, Kies und Steinen sowie die Ausübung des Wasser- und des Eissports beschränkt oder verboten werden.
+(3) Schonbezirke sind durch die Fischereibehörde durch Schilder zu kennzeichnen. Die Eigentümer und Besitzer des Gewässers und der Ufergrundstücke sind verpflichtet, die Kennzeichnung ohne Entschädigung zu dulden.
+(4) Die zuständige Naturschutzbehörde wird ermächtigt, durch Verordnung im Einvernehmen mit der jeweils gleichrangigen Fischereibehörde die Ausübung der Fischerei in naturschutzrechtlich geschützten Teilen von Natur und Landschaft im Sinne von § 20 Abs. 2 des Bundesnaturschutzgesetzes und § 15 Abs. 1 des Naturschutzgesetzes des Landes Sachsen-Anhalt einzuschränken, soweit der Schutzzweck unter Abwägung der fischereilichen Belange dies erfordert.
+Teil 9  Fischereibehörden, Fischereibeirat, Fischereiberater
+§ 48  Fischereibehörden
+(1) Oberste Fischereibehörde ist das für Fischerei zuständige Ministerium.
+(2) Obere Fischereibehörde ist das Landesverwaltungsamt.
+(3) Fischereibehörden im Sinne dieses Gesetzes sind die Landkreise und kreisfreien Städte als untere Fischereibehörden. Ihre Aufgaben gehören zum übertragenen Wirkungskreis. Kosten, die nicht durch Gebühren gedeckt werden, werden im Rahmen des allgemeinen Finanzausgleichs berücksichtigt.
+(4) Die unteren Fischereibehörden sind zuständig, wenn nichts anderes bestimmt ist. Die oberste Fischereibehörde und die obere Fischereibehörde üben die Fachaufsicht über die ihnen nachgeordneten Fischereibehörden aus. Eine Fachaufsichtsbehörde kann an Stelle einer nachgeordneten Behörde tätig werden, wenn diese eine Weisung nicht fristgemäß befolgt oder wenn Gefahr im Verzug ist.
+§ 49  Fischereibeirat
+(1) Zur Beratung in wichtigen fischereilichen Fragen wird ein Fischereibeirat bei der oberen Fischereibehörde gebildet. Der Fischereibeirat besteht aus Vertretern der Fischereiberechtigten, der Fischzüchter, der Teichwirte, der Berufsfischer, der Angler, der Land-, der Forst- und der Wasserwirtschaft, der Fischereiwissenschaft und anerkannten Naturschutzvereinigungen.
+(2) Der Fischereibeirat ist vor allen wesentlichen Entscheidungen von allgemeiner Bedeutung zu hören.
+(3) Die Mitglieder des Fischereibeirates üben ihre Tätigkeit ehrenamtlich aus.
+(4) Das für Fischerei zuständige Ministerium wird ermächtigt, durch Verordnung die Zusammensetzung und den Vorsitz des Fischereibeirates, die Zahl und die Berufung der Mitglieder sowie das Vorschlagsrecht der Interessengruppen zu regeln.
+§ 50  Fischereiberater
+(1) Der Fischereiberater ist als Berater der Fischereibehörde in wichtigen die Fischerei betreffenden Fragen zu hören. Er ist ehrenamtlich tätig.
+(2) Der Fischereiberater wird nach Anhörung der in ihrem Verwaltungsbereich ansässigen Fischereiorganisationen von der Fischereibehörde vorgeschlagen und von der oberen Fischereibehörde auf die Dauer von fünf Jahren berufen.
+Teil 10  Entschädigung
+§ 51  Art und Ausmaß einer Entschädigung
+Eine nach diesem Gesetz zu leistende Entschädigung hat den eintretenden Vermögensschaden angemessen auszugleichen. Für die Höhe der Entschädigung gelten die Vorschriften des Enteignungsgesetzes des Landes Sachsen-Anhalt. Die Entschädigung ist in Geld festzusetzen.
+§ 52  Entschädigungsverfahren
+Über Entschädigungsansprüche nach diesem Gesetz entscheidet die obere Fischereibehörde. Die Vorschriften des Enteignungsgesetzes des Landes Sachsen-Anhalt gelten entsprechend.
+Teil 11  Ordnungswidrigkeiten
+§ 53  Bußgeldvorschriften
+(1) Ordnungswidrig handelt, wer vorsätzlich oder fahrlässig
+1. entgegen § 15 die Fischerei ohne Zustimmung des Nutzungsberechtigten ausübt,
+2. über den in § 16 Abs. 1 Satz 2 ausgeschlossenen Flächen fischt,
+3. entgegen § 16 Abs. 3 Maßnahmen ergreift, die die Rückkehr der Fische in ein Gewässer oder die Fischerei auf den überfluteten Grundstücken erschweren oder verhindern,
+4. entgegen einem vollziehbaren Verbot nach § 17 Abs. 2 Uferflächen oder Anlagen betritt,
+5. auf Grund eines nach § 20 Abs. 4 nichtigen Fischereipachtvertrages oder entgegen § 21 Abs. 4 die Fischerei ausübt oder ausüben lässt,
+6. entgegen einer vollziehbaren Beschränkung nach § 26 Abs. 2 eine Fischereierlaubnis vergibt,
+7. entgegen § 26 Abs. 4 oder § 28 Abs. 3 die Fischerei ausübt, ohne die in diesen Vorschriften genannten Berechtigungsdokumente bei sich zu führen, oder diese auf Verlangen nicht vorzeigt,
+8. entgegen § 36 Abs. 1 Satz 1 als Fischereiberechtigter oder Fischereiausübungsberechtigter ein Fischsterben nicht unverzüglich der Fischereibehörde oder einer Polizeidienststelle anzeigt,
+9. entgegen § 37 Abs. 1 Satz 1 die Fischerei ausübt,
+10. entgegen § 37 Abs. 2 Fischgeräte oder sonstige Fangmittel mitführt,
+11. entgegen § 37 Abs. 3 seuchenkranke, seuchenverdächtige oder ansteckungsverdächtige Fische einsetzt,
+12. entgegen § 39 Abs. 1 seinen Mitteilungs- und Unterrichtungspflichten nicht genügt oder entgegen § 39 Abs. 3 Satz 1 einem Gewässer zuviel Wasser entzieht,
+13. entgegen § 41 Abs. 2 Satz 1 Fische einsetzt,
+14. entgegen § 46 Abs. 1 in Fischwegen oder entgegen einem vollziehbaren Verbot nach § 46 Abs. 2 Satz 1 auf Strecken oberhalb und unterhalb des Fischweges den Fischfang ausübt,
+15. einer Verordnung nach § 36 Abs. 2, den §§ 40, 47 Abs. 1 Satz 1 zuwiderhandelt, soweit sie für einen bestimmten Tatbestand auf diese Bußgeldvorschrift verweist,
+16. die Fischereiausübung absichtlich behindert.
+(2) Ordnungswidrig handelt, wer unter Verletzung fremden Fischereirechts die Fischerei auf Fische der fischereiwirtschaftlich nicht nutzbaren Arten sowie auf Fischnährtiere ausübt.
+(3) Die Ordnungswidrigkeit kann mit einer Geldbuße bis zu 5000 Euro geahndet werden.
+§ 54  Einziehung
+(1) Ist eine Ordnungswidrigkeit nach § 53 Abs. 1 Nrn. 9 bis 11, 13 bis 15 und Abs. 2 begangen worden, so können
+1. Gegenstände, auf die sich die Ordnungswidrigkeit bezieht, und
+2. Gegenstände, die zu ihrer Begehung oder Vorbereitung gebraucht worden oder bestimmt gewesen sind, eingezogen werden.
+(2) § 23 des Gesetzes über Ordnungswidrigkeiten ist anzuwenden.
+Teil 12  Übergangs- und Schlußbestimmungen
+§ 55  (aufgehoben)
+§ 56  Unbekannte Eigentümer
+Bis zum Nachweis des Eigentums an einem Gewässer steht das Fischereirecht dem Lande zu. Selbständige Fischereirechte bleiben unberührt.
+§ 57  Übergangsvorschriften
+(1) Fischereischeine, für deren Erteilung durch die Änderung des § 31 Abs. 3 Nr. 2 nach dem allgemeinen In-Kraft-Treten des Gesetzes zur Änderung des Fischereigesetzes die Voraussetzungen entfallen sind, dürfen aus diesem Grunde nicht widerrufen werden.
+(2) Jugendfischereischeine, die vor dem Tag des Inkrafttretens des Zweiten Gesetzes zur Änderung des Fischereigesetzes ausgestellt wurden, behalten ihre Gültigkeit für die ausgestellte Dauer.
+(3) Personen, die vor dem Tag des Inkrafttretens des Zweiten Gesetzes zur Änderung des Fischereigesetzes die zur Erlangung des Jugendfischereischeins vorgesehene Jugendfischerprüfung bestanden haben, sind von der Ablegung der Friedfischfischerprüfung befreit. Der Nachweis ist durch den Antragsteller zu führen.
+§ 58  (aufgehoben)
+§ 59  Inkrafttreten
+Dieses Gesetz tritt vorbehaltlich des Satzes 2 am Tage nach seiner Verkündung in Kraft. § 51 Satz 2 und § 52 Satz 2 treten mit Inkrafttreten des Enteignungsgesetzes des Landes Sachsen-Anhalt in Kraft.
diff --git a/src/test/resources/sampledata/SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf b/src/test/resources/sampledata/SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf
new file mode 100644
index 0000000..ab93c9c
--- /dev/null
+++ b/src/test/resources/sampledata/SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf
Binary files differ
diff --git a/src/test/resources/sampledata/SachsenAnhalt/SOURCES b/src/test/resources/sampledata/SachsenAnhalt/SOURCES
new file mode 100644
index 0000000..740d90b
--- /dev/null
+++ b/src/test/resources/sampledata/SachsenAnhalt/SOURCES
@@ -0,0 +1,58 @@
+Änderungsdokument:
+- Entwurf eines Zweiten Gesetzes zur Änderung des Fischereigesetzes,
+  Gesetzentwurf der Fraktionen CDU, SPD und FDP vom 11. Dezember 2025,
+  Landtag von Sachsen-Anhalt, 8. Wahlperiode, Drucksache 8/6357
+  (Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf)
+- Der Entwurf ist am 21. März 2026 als Gesetz verkündet worden
+  (GVBl. LSA S. 103, 104) und hat, wie die Änderungshistorie des
+  Landesrechtsportals ausweist, die Inhaltsübersicht und die §§ 29, 30,
+  31 und 57 geändert — also genau die Einheiten, die der Entwurf nennt.
+
+Bezugsweg des Änderungsdokuments:
+- Das Gesetz- und Verordnungsblatt für das Land Sachsen-Anhalt ist
+  nicht frei: landesrecht-sachsen-anhalt.info gibt unter
+  /down/aletztg.pdf nur die Inhaltsverzeichnisse der letzten
+  vierunddreißig Hefte aus (der Wirt verlangt eine Browserkennung,
+  sonst antwortet er mit 403); der Volltext ist Gegenstand eines
+  Abonnements.
+- Frei und skriptlesbar ist dagegen die Parlamentsdokumentation des
+  Landtags: padoka.landtag.sachsen-anhalt.de. Die Drucksachen liegen
+  unter /files/drs/wp<Wahlperiode>/drs/d<Nummer><Kürzel>.pdf; gefunden
+  werden sie über die Suchmaske /portal/browse.tt.html, die ihre
+  Ergebnisse erst nach einigen Sekunden nachlädt.
+
+Stammfassung (FischG-LSA-neu.txt):
+- Fischereigesetz (FischG) vom 31. August 1993 (GVBl. LSA S. 464),
+  Gesamtausgabe vom 29. August 2026, 59 Normen.
+- Bezugsweg: landesrecht.sachsen-anhalt.de (juris-Kennung bsst),
+  Dokumentkennung jlr-NNLST0000412A. Wie das saarländische Portal ist
+  es eine Einseitenanwendung ohne Fassungsliste; die Adressform
+  …@JJJJMMTT wird abgewiesen. Eine Vorfassung ist nicht zu beschaffen.
+
+Grenze dieses Falles:
+- Die beigelegte Stammfassung ist die NACHfassung: Sie trägt die
+  Änderung vom 21. März 2026 bereits. Aussagekräftig ist deshalb allein
+  die Zahl der erschlossenen Befehle; dass die meisten ihr Ziel nicht
+  mehr finden, ist die Folge des falschen Standes und kein Mangel des
+  Erzeugnisses (§ 13 Absatz 4 des Handbuchs, wie bei Rheinland-Pfalz).
+- Zwei Befehlsformen bleiben aus einem anderen Grund liegen: Nummer 3
+  des Entwurfs lautet „In § 31 Abs. 2 wie folgt geändert:“ — das Verb
+  fehlt. Damit ist der Rahmen nicht lesbar, und die drei Buchstaben
+  darunter nennen keinen Paragraphen mehr. Ebenso bleibt die
+  auslassende Anfügung („Als Abs. 2 neu angefügt: „…““) unerkannt.
+  Geraten wird nicht.
+
+Aufbereitung zum kanonischen Klartext:
+1. Volltext der Gesamtausgabe aus dem Browser (div.docLayoutText), in
+   zwei Stücken entnommen, weil der Auszug bei 50 000 Zeichen abbricht.
+2. Portalzutaten entfernt („zur Einzelansicht …“, nichtamtliches
+   Inhaltsverzeichnis, Fußnotenblöcke, Fußnotenzeichen).
+3. Normkopf und Titel auf eine Zeile mit doppeltem Leerzeichen, ebenso
+   die Teil-Überschriften; Aufzählungsmarke und Text auf eine Zeile.
+4. Kopfzeilen: Langtitel, Kurzbezeichnung, Ausfertigungsdatum,
+   Fundstelle.
+
+Rechtsstellung:
+- Amtliche Werke im Sinne des § 5 UrhG (Gesetzestext und Drucksache);
+  wiedergegeben wird ein einzelnes Werk zu Prüfzwecken, kein
+  Massenabzug. Die Quellenangabe folgt § 63 UrhG.
diff --git a/src/test/resources/sampledata/korpus-grundlinie.tsv b/src/test/resources/sampledata/korpus-grundlinie.tsv
index b5b360c..715593a 100644
--- a/src/test/resources/sampledata/korpus-grundlinie.tsv
+++ b/src/test/resources/sampledata/korpus-grundlinie.tsv
@@ -1,4 +1,4 @@
-# Grundlinie des Korpuslaufs (§ 6d des Handbuchs), Stand 28. August 2026 (zweite Fassung des Tages).
+# Grundlinie des Korpuslaufs (§ 6d des Handbuchs), Stand 29. August 2026.
 #
 # Jede Zeile hält fest, was ein Auftrag der Liste „korpus.tsv“ zu diesem Zeitpunkt hergegeben hat.
 # Der Lauf wird dagegen gehalten (KorpusberichtTest, „--grundlinie“): Gerügt wird allein, was
@@ -35,6 +35,9 @@
 HH-GutachterausschussVO	21	17	4	0	10	14	0	0	4	Befehl nicht erkannt:2; Stelle nicht auffindbar:1; Zieltext nicht vorhanden:1
 HB-BerufsfachschulVO	41	37	4	0	26	29	1	0	2	Befehl nicht erkannt:3; Fundstelle mehrdeutig:1
 MV-APOAmtsTA	24	22	2	0	-	-	-	-	-	Befehl nicht erkannt:2
+SL-SPaktG	1	1	0	0	19	20	0	0	1	-
+SL-AusfSPaktGVO	1	1	0	0	10	10	0	0	0	-
+ST-FischG	14	4	10	0	-	-	-	-	-	Befehl nicht erkannt:5; Stelle nicht auffindbar:3; Zieltext nicht vorhanden:2
 RP-UKAPOGS	23	9	14	0	-	-	-	-	-	Stelle nicht auffindbar:2; Zieltext nicht vorhanden:10; Bestand widerspricht dem Befehl:2
 GEG-GModG-RegE	97	87	10	0	-	-	-	-	-	Befehl nicht erkannt:6; Stelle nicht auffindbar:2; Zieltext nicht vorhanden:2
 GEG-Beschlussempfehlung	119	70	49	0	-	-	-	-	-	Befehl nicht erkannt:1; Stelle nicht auffindbar:3; Zieltext nicht vorhanden:40; Fundstelle mehrdeutig:1; Bestand widerspricht dem Befehl:4
diff --git a/src/test/resources/sampledata/korpus.tsv b/src/test/resources/sampledata/korpus.tsv
index 2832539..8a44af7 100644
--- a/src/test/resources/sampledata/korpus.tsv
+++ b/src/test/resources/sampledata/korpus.tsv
@@ -32,6 +32,15 @@
 HH-GutachterausschussVO	Hamburg/GAusschV-HH-alt.txt	Hamburg/HmbGVBl-2026-17_GutachterausschussVO-AendVO.pdf	-	Hamburg/GAusschV-HH-neu.txt	-
 HB-BerufsfachschulVO	Bremen/AssBerFSchulV-BR-alt.txt	Bremen/BremGBl-2026-87_BerufsfachschulVO-AendVO.pdf	-	Bremen/AssBerFSchulV-BR-neu.txt	-
 MV-APOAmtsTA	MecklenburgVorpommern/APOAmtsTA-MV-alt.txt	MecklenburgVorpommern/GVOBl-MV-2026-21_Besoldungsanpassung-ua.pdf	44	-	-
+# Das Saarland führt gleichfalls keine Fassungsliste; die Vorfassungen sind der
+# Änderungshistorie entnommen und aus den Gesetzblättern von 2019, 2020 und 2024 gegengeprüft
+# (Saarland/SOURCES). Ein Heft, zwei Stammwerke: Artikel 1 das Gesetz, Artikel 2 die Verordnung.
+SL-SPaktG	Saarland/SPaktG-alt.txt	Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf	1	Saarland/SPaktG-neu.txt	-
+SL-AusfSPaktGVO	Saarland/AusfSPaktGVO-alt.txt	Saarland/ABl-2026-31_Saarlandpakt-AendG.pdf	2	Saarland/AusfSPaktGVO-neu.txt	-
+# Sachsen-Anhalt wie Rheinland-Pfalz: keine Vorfassung, der Stamm ist die Nachfassung, und
+# aussagekräftig ist allein die Zahl der erschlossenen Befehle (14). Überdies ist das GVBl. LSA
+# nicht frei; das Änderungsdokument ist deshalb die Drucksache des Landtags.
+ST-FischG	SachsenAnhalt/FischG-LSA-neu.txt	SachsenAnhalt/Ltg-Drs-8-6357_Fischereigesetz-AendG-Entwurf.pdf	-	-	-
 # Rheinland-Pfalz führt keine Vorfassungen; angewandt wird deshalb auf die Nachfassung, und
 # aussagekräftig ist allein die Zahl der erschlossenen Befehle (23). Die liegengebliebenen sind
 # die Folge des falschen Standes, nicht eines Mangels — siehe § 13 Absatz 4 des Handbuchs.
