diff --git a/src/main/java/eu/mulk/aendggner/AendGgner.java b/src/main/java/eu/mulk/aendggner/AendGgner.java
index f7e6bf7..e647b75 100644
--- a/src/main/java/eu/mulk/aendggner/AendGgner.java
+++ b/src/main/java/eu/mulk/aendggner/AendGgner.java
@@ -2,8 +2,11 @@
 
 import eu.mulk.aendggner.aenderung.parse.AenderungsgesetzParser;
 import eu.mulk.aendggner.aenderung.parse.PatchTextExtraktor;
+import eu.mulk.aendggner.aenderung.parse.SuperskriptModus;
 import eu.mulk.aendggner.aenderung.parse.TextBereiniger;
 import eu.mulk.aendggner.anwendung.BefehlAnwender;
+import eu.mulk.aendggner.gesetz.Gesetz;
+import eu.mulk.aendggner.gesetz.bayern.BayRechtLoader;
 import eu.mulk.aendggner.gesetz.gii.GiiXmlLoader;
 import eu.mulk.aendggner.synopse.HtmlRenderer;
 import eu.mulk.aendggner.synopse.SynopseBuilder;
@@ -30,7 +33,11 @@
 
   private static final Logger log = Logger.getLogger(AendGgner.class);
 
-  @Parameters(index = "0", description = "The base law (gii-norm XML from gesetze-im-internet.de).")
+  @Parameters(
+      index = "0",
+      description =
+          "The base law: gii-norm XML from gesetze-im-internet.de, or — for Bavarian state law —"
+              + " the consolidated version from gesetze-bayern.de (PDF or canonical plain text).")
   private Path baseFile;
 
   @Parameters(
@@ -103,7 +110,7 @@
     log.debugf("Logging configured.");
 
     if (dumpGesetz) {
-      var gesetz = new GiiXmlLoader().load(baseFile);
+      var gesetz = ladeStammgesetz();
       System.out.printf(
           "%s — %s (%d Normen)%n", gesetz.jurabk(), gesetz.langue(), gesetz.normen().size());
       for (var norm : gesetz.normen()) {
@@ -118,7 +125,7 @@
     }
 
     if (extractOnly) {
-      var extraktor = new PatchTextExtraktor();
+      var extraktor = new PatchTextExtraktor(superskriptModus());
       for (var file : patches) {
         var text = extraktor.extrahiere(file);
         System.out.println(raw ? text : TextBereiniger.bereinige(text));
@@ -127,8 +134,8 @@
     }
 
     if (dumpBefehle) {
-      var gesetz = new GiiXmlLoader().load(baseFile);
-      var extraktor = new PatchTextExtraktor();
+      var gesetz = ladeStammgesetz();
+      var extraktor = new PatchTextExtraktor(superskriptModus());
       var parser = new AenderungsgesetzParser();
       for (var file : patches) {
         var text = TextBereiniger.bereinige(extraktor.extrahiere(file));
@@ -169,8 +176,8 @@
     }
 
     // Pipeline: Stammgesetz laden → Befehle parsen → anwenden → Synopse rendern.
-    var altesGesetz = new GiiXmlLoader().load(baseFile);
-    var extraktor = new PatchTextExtraktor();
+    var altesGesetz = ladeStammgesetz();
+    var extraktor = new PatchTextExtraktor(superskriptModus());
     var parser = new AenderungsgesetzParser();
 
     var gesetz = altesGesetz;
@@ -215,6 +222,23 @@
     return gesamtErgebnis.anzahlAngewandt() == 0 && !protokoll.isEmpty() ? 2 : 0;
   }
 
+  /** Gii-XML → {@link GiiXmlLoader}; PDF/Klartext (bayerisches Landesrecht) → {@link
+   * BayRechtLoader}. */
+  private Gesetz ladeStammgesetz() throws Exception {
+    return istGiiXml() ? new GiiXmlLoader().load(baseFile) : new BayRechtLoader().load(baseFile);
+  }
+
+  /** Bayerische Stammtexte tragen amtliche Satznummern — auch die Änderungsgesetze werden dann
+   * mit Superskript-Erhalt extrahiert, damit Zitate und Stammtext dieselbe Schreibweise tragen. */
+  private SuperskriptModus superskriptModus() throws IOException {
+    return istGiiXml() ? SuperskriptModus.ENTFERNEN : SuperskriptModus.BEHALTEN;
+  }
+
+  private boolean istGiiXml() throws IOException {
+    var mimeType = new org.apache.tika.Tika().detect(baseFile);
+    return mimeType.equals("application/xml") || mimeType.equals("text/xml");
+  }
+
   private static String kuerze(String text) {
     var einzeilig = text.replaceAll("\\s+", " ");
     return einzeilig.length() <= 160 ? einzeilig : einzeilig.substring(0, 157) + "…";
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/Aenderungsbefehl.java b/src/main/java/eu/mulk/aendggner/aenderung/Aenderungsbefehl.java
index d35fc5b..897f02c 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/Aenderungsbefehl.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/Aenderungsbefehl.java
@@ -107,6 +107,41 @@
       implements Aenderungsbefehl {}
 
   /**
+   * „Der Wortlaut wird Satz 1.“ (bayerisches Landesrecht) — der bisher unnummerierte Text erhält
+   * die amtliche Satznummer als Superskript (Vorbereitung für das Anfügen weiterer Sätze).
+   */
+  record WortlautZuSatz(Stelle stelle, String nummer, Provenienz provenienz)
+      implements Aenderungsbefehl {}
+
+  /**
+   * „Dem Wortlaut werden die folgenden Abs. 1 bis 4 vorangestellt: „…““ (bayerisches Landesrecht) —
+   * neue Absätze treten vor den bisherigen Normtext.
+   */
+  record WortlautVoranstellung(Stelle stelle, String text, Provenienz provenienz)
+      implements Aenderungsbefehl {}
+
+  /**
+   * „Fußnote 1 wird aufgehoben.“ / „Die Fußnoten 9 und 10 werden aufgehoben.“ (bayerisches
+   * Landesrecht) — entfernt die Fußnotenzeile(n) „ⁿ) [Amtl. Anm.:] …“ samt der Inline-Marker „ⁿ)“
+   * aus der Kontextnorm.
+   */
+  record FussnotenAufhebung(Stelle stelle, java.util.List<String> nummern, Provenienz provenienz)
+      implements Aenderungsbefehl {
+
+    public FussnotenAufhebung {
+      nummern = java.util.List.copyOf(nummern);
+    }
+  }
+
+  /**
+   * „In Satz 1 wird die Satznummerierung „1“ gestrichen.“ (bayerisches Landesrecht) — entfernt die
+   * amtliche Superskript-Satznummer am Anfang des bezeichneten Bereichs (etwa nachdem der zweite
+   * und letzte Satz eines Absatzes aufgehoben wurde).
+   */
+  record SatznummerierungStreichung(Stelle stelle, String nummer, Provenienz provenienz)
+      implements Aenderungsbefehl {}
+
+  /**
    * „Nach § 33 werden die folgenden Überschriften zu Teil 3 und zu Teil 3 Abschnitt 1 eingefügt:
    * „…““ bzw. „Die bisherigen Überschriften zu Teil 4 und Teil 4 Abschnitt 1 werden durch die
    * folgende Überschrift zu Abschnitt 2 ersetzt: „…““ — neue Gliederungs-Überschriften im
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java b/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java
index ababf63..1c63a5f 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/Stelle.java
@@ -20,6 +20,7 @@
       permits Paragraph,
           AbsatzNr,
           SatzNr,
+          HalbsatzNr,
           NummerNr,
           BuchstabeNr,
           Ueberschrift,
@@ -27,8 +28,20 @@
           Gliederungseinheit,
           Absatzbezeichnung {}
 
-  /** „§ 5“, „§ 28a“ — die Paragraphennummer ohne „§ “. */
-  public record Paragraph(String nummer) implements Komponente {}
+  /**
+   * „§ 5“, „§ 28a“, im bayerischen Landesrecht „Art. 5“ — die Normnummer ohne Sigel, dazu das
+   * Sigel selbst („§“ oder „Art.“).
+   */
+  public record Paragraph(String nummer, String sigel) implements Komponente {
+    public Paragraph(String nummer) {
+      this(nummer, "§");
+    }
+
+    /** Die Einzelnormbezeichnung, wie sie im {@code Gesetz}-Modell steht: „§ 5“, „Art. 5“. */
+    public String enbez() {
+      return sigel + " " + nummer;
+    }
+  }
 
   /** Eine Gliederungseinheit oberhalb des Paragraphen: „Teil 2“, „Abschnitt 3“, „Anlage 8“. */
   public record Gliederungseinheit(String art, String nummer) implements Komponente {
@@ -46,6 +59,9 @@
   /** „Satz 1“ */
   public record SatzNr(String nummer) implements Komponente {}
 
+  /** „Halbsatz 1“ — die Hälfte eines am Semikolon geteilten Satzes (bayerische Zitierweise). */
+  public record HalbsatzNr(String nummer) implements Komponente {}
+
   /** „Nummer 4“ */
   public record NummerNr(String nummer) implements Komponente {}
 
@@ -148,9 +164,10 @@
       }
       sb.append(
           switch (komponente) {
-            case Paragraph p -> "§ " + p.nummer();
+            case Paragraph p -> p.enbez();
             case AbsatzNr a -> "Absatz " + a.nummer();
             case SatzNr s -> "Satz " + s.nummer();
+            case HalbsatzNr h -> "Halbsatz " + h.nummer();
             case NummerNr n -> "Nummer " + n.nummer();
             case BuchstabeNr b -> "Buchstabe " + b.kennung();
             case Ueberschrift u -> "Überschrift";
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParser.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParser.java
index 1b79794..976cd5e 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParser.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParser.java
@@ -24,6 +24,13 @@
 
   private static final Pattern ARTIKEL_UEBERSCHRIFT = Pattern.compile("^Artikel\\s+(\\d+[a-z]?)$");
 
+  // Bayerische Änderungsgesetze gliedern sich in Paragraphen statt Artikel („§ 1“ als
+  // freistehende Überschriftzeile). Die §-Teilung greift nur, wenn das Dokument keinerlei
+  // Artikel-Überschriften enthält — Bundesgesetze mit unzitiert abgedruckten Ablösegesetzen
+  // (ProdHaftG) enthalten freistehende „§ N“-Zeilen innerhalb ihrer Artikel.
+  private static final Pattern PARAGRAPH_UEBERSCHRIFT_AUSSEN =
+      Pattern.compile("^§\\s*(\\d+[a-z]?)$");
+
   public record ParseErgebnis(
       List<Aenderungsbefehl> befehle, List<String> artikel, List<String> warnungen) {}
 
@@ -35,20 +42,35 @@
    */
   public ParseErgebnis parse(String text, Gesetz ziel, @Nullable String artikelFilter) {
     var zitate = ZitatExtraktor.extrahiere(text);
-    var artikelBloecke = teileInArtikel(zitate.text());
+    var artikelBloecke = teileInArtikel(zitate.text(), ARTIKEL_UEBERSCHRIFT);
+    boolean paragraphenModus = false;
+    if (artikelBloecke.isEmpty()) {
+      artikelBloecke = teileInArtikel(zitate.text(), PARAGRAPH_UEBERSCHRIFT_AUSSEN);
+      paragraphenModus = !artikelBloecke.isEmpty();
+    }
 
     var befehle = new ArrayList<Aenderungsbefehl>();
     var betroffeneArtikel = new ArrayList<String>();
+    var warnungen = new ArrayList<>(zitate.warnungen());
 
     for (var artikel : artikelBloecke) {
       var relevant =
           artikelFilter != null
               ? artikel.label.equals(artikelFilter)
+                  && (!paragraphenModus || hatAenderungsformel(artikel))
               : betrifft(artikel, ziel, zitate);
       if (!relevant) {
         continue;
       }
       log.infof("Artikel %s betrifft %s.", artikel.label, ziel.jurabk());
+      if (paragraphenModus && artikelFilter != null && betroffeneArtikel.contains(artikel.label)) {
+        // Ein GVBl-Heft enthält mehrere Gesetze mit je eigener §-Zählung.
+        warnungen.add(
+            "Mehrere Änderungsgesetze im Dokument tragen einen § "
+                + artikel.label
+                + "; --artikel ist hier mehrdeutig — besser ohne Filter arbeiten (Auswahl über den"
+                + " Namen des Stammgesetzes).");
+      }
       betroffeneArtikel.add(artikel.label);
 
       var scan = GliederungsScanner.scanne(artikel.zeilen);
@@ -59,12 +81,76 @@
         befehle.add(vorspannBefehl(scan.vorspann(), artikel.label, zitate));
         continue;
       }
+      // Der Vorspann kann nach der gesetzesweiten Änderungsformel einen Rahmenbefehl tragen, der
+      // den Kontext aller Punkte setzt: „… wird wie folgt geändert: Art. 28 Abs. 1 wird wie folgt
+      // geändert:“ (GVBl) bzw. mit eingebettetem Ziel „Art. 7 Abs. 2 des X-Gesetzes … wird wie
+      // folgt geändert:“ (dann trägt die Formel das Ziel selbst).
+      var kontext = vorspannKontext(scan.vorspann(), artikel.label, zitate, befehle);
       for (var punkt : scan.punkte()) {
-        verarbeitePunkt(punkt, Stelle.LEER, artikel.label, "", zitate, befehle);
+        verarbeitePunkt(punkt, kontext, artikel.label, "", zitate, befehle);
       }
     }
 
-    return new ParseErgebnis(befehle, betroffeneArtikel, zitate.warnungen());
+    return new ParseErgebnis(befehle, betroffeneArtikel, warnungen);
+  }
+
+  private static final String AENDERUNGSFORMEL = "wird wie folgt geändert:";
+
+  private static boolean hatAenderungsformel(ArtikelBlock artikel) {
+    var scan = GliederungsScanner.scanne(artikel.zeilen);
+    return scan.vorspann().replaceAll("\\s+", " ").contains("wird wie folgt geändert");
+  }
+
+  // Eingebettetes Rahmenziel in der Änderungsformel selbst: „Art. 7 Abs. 2 des Bayerischen
+  // Umweltinformationsgesetzes … wird wie folgt geändert:“. Der Lookbehind auf „durch “ schließt
+  // die Zitierkette der Änderungshistorie aus („das zuletzt durch § 5 des Gesetzes vom … geändert
+  // worden ist“) — dort ist die Norm nie das Subjekt der Formel.
+  private static final Pattern EINGEBETTETES_ZIEL =
+      Pattern.compile(
+          "(?<!durch )\\b((?:§|Art\\.)\\s*\\d+[a-z]?"
+              + "(?:\\s+(?:Absatz|Abs\\.|Satz|Nummer|Nr\\.|Buchstabe|Buchst\\.)\\s+\\d+[a-z]?)*)"
+              + "\\s+(?:des|der)\\s+\\p{Lu}");
+
+  /**
+   * Bestimmt aus dem Vorspann eines Artikels mit Gliederungspunkten den gemeinsamen Kontext der
+   * Punkte. Ohne erkennbaren Rahmen bleibt der Kontext leer (die Punkte müssen ihre Ziele dann
+   * selbst vollständig nennen; Unerkanntes landet als „nicht erkannt“ im Protokoll — niemals
+   * stillschweigend).
+   */
+  private static Stelle vorspannKontext(
+      String vorspann,
+      String artikelLabel,
+      ZitatExtraktor.Ergebnis zitate,
+      List<Aenderungsbefehl> befehle) {
+    var normalisiert = vorspann.replaceAll("\\s+", " ").strip();
+    // Die erste Formel ist die gesetzesweite Einleitung; ein dahinter stehender Rahmenbefehl
+    // trägt ggf. seine eigene Formel („… wird wie folgt geändert: Art. 28 Abs. 1 wird wie folgt
+    // geändert:“).
+    int formel = normalisiert.indexOf(AENDERUNGSFORMEL);
+    if (formel < 0) {
+      return Stelle.LEER;
+    }
+    var rest = normalisiert.substring(formel + AENDERUNGSFORMEL.length()).strip();
+    if (!rest.isEmpty()) {
+      // Rahmenbefehl hinter der gesetzesweiten Formel („Art. 28 Abs. 1 wird wie folgt geändert:“,
+      // auch als Umnummerierungs-Verbund).
+      var provenienz = new Provenienz(artikelLabel, "", zitate.stelleZitateWiederHer(rest));
+      var rahmen = BefehlErkenner.rahmenMitBefehl(rest, Stelle.LEER, provenienz);
+      if (rahmen.isPresent()) {
+        if (rahmen.get().begleitbefehl() != null) {
+          befehle.add(rahmen.get().begleitbefehl());
+        }
+        return rahmen.get().stelle();
+      }
+      return Stelle.LEER;
+    }
+    // Die Formel endet den Vorspann: Trägt sie ihr Ziel eingebettet („Art. 7 Abs. 2 des
+    // X-Gesetzes … wird wie folgt geändert:“), wird dieses zum Kontext.
+    var eingebettet = EINGEBETTETES_ZIEL.matcher(normalisiert.substring(0, formel));
+    if (eingebettet.find()) {
+      return StellenParser.parse(eingebettet.group(1)).orElse(Stelle.LEER);
+    }
+    return Stelle.LEER;
   }
 
   /** Versucht, den Vorspann-Rest nach der Änderungsformel als einzelnen Befehl zu erkennen. */
@@ -133,7 +219,7 @@
 
   private record ArtikelBlock(String label, List<String> zeilen) {}
 
-  private static List<ArtikelBlock> teileInArtikel(String platzhalterText) {
+  private static List<ArtikelBlock> teileInArtikel(String platzhalterText, Pattern ueberschrift) {
     var bloecke = new ArrayList<ArtikelBlock>();
     String aktuellesLabel = null;
     var aktuelleZeilen = new ArrayList<String>();
@@ -141,10 +227,10 @@
     for (var zeile : platzhalterText.split("\n", -1)) {
       // Gesetzentwürfe (RefE/RegE/Drucksachen): Nach dem Gesetzestext folgt der Begründungsteil
       // — Freitext, der keine Befehle enthält und den letzten Artikel nicht verunreinigen darf.
-      if (aktuellesLabel != null && zeile.strip().equals("Begründung")) {
+      if (aktuellesLabel != null && zeile.strip().matches("Begründung:?")) {
         break;
       }
-      var matcher = ARTIKEL_UEBERSCHRIFT.matcher(zeile.strip());
+      var matcher = ueberschrift.matcher(zeile.strip());
       if (matcher.matches()) {
         if (aktuellesLabel != null) {
           bloecke.add(new ArtikelBlock(aktuellesLabel, List.copyOf(aktuelleZeilen)));
@@ -174,6 +260,11 @@
     if (!vorspann.contains("wird wie folgt geändert")) {
       return false;
     }
+    // Ausführungs-/Durchführungstitel nennen das Stammgesetz nur als Genitiv-Attribut („Die
+    // Verordnung zur Ausführung des Bayerischen Jagdgesetzes (AVBayJG) … wird wie folgt
+    // geändert“) — solche Nennungen zählen nicht als Treffer.
+    vorspann =
+        vorspann.replaceAll("\\b(?:zur Ausführung|zur Durchführung|zum Vollzug) des [^,()]*", "");
     var vorspannStamm = stammForm(vorspann);
     return (ziel.kurzue() != null && vorspannStamm.contains(stammForm(ziel.kurzue())))
         || (ziel.langue() != null && vorspannStamm.contains(stammForm(ziel.langue())))
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java
index 9cb4701..edbe742 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/BefehlErkenner.java
@@ -5,7 +5,9 @@
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Aufhebung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Ebene;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Ersetzung;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.FussnotenAufhebung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.GliederungsUeberschriften;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.SatznummerierungStreichung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Neufassung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Sammelbefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Streichung;
@@ -14,7 +16,9 @@
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Umnummerierung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WoerterEinfuegung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortAnker;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautVoranstellung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuAbsatz;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuSatz;
 import eu.mulk.aendggner.aenderung.Provenienz;
 import eu.mulk.aendggner.aenderung.Stelle;
 import java.util.ArrayList;
@@ -65,7 +69,7 @@
   // „…““ — neue Gliederungs-Überschriften hinter einem Anker-§.
   private static final Pattern GLIEDERUNG_UEBERSCHRIFT_EINFUEGUNG =
       Pattern.compile(
-          "^Nach (§ \\S+) (?:wird|werden) (?:die |der |das )?folgenden? Überschrift(?:en)? "
+          "^Nach ((?:§|Art\\.) \\S+) (?:wird|werden) (?:die |der |das )?folgenden? Überschrift(?:en)? "
               + "zu (.+?) (?:ein|an)gefügt: "
               + Z
               + "\\.?$");
@@ -243,6 +247,19 @@
 
   private static final Pattern AUFHEBUNG = Pattern.compile("^(.+?) (?:wird|werden) aufgehoben\\.$");
 
+  // „Fußnote 1 wird aufgehoben.“ / „Die Fußnoten 9 und 10 werden aufgehoben.“ (bayerisches
+  // Landesrecht; Fußnoten stehen dort als „ⁿ) [Amtl. Anm.:] …“-Zeilen im Normtext).
+  private static final Pattern FUSSNOTE_AUFHEBUNG =
+      Pattern.compile(
+          "^(?:Die )?Fußnoten? (\\d+(?:(?:, | und )\\d+)*) (?:wird|werden) aufgehoben\\.$");
+  private static final Pattern FUSSNOTEN_TRENNER = Pattern.compile(", | und ");
+
+  // „In Satz 1 wird die Satznummerierung „1“ gestrichen.“ (bayerisches Landesrecht) — etwa
+  // nachdem der zweite und letzte Satz eines Absatzes aufgehoben wurde.
+  private static final Pattern SATZNUMMERIERUNG_STREICHUNG =
+      Pattern.compile(
+          "^(?:In )?(.+?) (?:wird|werden) die Satznummerierung " + Z + " gestrichen\\.$");
+
   // „Die Überschrift von Teil 3 Abschnitt 2 wird gestrichen.“ — Streichung einer Gliederungs-
   // Überschrift (die Wörter-Streichung STREICHUNG erfordert dagegen ein Zitat).
   private static final Pattern UEBERSCHRIFT_STREICHUNG =
@@ -274,6 +291,23 @@
       Pattern.compile(
           "^(?:In )?(.+?) (?:wird|werden) (?:jeweils )?" + WOERTER + " " + Z + " gestrichen\\.$");
 
+  // „Die Angabe „X“ wird gestrichen.“ — ohne Stellenangabe (Kontext liefert das Ziel); tritt vor
+  // allem als rechte Klausel eines Verbunds auf („… ersetzt und die Angabe „X“ wird gestrichen“).
+  private static final Pattern STREICHUNG_OHNE_STELLE =
+      Pattern.compile(
+          "^(?:Die Wörter|Das Wort|Die Angabe|Die Zahl) " + Z + " (?:wird|werden) "
+              + "(?:jeweils )?gestrichen\\.$");
+
+  // „In Nr. 2 werden die Angabe „X“ und die Angabe „Y“ gestrichen.“ — mehrere Streichobjekte
+  // unter einem gemeinsamen „gestrichen“.
+  private static final Pattern STREICHUNG_MEHRFACH =
+      Pattern.compile(
+          "^(?:In )?(.+?) (?:wird|werden) (?:jeweils )?("
+              + WOERTER
+              + " «\\d+»(?:(?:, | und | sowie )"
+              + WOERTER
+              + " «\\d+»)+) gestrichen\\.$");
+
   // „§ 9 wird gestrichen.“, „Absatz 3 wird gestrichen.“, „Die §§ 34 bis 39 werden gestrichen.“,
   // „Der bisherige Teil 3 wird gestrichen.“ — Streichung ganzer Struktureinheiten (semantisch eine
   // Aufhebung). Greift erst, wenn die Wörter-Streichung STREICHUNG (die ein Zitat verlangt) und die
@@ -284,30 +318,36 @@
   private static final Pattern UMNUMMERIERUNG =
       Pattern.compile(
           "^(?:Der bisherige |Die bisherige |Das bisherige )?(.+?) wird (?:zu )?"
-              + "(§|Absatz|Satz|Nummer|Buchstabe|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage) "
+              + "(§|Art\\.|Absatz|Abs\\.|Satz|Nummer|Nr\\.|Buchstabe|Buchst\\."
+              + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage) "
               + "(\\d+[a-z]?)\\.$");
 
   // „Die bisherigen Absätze 2 bis 4 werden zu den Absätzen 3 bis 5.“ bzw. „Die bisherigen Nummern 4
   // bis 6 werden die Nummern 8 bis 10.“ — Bereichs-Umnummerierung, in Einzelbefehle aufgelöst.
   private static final Pattern UMNUMMERIERUNG_BEREICH =
       Pattern.compile(
-          "^Die (?:bisherigen )?(?:Absätze|Sätze|Nummern|Buchstaben) (\\d+) bis (\\d+) "
-              + "werden (?:zu den |die )?(Absätzen|Sätzen|Nummern|Buchstaben|Absätze|Sätze) "
+          "^Die (?:bisherigen )?(?:Absätze|Abs\\.|Sätze|Nummern|Nrn?\\.|Buchstaben|Buchst\\.) "
+              + "(\\d+) bis (\\d+) "
+              + "werden (?:zu den |die )?(Absätzen|Sätzen|Nummern|Buchstaben|Absätze|Sätze"
+              + "|Abs\\.|Nrn?\\.|Buchst\\.) "
               + "(\\d+) bis (\\d+)\\.$");
 
   // „Die §§ 46 und 47 werden zu den §§ 34 und 35.“ — paarweise §-Umnummerierung (auch Bereiche).
   private static final Pattern UMNUMMERIERUNG_PARAGRAPHEN =
-      Pattern.compile("^Die §§ (.+?) werden (?:zu den §§ |zu §§ |die §§ )(.+?)\\.$");
+      Pattern.compile("^Die (§§|Artt?\\.) (.+?) werden (?:zu den \\1 |zu \\1 |die \\1 )(.+?)\\.$");
 
   // „Die §§ 52 bis 56 werden wie folgt gefasst: „§ 52 (weggefallen) …““ — Neufassung eines §-Bereichs;
   // der Zitatblock wird an „§ N“-Grenzen in Einzel-Neufassungen zerlegt.
   private static final Pattern PARAGRAPH_BEREICH_NEUFASSUNG =
       Pattern.compile(
-          "^Die §§ (\\d+[a-z]?) bis (\\d+[a-z]?) (?:wird|werden) wie folgt gefasst: " + Z + "\\.?$");
+          "^Die (?:§§|Artt?\\.) (\\d+[a-z]?) bis (\\d+[a-z]?) (?:wird|werden) wie folgt gefasst: "
+              + Z
+              + "\\.?$");
 
-  // „Der Wortlaut wird Absatz 1.“
+  // „Der Wortlaut wird Absatz 1.“, bayerisch auch „Der bisherige Wortlaut wird Abs. 5.“ und
+  // „Der Wortlaut wird Satz 1.“
   private static final Pattern WORTLAUT_ZU_ABSATZ =
-      Pattern.compile("^Der Wortlaut wird Absatz (\\d+[a-z]?)\\.$");
+      Pattern.compile("^Der (?:bisherige )?Wortlaut wird (Absatz|Abs\\.|Satz) (\\d+[a-z]?)\\.$");
 
   // „In Nummer 7 wird das Wort «1» am Ende durch ein Komma ersetzt.“
   private static final Pattern WORT_ZU_SATZZEICHEN =
@@ -361,15 +401,16 @@
 
   private static final Pattern EBENE_BEZEICHNUNG =
       Pattern.compile(
-          "^(?:§ (\\d+[a-z]?)|Absatz (\\d+[a-z]?)|Satz(?: (\\d+[a-z]?))?|Sätze"
-              + "|Nummer (\\d+[a-z]?)|Buchstabe ([a-z]{1,3})"
-              + "|(Absätze .+|Nummern .+|Buchstaben .+))$");
+          "^(?:(?:§|Art\\.) (\\d+[a-z]?)|(?:Absatz|Abs\\.) (\\d+[a-z]?)|Satz(?: (\\d+[a-z]?))?|Sätze"
+              + "|(?:Nummer|Nr\\.) (\\d+[a-z]?)|(?:Buchstabe|Buchst\\.) ([a-z]{1,3})"
+              + "|(Absätze .+|Abs\\. .+|Sätze .+|Nummern .+|Nrn?\\. .+|Buchstaben .+"
+              + "|Buchst\\. .+))$");
 
   // „In <Stelle> werden die Wörter «1» durch die Wörter «2» und die Angabe «3» durch die Wörter «4»
   // ersetzt.“ — mehrere Ersetzungspaare unter einem gemeinsamen „ersetzt“. Die Mitte (Gruppe 2)
   // wird an „ und “ in Einzelpaare zerlegt und je gegen EIN_ERSETZUNGS_PAAR validiert.
   private static final Pattern PAAR_ERSETZUNG =
-      Pattern.compile("^(?:In )?(.+?) (?:wird|werden) (.+(?: und |, ).+) ersetzt\\.$");
+      Pattern.compile("^(?:In )?(.+?) (?:wird|werden) (.+(?: und | sowie |, ).+) ersetzt\\.$");
   private static final Pattern EIN_ERSETZUNGS_PAAR =
       Pattern.compile(
           "^(?:jeweils )?"
@@ -381,15 +422,17 @@
               + " )?"
               + Z
               + "$");
-  // Paare trennen sich an „ und “ sowie an Kommata vor dem nächsten Wörter-Objekt.
+  // Paare trennen sich an „ und “/„ sowie “ sowie an Kommata vor dem nächsten Wörter-Objekt.
   private static final Pattern PAAR_SEP =
-      Pattern.compile(" und |,\\s+(?=(?:die Wörter|das Wort|die Angabe|die Zahl) )");
+      Pattern.compile(" und | sowie |,\\s+(?=(?:die Wörter|das Wort|die Angabe|die Zahl) )");
 
   // „Die bisherigen Absätze 6 und 7 werden die Absätze 1 und 2.“ — koordinierte Umnummerierung.
   private static final Pattern UMNUMMERIERUNG_KOORDINIERT =
       Pattern.compile(
-          "^Die (?:bisherigen )?(Absätze|Sätze|Nummern|Buchstaben) (\\d+[a-z]?) und (\\d+[a-z]?) "
-              + "werden (?:zu den |die )?(?:Absätze[n]?|Sätze[n]?|Nummern|Buchstaben) "
+          "^Die (?:bisherigen )?(Absätze|Abs\\.|Sätze|Nummern|Nrn?\\.|Buchstaben|Buchst\\.)"
+              + " (\\d+[a-z]?) und (\\d+[a-z]?) "
+              + "werden (?:zu den |die )?(?:Absätze[n]?|Abs\\.|Sätze[n]?|Nummern|Nrn?\\."
+              + "|Buchstaben|Buchst\\.) "
               + "(\\d+[a-z]?) und (\\d+[a-z]?)\\.$");
 
   // „In Absatz 3 Satz 1 wird vor dem Punkt am Ende ein Komma und werden die Wörter „…“
@@ -408,7 +451,8 @@
   private static final Pattern EINFUEGUNGS_PAARE =
       Pattern.compile(
           "^(?:In )?(.+?) (?:wird|werden) (?:jeweils )?((?:nach|vor) .+) eingefügt\\.$");
-  private static final Pattern EINFUEGUNGS_PAAR_SEP = Pattern.compile(" und (?=nach |vor )");
+  private static final Pattern EINFUEGUNGS_PAAR_SEP =
+      Pattern.compile("(?: und |,\\s+)(?=nach |vor )");
   private static final Pattern EIN_EINFUEGUNGS_PAAR =
       Pattern.compile(
           "^(nach|vor) (?:dem Wort|den Wörtern|der Angabe|der Zahl) "
@@ -422,7 +466,12 @@
   // „… ein Komma eingefügt und werden …“: Trennstellen eines Verbundbefehls sind „ und “ (ggf. mit
   // Komma) bzw. „, “ direkt vor „wird/werden“. Innerhalb von Zitaten steht „ und “ als «n» maskiert.
   private static final Pattern VERBUND_SEP =
-      Pattern.compile(",? und |, (?=wird\\b|werden\\b)");
+      Pattern.compile(
+          ",? und |, (?=wird\\b|werden\\b)"
+              // Komma-Kette gleichrangiger Klauseln („… ersetzt, die Angabe «n» wird gestrichen
+              // und …“) — nur vor einer Wortgruppen-Klausel mit maskiertem Zitat, damit echte
+              // Relativsätze nicht getrennt werden.
+              + "|, (?=(?:die Wörter|das Wort|die Angabe|die Zahl) «)");
   private static final Pattern WIRD_WERDEN = Pattern.compile(" (?:wird|werden) ");
 
   // „In <Stelle> wird nach den Wörtern «1» ein Komma eingefügt.“ (Satzzeichen statt Wörter einfügen)
@@ -461,7 +510,8 @@
   private static final Pattern UMNUMMERIERUNGS_RAHMEN =
       Pattern.compile(
           "^(?:Der bisherige |Die bisherige |Das bisherige )?(.+?) wird (?:zu )?"
-              + "(§|Absatz|Satz|Nummer|Buchstabe|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage)"
+              + "(§|Art\\.|Absatz|Abs\\.|Satz|Nummer|Nr\\.|Buchstabe|Buchst\\."
+              + "|Teil|Abschnitt|Unterabschnitt|Buch|Kapitel|Anlage)"
               + " (\\d+[a-z]?) und wird wie folgt geändert:$");
 
   /** Ein Kontextrahmen samt optionalem Begleitbefehl (Umnummerierung des Rahmens selbst). */
@@ -599,7 +649,21 @@
     }
 
     if ((m = WORTLAUT_ZU_ABSATZ.matcher(text)).matches()) {
-      return Optional.of(new WortlautZuAbsatz(kontext, m.group(1), provenienz));
+      if (m.group(1).equals("Satz")) {
+        return Optional.of(new WortlautZuSatz(kontext, m.group(2), provenienz));
+      }
+      return Optional.of(new WortlautZuAbsatz(kontext, m.group(2), provenienz));
+    }
+
+    if ((m = FUSSNOTE_AUFHEBUNG.matcher(text)).matches()) {
+      var nummern = List.of(FUSSNOTEN_TRENNER.split(m.group(1)));
+      return Optional.of(new FussnotenAufhebung(kontext, nummern, provenienz));
+    }
+
+    if ((m = SATZNUMMERIERUNG_STREICHUNG.matcher(text)).matches()) {
+      var nummer = wortZitat(zitate, m.group(2));
+      return ausStellen(
+          m.group(1), s -> new SatznummerierungStreichung(kontext.plus(s), nummer, provenienz));
     }
 
     if ((m = UEBERSCHRIFT_ERSETZUNG.matcher(text)).matches()) {
@@ -658,7 +722,7 @@
       if (stellen.size() == 1
           && (ziel.equals("Überschrift")
               || ziel.equals("Inhaltsübersicht")
-              || ziel.matches("§\\s*\\d+[a-z]?"))) {
+              || ziel.matches("(?:§|Art\\.)\\s*\\d+[a-z]?"))) {
         return Optional.of(new Neufassung(kontext.plus(stellen.get(0)), neuerText, provenienz));
       }
       var ebene = strukturEbene(ziel);
@@ -845,7 +909,7 @@
         // „Nach § 60a werden die folgenden §§ 60b und 60c eingefügt: „…““ — Block mehrerer
         // Paragraphen (Aufteilung an den §-Überschriften erfolgt beim Anwenden). Signal:
         // Ebene PARAGRAPH mit bezeichnung == null.
-        if (m.group(3).strip().matches("§§\\s*\\d.*")) {
+        if (m.group(3).strip().matches("(?:§§|Artt?\\.)\\s*\\d.*")) {
           return Optional.of(
               new StrukturEinfuegung(
                   kontext.plus(stelle.get()),
@@ -872,6 +936,12 @@
       // Bei der stellenlosen Form ist die neue Einheit zugleich der Anker (sie tritt vor die
       // gleichnamige bestehende Einheit).
       boolean mitStelle = m.pattern() == VORANSTELLUNG_MIT_STELLE;
+      // „Dem Wortlaut werden die folgenden Abs. 1 bis 4 vorangestellt: „…““ (bayerisch): die
+      // neuen Absätze treten vor den gesamten bisherigen Normtext.
+      if (mitStelle && m.group(1).equals("Wortlaut")) {
+        return Optional.of(
+            new WortlautVoranstellung(kontext, zitat(zitate, m.group(4)), provenienz));
+      }
       var ankerPhrase = m.group(1);
       var ebeneBez = ebeneUndBezeichnung(mitStelle ? m.group(2) : m.group(1));
       var stelle = StellenParser.parse(ankerPhrase);
@@ -996,12 +1066,40 @@
       return ausStellen(m.group(1), s -> new Streichung(kontext.plus(s), woerter, provenienz));
     }
 
+    if ((m = STREICHUNG_OHNE_STELLE.matcher(text)).matches()) {
+      var woerter = wortZitat(zitate, m.group(1));
+      return Optional.of(new Streichung(kontext, woerter, provenienz));
+    }
+
+    if ((m = STREICHUNG_MEHRFACH.matcher(text)).matches()) {
+      var stellen = StellenParser.parseMehrfach(m.group(1));
+      if (stellen.isEmpty()) {
+        if (!StellenParser.istNurChapeau(m.group(1))) {
+          return Optional.empty();
+        }
+        stellen = List.of(Stelle.LEER);
+      }
+      var objekte = new ArrayList<String>();
+      var zm = Pattern.compile("«(\\d+)»").matcher(m.group(2));
+      while (zm.find()) {
+        objekte.add(wortZitat(zitate, zm.group(1)));
+      }
+      var teile = new ArrayList<Aenderungsbefehl>();
+      for (var s : stellen) {
+        for (var woerter : objekte) {
+          teile.add(new Streichung(kontext.plus(s), woerter, provenienz));
+        }
+      }
+      return Optional.of(teile.size() == 1 ? teile.get(0) : new Sammelbefehl(teile));
+    }
+
     if ((m = STRUKTUR_STREICHUNG.matcher(text)).matches()) {
       return ausStellen(m.group(1), s -> new Aufhebung(kontext.plus(s), provenienz));
     }
 
     if ((m = UMNUMMERIERUNG_PARAGRAPHEN.matcher(text)).matches()) {
-      return paragraphenUmnummerierung(m.group(1), m.group(2), kontext, provenienz);
+      var sigel = m.group(1).startsWith("Art") ? "Art. " : "§ ";
+      return paragraphenUmnummerierung(sigel, m.group(2), m.group(3), kontext, provenienz);
     }
 
     if ((m = UMNUMMERIERUNG_BEREICH.matcher(text)).matches()) {
@@ -1047,7 +1145,12 @@
     }
     var stellen = StellenParser.parseMehrfach(m.group(1));
     if (stellen.isEmpty()) {
-      return Optional.empty();
+      // „In dem Satzteil nach Nr. 3 werden … ersetzt.“ — reine Chapeau-Angabe ohne eigene
+      // Komponente: die Ersetzung sucht im Text der Kontextstelle.
+      if (!StellenParser.istNurChapeau(m.group(1))) {
+        return Optional.empty();
+      }
+      stellen = List.of(Stelle.LEER);
     }
     var segmente = PAAR_SEP.split(m.group(2));
     if (segmente.length < 2) {
@@ -1135,6 +1238,13 @@
    * erkannt werden, entsteht ein {@link Sammelbefehl}. Nur wenn <em>alle</em> Klauseln erkannt
    * werden, greift die Zerlegung — sonst bleibt der Befehl unbekannt (konservativ).
    */
+  // Reine Wortoperationen tragen nie einen eigenen strukturellen Lokativ, sondern wirken innerhalb
+  // des zuvor gesetzten Skopus (Gapping): „… und die Angabe „X“ wird gestrichen/eingefügt“.
+  private static final Pattern REINE_WORT_OPERATION =
+      Pattern.compile(
+          "(?i)(?:die Angabe|nach der Angabe|vor der Angabe|die Wörter|die Worte|"
+              + "nach den Wörtern|vor den Wörtern|das Wort)\\b");
+
   private static Optional<Aenderungsbefehl> erkenneVerbund(
       String text, Stelle kontext, ZitatExtraktor.Ergebnis zitate, Provenienz provenienz) {
     var sep = VERBUND_SEP.matcher(text);
@@ -1146,6 +1256,15 @@
       }
       var linksBefehl = erkenneAlsSatz(links, kontext, zitate, provenienz);
       if (linksBefehl.isEmpty()) {
+        // Gemeinsames Schlussverb (Gapping): „die Angabe «A» wird durch die Angabe «B» und die
+        // Angabe «C» wird durch die Angabe «D» ersetzt.“ — das „ersetzt“ der rechten Klausel
+        // gilt auch links.
+        var schluss = gemeinsamerVerbSchluss(rechts);
+        if (schluss != null) {
+          linksBefehl = erkenneAlsSatz(links + " " + schluss, kontext, zitate, provenienz);
+        }
+      }
+      if (linksBefehl.isEmpty()) {
         continue;
       }
       var rechtsBefehl =
@@ -1182,12 +1301,50 @@
     if (linksBefehl instanceof Umnummerierung um
         && um.neu().paragraph().isPresent()
         && rechts.startsWith("in ")
-        && !rechts.matches(".*§\\s*\\d.*")) {
+        && !rechts.matches(".*(?:§|Art\\.)\\s*\\d.*")) {
       var imNeuen = erkenneAlsSatz(gross, um.neu(), zitate, provenienz);
       if (imNeuen.isPresent()) {
         return imNeuen;
       }
     }
+    // „Der bisherige Wortlaut wird Abs. 5 und in Halbsatz 1 wird … ersetzt“ (bayerisch): die
+    // lokative Folgeklausel bezieht sich auf den soeben nummerierten Absatz.
+    if (linksBefehl instanceof WortlautZuAbsatz wz
+        && rechts.startsWith("in ")
+        && !rechts.matches(".*(?:§|Art\\.)\\s*\\d.*")) {
+      var neuKontext =
+          wz.stelle().plus(new Stelle(List.of(new Stelle.AbsatzNr(wz.nummer()))));
+      var imNeuen = erkenneAlsSatz(gross, neuKontext, zitate, provenienz);
+      if (imNeuen.isPresent()) {
+        return imNeuen;
+      }
+    }
+    // Gapping mit gemeinsamem Lokativ: „In Abs. 2 Satz 1 wird A ersetzt und die Angabe „B“ wird
+    // gestrichen“ — die rechte Klausel ist eine reine Wortoperation ohne eigenen Lokativ und erbt
+    // daher den Skopus der linken (sonst löste sie fälschlich auf Artikelebene auf). Nur wenn die
+    // linke Klausel überhaupt einen Lokativ trägt und der so entstandene Befehl eine engere Stelle
+    // als der bloße Kontext trifft.
+    // Nach einer Umnummerierung wird die Wortoperation nicht auf die neue Stelle festgenagelt: sie
+    // löst norm-weit auf (findet ihren Zieltext im umbenannten Absatz, ohne eine womöglich schon
+    // bestehende Zielnummer fälschlich zu treffen) — das übernehmen die Zweige weiter unten.
+    if (REINE_WORT_OPERATION.matcher(rechts).lookingAt()
+        && !(linksBefehl instanceof Umnummerierung)) {
+      var praefix0 = lokativerPraefix(links);
+      var vm = WIRD_WERDEN.matcher(rechts);
+      if (praefix0 != null && !praefix0.isBlank() && vm.find()) {
+        // „die Angabe „X“ wird gestrichen“ → „In <loc> wird die Angabe „X“ gestrichen“: den Lokativ
+        // der linken Klausel voranstellen und das Verb nach vorn ziehen (grammatische Normalform).
+        var subjekt = rechts.substring(0, vm.start()).strip();
+        var praedikat = rechts.substring(vm.end()).strip();
+        var umgestellt =
+            praefix0.strip() + " " + vm.group().strip() + " " + subjekt + " " + praedikat;
+        var geerbt = erkenneAlsSatz(umgestellt, kontext, zitate, provenienz);
+        if (geerbt.isPresent()
+            && geerbt.get().stelle().komponenten().size() > kontext.komponenten().size()) {
+          return geerbt;
+        }
+      }
+    }
     var direkt = erkenneAlsSatz(rechts, kontext, zitate, provenienz);
     if (direkt.isPresent()) {
       return direkt;
@@ -1257,6 +1414,15 @@
     return erkenne(satz, kontext, zitate, provenienz);
   }
 
+  private static final Pattern VERB_SCHLUSS =
+      Pattern.compile(".*\\b(ersetzt|gestrichen|eingefügt|angefügt|aufgehoben)\\.$");
+
+  /** Das gemeinsame Schlussverb einer Klauselkette („… ersetzt.“), falls vorhanden. */
+  private static @Nullable String gemeinsamerVerbSchluss(String rechts) {
+    var m = VERB_SCHLUSS.matcher(rechts);
+    return m.matches() ? m.group(1) + "." : null;
+  }
+
   /** Der Teil einer Klausel vor dem ersten „wird“/„werden“ („In § 3 Absatz 1“). */
   private static @Nullable String lokativerPraefix(String klausel) {
     var m = WIRD_WERDEN.matcher(klausel);
@@ -1276,9 +1442,9 @@
    * §-Umnummerierungen auf. Beide Seiten werden zu Paragraphenlisten expandiert und zusammengeführt.
    */
   private static Optional<Aenderungsbefehl> paragraphenUmnummerierung(
-      String altPhrase, String neuPhrase, Stelle kontext, Provenienz provenienz) {
-    var alt = StellenParser.parseMehrfach("§ " + altPhrase);
-    var neu = StellenParser.parseMehrfach("§ " + neuPhrase);
+      String sigel, String altPhrase, String neuPhrase, Stelle kontext, Provenienz provenienz) {
+    var alt = StellenParser.parseMehrfach(sigel + altPhrase);
+    var neu = StellenParser.parseMehrfach(sigel + neuPhrase);
     if (alt.isEmpty() || alt.size() != neu.size()) {
       return Optional.empty();
     }
@@ -1429,11 +1595,11 @@
   private static @Nullable Ebene strukturEbene(String ziel) {
     var erstesWort = ziel.split("\\s+", 2)[0];
     return switch (erstesWort) {
-      case "§", "§§" -> Ebene.PARAGRAPH;
-      case "Absatz", "Absätze" -> Ebene.ABSATZ;
+      case "§", "§§", "Art.", "Artt." -> Ebene.PARAGRAPH;
+      case "Absatz", "Absätze", "Abs." -> Ebene.ABSATZ;
       case "Satz", "Sätze" -> Ebene.SATZ;
-      case "Nummer", "Nummern" -> Ebene.NUMMER;
-      case "Buchstabe", "Buchstaben" -> Ebene.BUCHSTABE;
+      case "Nummer", "Nummern", "Nr.", "Nrn." -> Ebene.NUMMER;
+      case "Buchstabe", "Buchstaben", "Buchst." -> Ebene.BUCHSTABE;
       default -> null;
     };
   }
@@ -1441,10 +1607,11 @@
   private static Stelle.Komponente komponenteFuer(String ebene, String nummer) {
     return switch (ebene) {
       case "§" -> new Stelle.Paragraph(nummer);
-      case "Absatz" -> new Stelle.AbsatzNr(nummer);
+      case "Art." -> new Stelle.Paragraph(nummer, "Art.");
+      case "Absatz", "Abs." -> new Stelle.AbsatzNr(nummer);
       case "Satz" -> new Stelle.SatzNr(nummer);
-      case "Nummer" -> new Stelle.NummerNr(nummer);
-      case "Buchstabe" -> new Stelle.BuchstabeNr(nummer);
+      case "Nummer", "Nr." -> new Stelle.NummerNr(nummer);
+      case "Buchstabe", "Buchst." -> new Stelle.BuchstabeNr(nummer);
       case "Teil", "Abschnitt", "Unterabschnitt", "Buch", "Kapitel", "Anlage" ->
           new Stelle.Gliederungseinheit(ebene, nummer);
       default -> throw new IllegalArgumentException("Unbekannte Ebene: " + ebene);
@@ -1454,10 +1621,10 @@
   /** Normalisiert die Ebenenwörter (auch Dativ-/Pluralformen) auf den Basisnamen. */
   private static @Nullable String ebeneAusWort(String wort) {
     return switch (wort) {
-      case "Absatz", "Absätze", "Absätzen" -> "Absatz";
+      case "Absatz", "Absätze", "Absätzen", "Abs." -> "Absatz";
       case "Satz", "Sätze", "Sätzen" -> "Satz";
-      case "Nummer", "Nummern" -> "Nummer";
-      case "Buchstabe", "Buchstaben" -> "Buchstabe";
+      case "Nummer", "Nummern", "Nr.", "Nrn." -> "Nummer";
+      case "Buchstabe", "Buchstaben", "Buchst." -> "Buchstabe";
       default -> null;
     };
   }
@@ -1469,17 +1636,18 @@
   private static Optional<Aenderungsbefehl> paragraphBereichNeufassung(
       String block, Stelle kontext, Provenienz provenienz) {
     var teile = new ArrayList<Aenderungsbefehl>();
-    var stuecke = block.strip().split("(?=§\\s*\\d)");
+    var stuecke = block.strip().split("(?=(?:§|Art\\.)\\s*\\d)");
     for (var stueck : stuecke) {
       var s = stueck.strip();
       if (s.isEmpty()) {
         continue;
       }
-      var pm = Pattern.compile("^§\\s*(\\d+[a-z]?)\\b").matcher(s);
+      var pm = Pattern.compile("^(§|Art\\.)\\s*(\\d+[a-z]?)\\b").matcher(s);
       if (!pm.find()) {
         return Optional.empty();
       }
-      var stelle = kontext.plus(new Stelle(List.of(new Stelle.Paragraph(pm.group(1)))));
+      var stelle =
+          kontext.plus(new Stelle(List.of(new Stelle.Paragraph(pm.group(2), pm.group(1)))));
       teile.add(new Neufassung(stelle, s, provenienz));
     }
     if (teile.isEmpty()) {
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/FontgroessenFilter.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/FontgroessenFilter.java
index 964d856..26589b3 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/FontgroessenFilter.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/FontgroessenFilter.java
@@ -84,6 +84,11 @@
   private FontgroessenFilter() {}
 
   static String extrahiere(PDDocument dokument) throws IOException {
+    return extrahiere(dokument, SuperskriptModus.ENTFERNEN);
+  }
+
+  static String extrahiere(PDDocument dokument, SuperskriptModus superskriptModus)
+      throws IOException {
     var zaehler = new GroessenZaehler();
     zaehler.setLineSeparator("\n");
     var wegwerf = new StringWriter();
@@ -96,7 +101,9 @@
     }
     log.debugf("Brotschriftgrößen (je Seite): %s", schwellen);
 
-    var filter = new GroessenFilterStripper(schwellen, zaehler.brotschriftUntergrenzen(schwellen));
+    var filter =
+        new GroessenFilterStripper(
+            schwellen, zaehler.brotschriftUntergrenzen(schwellen), superskriptModus);
     filter.setLineSeparator("\n");
     var ausgabe = new StringWriter();
     filter.writeText(dokument, ausgabe);
@@ -303,21 +310,42 @@
     /** Läufe, die um mehr als diese Punktzahl unter der Brotschrift liegen, sind immer Beiwerk. */
     private static final float STARK_KLEINER_PT = 3f;
 
+    /** Mindest-Hebung (pt) der Grundlinie, ab der eine kleinere Ziffer als Superskript gilt. */
+    private static final float SUPERSKRIPT_HEBUNG_MIN_PT = 2f;
+
+    /** Maximal-Hebung (pt): darüber liegt ein Zeilenwechsel vor, kein Superskript. */
+    private static final float SUPERSKRIPT_HEBUNG_MAX_PT = 6f;
+
     private final Map<Integer, Float> schwellen;
     private final Map<Integer, Float> untergrenzen;
+    private final SuperskriptModus superskriptModus;
 
     /** End-X (pt) des breitesten behaltenen Laufs der laufenden Zeile; NaN vor dem ersten. */
     private float zeilenEndX = Float.NaN;
 
-    GroessenFilterStripper(Map<Integer, Float> schwellen, Map<Integer, Float> untergrenzen) {
+    GroessenFilterStripper(
+        Map<Integer, Float> schwellen,
+        Map<Integer, Float> untergrenzen,
+        SuperskriptModus superskriptModus) {
       this.schwellen = schwellen;
       this.untergrenzen = untergrenzen;
+      this.superskriptModus = superskriptModus;
     }
 
     @Override
     protected void writeString(String text, List<TextPosition> positionen) throws IOException {
       if (!behalte(positionen)) {
-        return; // Fußnotenblock bzw. hochgestellte Ziffer
+        // Fußnotenblock bzw. hochgestellte Ziffer. In BEHALTEN-Modus werden reine Ziffernläufe
+        // im Satzspiegel (oberhalb des Fußnotenblocks) als Superskripte übernommen.
+        var hochgestellt = superskriptModus == SuperskriptModus.BEHALTEN ? nurZiffern(positionen) : null;
+        if (hochgestellt == null) {
+          return;
+        }
+        text = hochgestellt;
+      } else if (superskriptModus == SuperskriptModus.BEHALTEN) {
+        // Gehobene, kleiner gesetzte Ziffern innerhalb eines Brotschrift-Laufs (bayerische
+        // Satznummern und Fußnotenmarker kleben im selben Lauf wie der Fließtext).
+        text = mitSuperskripten(text, positionen);
       }
       for (var position : positionen) {
         float endX = position.getXDirAdj() + position.getWidthDirAdj();
@@ -326,6 +354,76 @@
       super.writeString(text, positionen);
     }
 
+    /**
+     * Der Lauf als Superskript-Text, falls er ausschließlich aus Ziffern im Satzspiegel besteht
+     * (hochgestellte Marker, die als eigener Lauf ankommen); sonst {@code null}.
+     */
+    private @org.jspecify.annotations.Nullable String nurZiffern(List<TextPosition> positionen) {
+      if (positionen.isEmpty()) {
+        return null;
+      }
+      var grenze = untergrenzen.get(getCurrentPageNo());
+      var sb = new StringBuilder();
+      for (var position : positionen) {
+        if (grenze != null && position.getYDirAdj() > grenze) {
+          return null; // Fußnotenblock
+        }
+        var unicode = position.getUnicode();
+        for (int i = 0; i < unicode.length(); i++) {
+          if (!Character.isDigit(unicode.charAt(i))) {
+            return null;
+          }
+        }
+        sb.append(eu.mulk.aendggner.gesetz.Superskript.zuSuperskript(unicode));
+      }
+      return sb.toString();
+    }
+
+    /**
+     * Ersetzt innerhalb eines behaltenen Laufs Ziffern, die kleiner gesetzt und gegenüber der
+     * Grundlinie des Laufs deutlich gehoben sind, durch Unicode-Superskripte. Die Grundlinie ist
+     * das größte Y des Laufs (gehobene Zeichen haben kleinere Y-Werte); die Hebung ist nach oben
+     * begrenzt, damit ein etwaiger Zeilenwechsel im Lauf keine Fehltreffer erzeugt.
+     */
+    private String mitSuperskripten(String text, List<TextPosition> positionen) {
+      float grundlinie = Float.NEGATIVE_INFINITY;
+      float brotschriftGroesse = 0;
+      for (var position : positionen) {
+        if (position.getYDirAdj() > grundlinie) {
+          grundlinie = position.getYDirAdj();
+          brotschriftGroesse = position.getFontSizeInPt();
+        }
+      }
+      var sb = new StringBuilder(text.length());
+      boolean geaendert = false;
+      for (var position : positionen) {
+        var unicode = position.getUnicode();
+        float hebung = grundlinie - position.getYDirAdj();
+        if (hebung >= SUPERSKRIPT_HEBUNG_MIN_PT
+            && hebung <= SUPERSKRIPT_HEBUNG_MAX_PT
+            && position.getFontSizeInPt() < brotschriftGroesse
+            && istZiffernfolge(unicode)) {
+          sb.append(eu.mulk.aendggner.gesetz.Superskript.zuSuperskript(unicode));
+          geaendert = true;
+        } else {
+          sb.append(unicode);
+        }
+      }
+      return geaendert ? sb.toString() : text;
+    }
+
+    private static boolean istZiffernfolge(String unicode) {
+      if (unicode.isEmpty()) {
+        return false;
+      }
+      for (int i = 0; i < unicode.length(); i++) {
+        if (!Character.isDigit(unicode.charAt(i))) {
+          return false;
+        }
+      }
+      return true;
+    }
+
     /** Schreibt vor jedem Zeilentrenner das End-X der Zeile als Metadaten für
      * {@link #klassifiziereZeilenenden}. */
     @Override
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
index 9112cb6..c9fde36 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
@@ -21,6 +21,15 @@
   private static final Logger log = Logger.getLogger(PatchTextExtraktor.class);
 
   private final Tika tika = new Tika();
+  private final SuperskriptModus superskriptModus;
+
+  public PatchTextExtraktor() {
+    this(SuperskriptModus.ENTFERNEN);
+  }
+
+  public PatchTextExtraktor(SuperskriptModus superskriptModus) {
+    this.superskriptModus = superskriptModus;
+  }
 
   public String extrahiere(Path datei) throws IOException {
     var mimeType = tika.detect(datei);
@@ -36,9 +45,9 @@
     };
   }
 
-  private static String extrahierePdf(Path datei) throws IOException {
+  private String extrahierePdf(Path datei) throws IOException {
     try (var dokument = Loader.loadPDF(datei.toFile())) {
-      return FontgroessenFilter.extrahiere(dokument);
+      return FontgroessenFilter.extrahiere(dokument, superskriptModus);
     }
   }
 }
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java
index 78a815b..473eb14 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/StellenParser.java
@@ -46,12 +46,13 @@
 
   private StellenParser() {}
 
-  // „in dem Satzteil vor Nummer 1“, „in der Angabe vor Nummer 1“ — verfeinernde Chapeau-Angaben
-  // ohne eigene Stelle-Komponente; die Ersetzung sucht ohnehin im Text der umgebenden Stelle.
+  // „in dem Satzteil vor Nummer 1“, „in der Angabe vor Nummer 1“, bayerisch auch „Satzteil nach
+  // Nr. 3“ — verfeinernde Chapeau-Angaben ohne eigene Stelle-Komponente; die Ersetzung sucht
+  // ohnehin im Text der umgebenden Stelle.
   private static final Pattern CHAPEAU_QUALIFIER =
       Pattern.compile(
-          "(?i)(?:im |in dem |in der |dem |der )?(?:Satzteil|Angabe) vor "
-              + "(?:Nummer|Buchstabe|Satz|Absatz) \\S+");
+          "(?i)(?:im |in dem |in der |dem |der )?(?:Satzteil|Angabe) (?:vor|nach) "
+              + "(?:Nummer|Nr\\.|Buchstabe|Buchst\\.|Satz|Absatz|Abs\\.) \\S+");
 
   /**
    * Wahr, wenn die Phrase ausschließlich aus einem Chapeau-Qualifier besteht (z.B. „im Satzteil
@@ -82,7 +83,16 @@
           komponenten.add(new Stelle.Paragraph(wert));
           i++;
         }
-        case "Absatz", "Abs.", "Absätze" -> {
+        // Bayerisches Landesrecht: Gesetze gliedern sich in Artikel, zitiert stets als „Art. N“.
+        case "Art.", "Artt." -> {
+          var wert = naechstesWort(woerter, i);
+          if (wert == null || !NUMMER_WERT.matcher(wert).matches()) {
+            return Optional.empty();
+          }
+          komponenten.add(new Stelle.Paragraph(wert, "Art."));
+          i++;
+        }
+        case "Absatz", "Abs.", "Absätze", "Absätzen" -> {
           var wert = naechstesWort(woerter, i);
           if (wert == null || !NUMMER_WERT.matcher(wert).matches()) {
             return Optional.empty();
@@ -90,7 +100,7 @@
           komponenten.add(new Stelle.AbsatzNr(wert));
           i++;
         }
-        case "Satz", "Sätze" -> {
+        case "Satz", "Sätze", "Sätzen" -> {
           var wert = naechstesWort(woerter, i);
           if (wert == null || !NUMMER_WERT.matcher(wert).matches()) {
             return Optional.empty();
@@ -98,7 +108,15 @@
           komponenten.add(new Stelle.SatzNr(wert));
           i++;
         }
-        case "Nummer", "Nr.", "Nummern" -> {
+        case "Halbsatz", "Halbsätze", "Halbs." -> {
+          var wert = naechstesWort(woerter, i);
+          if (wert == null || !NUMMER_WERT.matcher(wert).matches()) {
+            return Optional.empty();
+          }
+          komponenten.add(new Stelle.HalbsatzNr(wert));
+          i++;
+        }
+        case "Nummer", "Nr.", "Nummern", "Nrn." -> {
           var wert = naechstesWort(woerter, i);
           if (wert == null || !NUMMER_WERT.matcher(wert).matches()) {
             return Optional.empty();
@@ -195,6 +213,14 @@
           return List.of();
         }
         voll = geerbt.get();
+      } else if (vorige != null) {
+        // Bloßes Label mit nachgestellten Komponenten („Art. 18 Satz 2, Art. 19 und 20 Satz 1“ →
+        // das „20 Satz 1“): Das Label erbt die gröbste passende Komponentenart der vorigen Stelle.
+        var kombiniert = mitGeerbtemLabelUndRest(vorige, segment);
+        if (kombiniert.isEmpty()) {
+          return List.of();
+        }
+        voll = kombiniert.get();
       } else {
         return List.of();
       }
@@ -217,9 +243,58 @@
     return Optional.of(new Stelle(komponenten));
   }
 
+  private static final Pattern LABEL_MIT_REST =
+      Pattern.compile("(\\d+[a-z]?|[a-z]{1,3})\\s+(\\S.*)");
+
+  /**
+   * „Art. 19 und 20 Satz 1“: Das führende bloße Label des Segments erbt aus {@code vorige} die
+   * letzte Komponentenart, die gröber ist als die erste Komponente des Rests; die feineren
+   * Komponenten der vorigen Stelle entfallen, der geparste Rest wird angehängt.
+   */
+  private static Optional<Stelle> mitGeerbtemLabelUndRest(Stelle vorige, String segment) {
+    var m = LABEL_MIT_REST.matcher(segment.strip());
+    if (!m.matches()) {
+      return Optional.empty();
+    }
+    var rest = parse(m.group(2));
+    if (rest.isEmpty()) {
+      return Optional.empty();
+    }
+    int restRang = rang(rest.get().komponenten().get(0));
+    var vorKomp = vorige.komponenten();
+    for (int i = vorKomp.size() - 1; i >= 0; i--) {
+      if (rang(vorKomp.get(i)) < restRang) {
+        var neu = mitLabel(vorKomp.get(i), m.group(1));
+        if (neu == null) {
+          return Optional.empty();
+        }
+        var komponenten = new ArrayList<Stelle.Komponente>(vorKomp.subList(0, i));
+        komponenten.add(neu);
+        komponenten.addAll(rest.get().komponenten());
+        return Optional.of(new Stelle(komponenten));
+      }
+    }
+    return Optional.empty();
+  }
+
+  /** Hierarchie-Rang einer Komponente (kleiner = gröber). */
+  private static int rang(Stelle.Komponente komponente) {
+    return switch (komponente) {
+      case Stelle.Gliederungseinheit g -> 0;
+      case Stelle.Paragraph p -> 1;
+      case Stelle.AbsatzNr a -> 2;
+      case Stelle.SatzNr s -> 3;
+      case Stelle.HalbsatzNr h -> 4;
+      case Stelle.NummerNr n -> 5;
+      case Stelle.BuchstabeNr b -> 6;
+      default -> 9;
+    };
+  }
+
   private static final Pattern BEREICH =
       Pattern.compile(
-          "(?:(§§?|Absätze|Absatz|Sätze|Satz|Nummern|Nummer|Buchstaben|Buchstabe)\\s+)?"
+          "(?:(§§?|Artt?\\.|Absätze|Absatz|Abs\\.|Sätze|Satz|Nummern|Nummer|Nrn?\\.|Buchstaben"
+              + "|Buchstabe|Buchst\\.)\\s+)?"
               + "(\\d+|[a-z])\\s+bis\\s+(\\d+|[a-z])");
 
   /**
@@ -292,19 +367,21 @@
   private static Stelle.@Nullable Komponente komponenteFuerArt(String art, String label) {
     return switch (art) {
       case "§", "§§" -> new Stelle.Paragraph(label);
-      case "Absatz", "Absätze" -> new Stelle.AbsatzNr(label);
+      case "Art.", "Artt." -> new Stelle.Paragraph(label, "Art.");
+      case "Absatz", "Absätze", "Abs." -> new Stelle.AbsatzNr(label);
       case "Satz", "Sätze" -> new Stelle.SatzNr(label);
-      case "Nummer", "Nummern" -> new Stelle.NummerNr(label);
-      case "Buchstabe", "Buchstaben" -> new Stelle.BuchstabeNr(label);
+      case "Nummer", "Nummern", "Nr.", "Nrn." -> new Stelle.NummerNr(label);
+      case "Buchstabe", "Buchstaben", "Buchst." -> new Stelle.BuchstabeNr(label);
       default -> null;
     };
   }
 
   private static Stelle.@Nullable Komponente mitLabel(Stelle.Komponente muster, String label) {
     return switch (muster) {
-      case Stelle.Paragraph p -> new Stelle.Paragraph(label);
+      case Stelle.Paragraph p -> new Stelle.Paragraph(label, p.sigel());
       case Stelle.AbsatzNr a -> new Stelle.AbsatzNr(label);
       case Stelle.SatzNr s -> new Stelle.SatzNr(label);
+      case Stelle.HalbsatzNr h -> new Stelle.HalbsatzNr(label);
       case Stelle.NummerNr n -> new Stelle.NummerNr(label);
       case Stelle.BuchstabeNr b -> new Stelle.BuchstabeNr(label);
       case Stelle.Gliederungseinheit g -> new Stelle.Gliederungseinheit(g.art(), label);
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/SuperskriptModus.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/SuperskriptModus.java
new file mode 100644
index 0000000..36f6338
--- /dev/null
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/SuperskriptModus.java
@@ -0,0 +1,15 @@
+package eu.mulk.aendggner.aenderung.parse;
+
+/**
+ * Behandlung hochgestellter Ziffern bei der PDF-Extraktion.
+ *
+ * <p>Bundesrecht ({@link #ENTFERNEN}): hochgestellte Fußnotenziffern sind Beiwerk und werden — wo
+ * sie als eigene Läufe erkennbar sind — verworfen. Bayerisches Landesrecht ({@link #BEHALTEN}):
+ * hochgestellte Ziffern sind amtliche Satznummern bzw. Fußnotenmarker und werden als
+ * Unicode-Superskripte (¹²³) in den Text übernommen, damit Stammgesetz und zitierter Änderungstext
+ * dieselbe kanonische Schreibweise tragen.
+ */
+public enum SuperskriptModus {
+  ENTFERNEN,
+  BEHALTEN
+}
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/TextBereiniger.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/TextBereiniger.java
index 8a7b6ae..4016256 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/TextBereiniger.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/TextBereiniger.java
@@ -98,6 +98,25 @@
       Pattern.compile(
           "^\\s*Deutscher Bundestag [–-] \\d+\\. Wahlperiode [–-] \\d+ [–-] Drucksache.*$");
 
+  // Bayerisches Gesetz- und Verordnungsblatt: Kolumnentitel mit Seitenzahl links oder rechts
+  // („… Nr. 6/2026 77“) bzw. auf geraden Seiten ohne Zwischenraum an die Jahreszahl geklebt
+  // („… Nr. 6/202676“).
+  private static final Pattern GVBL_KOPF =
+      Pattern.compile(
+          "^\\s*(?:\\d{1,4}\\s+)?Bayerisches Gesetz- und Verordnungsblatt Nr\\. \\d+/\\d{4}"
+              + "(?:\\s*\\d{1,4})?\\s*$");
+  // Bayerischer Landtag: laufender Seitenkopf („Drucksache 19/9707 Bayerischer Landtag
+  // 19. Wahlperiode Seite 2“) und Titelköpfe („19. Wahlperiode 28.01.2026  Drucksache 19/9707“,
+  // „Bayerischer Landtag“ + „19. Wahlperiode Drucksache 19/9707“).
+  private static final Pattern LANDTAG_SEITENKOPF =
+      Pattern.compile(
+          "^\\s*Drucksache \\d+/\\d+\\s+Bayerischer Landtag\\s+\\d+\\. Wahlperiode"
+              + "\\s+Seite \\d+\\s*$");
+  private static final Pattern LANDTAG_TITELKOPF =
+      Pattern.compile(
+          "^\\s*\\d+\\. Wahlperiode\\s+(?:\\d{2}\\.\\d{2}\\.\\d{4}\\s+)?Drucksache \\d+/\\d+\\s*$");
+  private static final Pattern LANDTAG_MARKE = Pattern.compile("^\\s*Bayerischer Landtag\\s*$");
+
   /** Konjunktionen, die typischerweise auf einen Suspensivstrich folgen („Wirk- und …“). */
   private static final Pattern KONJUNKTION =
       Pattern.compile("^(und|oder|sowie|bzw\\.|beziehungsweise)\\b.*");
@@ -116,6 +135,7 @@
       Pattern.compile(
           "^(?:(?:Artikel|Teil|Abschnitt|Unterabschnitt|Kapitel|Titel|Buch)\\s+\\d+[a-z]?"
               + "|§\\s*\\d+[a-z]?"
+              + "|Art\\.\\s*\\d+[a-z]?"
               + "|(?:Anlage|Anhang)(?:\\s+\\d+[a-z]?)?)$");
 
   /** Perzentil der Zeilenlängen, das als „volle Spaltenbreite“ gilt (siehe {@link #verbindeUmbrueche}). */
@@ -145,7 +165,10 @@
   private TextBereiniger() {}
 
   public static String bereinige(String rohText) {
-    var text = normalisiereAnfuehrungszeichen(rohText);
+    // Geschützte Leerzeichen (GVBl-Satz: „§  1“, „Abs.  2“) sind für Javas \s und
+    // String.strip unsichtbar — früh auf gewöhnliche Leerzeichen normalisieren.
+    var text = rohText.replace(' ', ' ').replace(' ', ' ');
+    text = normalisiereAnfuehrungszeichen(text);
     text = INVERTIERTES_ZITAT.matcher(text).replaceAll("$1„($2) ");
     text = INVERTIERTES_PARAGRAPH_ZITAT.matcher(text).replaceAll("$1„$2");
     text = INVERTIERTES_LISTEN_ZITAT.matcher(text).replaceAll("$1„$2 ");
@@ -258,7 +281,11 @@
         || SEITENMARKER.matcher(zeile).matches()
         || DRUCKSACHE_KOPF.matcher(zeile).matches()
         || BUNDESTAG_KOPF.matcher(zeile).matches()
-        || BUNDESRAT_KOPF.matcher(zeile).matches();
+        || BUNDESRAT_KOPF.matcher(zeile).matches()
+        || GVBL_KOPF.matcher(zeile).matches()
+        || LANDTAG_SEITENKOPF.matcher(zeile).matches()
+        || LANDTAG_TITELKOPF.matcher(zeile).matches()
+        || LANDTAG_MARKE.matcher(zeile).matches();
   }
 
   /**
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/ZitatExtraktor.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/ZitatExtraktor.java
index c24a1dc..e116056 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/ZitatExtraktor.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/ZitatExtraktor.java
@@ -62,6 +62,12 @@
     for (int i = 0; i < text.length(); i++) {
       char c = text.charAt(i);
       if (c == OEFFNEND) {
+        if (tiefe > 0 && istFortfuehrungszeichen(text, i)) {
+          // GVBl-Zitierweise: Jedes neugefasste Aufzählungsglied öffnet am Zeilenanfang erneut
+          // mit „, geschlossen wird nur einmal am Blockende. Das Fortführungszeichen ist
+          // Typografie, kein geschachteltes Zitat — es würde die Tiefenzählung entgleisen lassen.
+          continue;
+        }
         if (tiefe == 0) {
           aktuellesZitat.setLength(0);
         } else {
@@ -104,6 +110,27 @@
     return new Ergebnis(ausgabe.toString(), zitate, warnungen);
   }
 
+  // Aufzählungsmarker unmittelbar nach dem öffnenden Zeichen („2.“, „b)“, „aa)“).
+  private static final Pattern FORTFUEHRUNGS_MARKER =
+      Pattern.compile("^(?:\\d+[a-z]?\\.|[a-z]{1,3}\\))[ \\t]");
+
+  /**
+   * Wahr, wenn das öffnende Anführungszeichen an Position {@code i} ein Fortführungszeichen ist:
+   * Es steht am Zeilenanfang innerhalb eines offenen Zitats und ihm folgt unmittelbar ein
+   * Aufzählungsmarker.
+   */
+  private static boolean istFortfuehrungszeichen(String text, int i) {
+    int z = i;
+    while (z > 0 && (text.charAt(z - 1) == ' ' || text.charAt(z - 1) == '\t')) {
+      z--;
+    }
+    if (z != 0 && text.charAt(z - 1) != '\n') {
+      return false;
+    }
+    var fenster = text.substring(i + 1, Math.min(text.length(), i + 10));
+    return FORTFUEHRUNGS_MARKER.matcher(fenster).find();
+  }
+
   private static String kontextAuszug(String text, int position) {
     var von = Math.max(0, position - 60);
     var bis = Math.min(text.length(), position + 20);
diff --git a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
index ac4dbf2..b6bee1b 100644
--- a/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
+++ b/src/main/java/eu/mulk/aendggner/anwendung/BefehlAnwender.java
@@ -4,7 +4,9 @@
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Anfuegung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Aufhebung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Ersetzung;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.FussnotenAufhebung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.GliederungsUeberschriften;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.SatznummerierungStreichung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Neufassung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Sammelbefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.Streichung;
@@ -14,12 +16,15 @@
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.UnbekannterBefehl;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WoerterEinfuegung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortAnker;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautVoranstellung;
 import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuAbsatz;
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuSatz;
 import eu.mulk.aendggner.aenderung.Stelle;
 import eu.mulk.aendggner.gesetz.Absatz;
 import eu.mulk.aendggner.gesetz.Gesetz;
 import eu.mulk.aendggner.gesetz.Gliederung;
 import eu.mulk.aendggner.gesetz.Norm;
+import eu.mulk.aendggner.gesetz.Superskript;
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -128,6 +133,10 @@
         case Aufhebung a -> wendeAufhebungAn(normen, a);
         case Umnummerierung u -> wendeUmnummerierungAn(normen, u);
         case WortlautZuAbsatz w -> wendeWortlautZuAbsatzAn(normen, w);
+        case WortlautZuSatz w -> wendeWortlautZuSatzAn(normen, w);
+        case WortlautVoranstellung w -> wendeWortlautVoranstellungAn(normen, w);
+        case FussnotenAufhebung f -> wendeFussnotenAufhebungAn(normen, f);
+        case SatznummerierungStreichung s -> wendeSatznummerierungStreichungAn(normen, s);
         case GliederungsUeberschriften g ->
             wendeGliederungsUeberschriftenAn(normen, gliederungen, g);
         case Sammelbefehl s -> wendeSammelAn(normen, gliederungen, s);
@@ -318,6 +327,7 @@
     return bearbeiteText(
         normen,
         befehl,
+        ohneFussnoten(
         text -> {
           if (befehl.amEnde()) {
             var gestutzt = text.stripTrailing();
@@ -336,13 +346,14 @@
                 "„" + befehl.alt() + "“ kommt " + anzahl + "-mal vor (ohne „jeweils“ mehrdeutig).");
           }
           return TextErgebnis.ok(text.replace(befehl.alt(), befehl.neu()));
-        });
+        }));
   }
 
   private static AngewandteAenderung wendeStreichungAn(List<Norm> normen, Streichung befehl) {
     return bearbeiteText(
         normen,
         befehl,
+        ohneFussnoten(
         text -> {
           int anzahl = zaehleVorkommen(text, befehl.woerter());
           if (anzahl == 0) {
@@ -355,7 +366,7 @@
               text.replace(befehl.woerter(), "")
                   .replaceAll("  +", " ")
                   .replaceAll(" ([,;.])", "$1"));
-        });
+        }));
   }
 
   private static AngewandteAenderung wendeWoerterEinfuegungAn(
@@ -363,6 +374,7 @@
     return bearbeiteText(
         normen,
         befehl,
+        ohneFussnoten(
         text ->
             switch (befehl.anker()) {
               case WortAnker.NachWoertern nach -> {
@@ -405,7 +417,7 @@
                 }
                 yield TextErgebnis.ok(gestutzt + " " + befehl.woerter());
               }
-            });
+            }));
   }
 
   // --- Strukturoperationen -------------------------------------------------------------------
@@ -419,7 +431,7 @@
         return manuell(befehl, aufloesung.fehler());
       }
       var norm = normen.get(aufloesung.normIndex());
-      var titel = befehl.neuerText().replaceFirst("^§\\s*\\S+\\s+", "").strip();
+      var titel = befehl.neuerText().replaceFirst("^(?:§|Art\\.)\\s*\\S+\\s+", "").strip();
       normen.set(aufloesung.normIndex(), norm.mitTitel(titel));
       return angewandt(befehl, norm.enbez());
     }
@@ -671,7 +683,9 @@
           yield angewandt(befehl, neue.stream().map(Norm::enbez).toList());
         }
 
-        var enbezNeu = "§ " + befehl.bezeichnung();
+        var sigelNeu =
+            befehl.stelle().paragraph().map(Stelle.Paragraph::sigel).orElse("§");
+        var enbezNeu = sigelNeu + " " + befehl.bezeichnung();
         if (StellenAufloeser.normIndex(gesetzAus(normen), enbezNeu) >= 0) {
           yield manuell(befehl, enbezNeu + " existiert bereits im Stammgesetz.");
         }
@@ -783,7 +797,10 @@
       var absaetze = new ArrayList<>(norm.absaetze());
       for (int i = 0; i < absaetze.size(); i++) {
         if (nummer.equals(absaetze.get(i).nummer())) {
-          absaetze.set(i, new Absatz(null, absaetze.get(i).text()));
+          // Als weggefallen markieren (Nummer behalten) — konsistent mit der Aufhebung über einen
+          // Absatz-Lokator; eine etwaige Folge-Umnummerierung „Abs. N+1 wird Abs. N“ räumt den
+          // weggefallenen Absatz dann weg.
+          absaetze.set(i, new Absatz(nummer, "(weggefallen)"));
           normen.set(aufloesung.normIndex(), norm.mitAbsaetzen(absaetze));
           return angewandt(befehl, norm.enbez());
         }
@@ -845,8 +862,8 @@
       List<Norm> normen, Umnummerierung befehl) {
     // „§ 9a wird zu § 9.“ — Umbenennung einer ganzen Norm.
     if (nurParagraph(befehl.stelle()) && nurParagraph(befehl.neu())) {
-      var enbezAlt = "§ " + befehl.stelle().paragraph().get().nummer();
-      var enbezNeu = "§ " + befehl.neu().paragraph().get().nummer();
+      var enbezAlt = befehl.stelle().paragraph().get().enbez();
+      var enbezNeu = befehl.neu().paragraph().get().enbez();
       int idx = StellenAufloeser.normIndex(gesetzAus(normen), enbezAlt);
       if (idx < 0) {
         return manuell(befehl, enbezAlt + " existiert nicht im Gesetz.");
@@ -870,7 +887,12 @@
 
     var altAbsatz = befehl.stelle().absatz();
     var neuAbsatz = befehl.neu().absatz();
-    if (altAbsatz.isPresent() && neuAbsatz.isPresent()) {
+    // Nur wenn der Absatz selbst das Umnummerierungsziel ist — bei „Satz 5 wird Satz 4“ stammt
+    // eine etwaige Absatzangabe aus dem Kontextrahmen und der Satz-Zweig unten ist zuständig.
+    if (altAbsatz.isPresent()
+        && neuAbsatz.isPresent()
+        && feinsteIstAbsatz(befehl.stelle())
+        && feinsteIstAbsatz(befehl.neu())) {
       var ergebnis = StellenAufloeser.aufloese(gesetzAus(normen), befehl.stelle());
       if (ergebnis instanceof StellenAufloeser.Ergebnis.NichtGefunden nicht) {
         return manuell(befehl, nicht.begruendung());
@@ -878,15 +900,72 @@
       var fundstelle = ((StellenAufloeser.Ergebnis.Gefunden) ergebnis).fundstelle();
       var norm = normen.get(fundstelle.normIndex());
       var absaetze = new ArrayList<>(norm.absaetze());
-      var absatz = absaetze.get(fundstelle.absatzIndex());
-      absaetze.set(fundstelle.absatzIndex(), new Absatz(neuAbsatz.get().nummer(), absatz.text()));
+      int quelleIdx = fundstelle.absatzIndex();
+      var neueNummer = neuAbsatz.get().nummer();
+      // Ein leerer Platzhalter-Absatz mit der Zielnummer (weggefallen/gegenstandslos) wird durch die
+      // Umnummerierung überschrieben (analog zur Norm-Umnummerierung auf eine weggefallene Zielnorm).
+      for (int i = absaetze.size() - 1; i >= 0; i--) {
+        if (i != quelleIdx
+            && neueNummer.equals(absaetze.get(i).nummer())
+            && istLeererPlatzhalter(absaetze.get(i).text())) {
+          absaetze.remove(i);
+          if (i < quelleIdx) {
+            quelleIdx--;
+          }
+        }
+      }
+      absaetze.set(quelleIdx, new Absatz(neueNummer, absaetze.get(quelleIdx).text()));
       normen.set(fundstelle.normIndex(), norm.mitAbsaetzen(absaetze));
       return angewandt(befehl, norm.enbez());
     }
-    // Satz-Umnummerierungen ändern den Text nicht (Sätze sind unnummeriert).
+    // Satz-Umnummerierung: unnummerierte Sätze brauchen keine Textänderung; amtlich nummerierte
+    // (bayerisches Landesrecht, „Satz 5 wird Satz 4.“) erhalten die neue Satznummer im Text.
+    var altSatz = letzteKomponente(befehl.stelle(), Stelle.SatzNr.class);
+    var neuSatz = letzteKomponente(befehl.neu(), Stelle.SatzNr.class);
+    if (altSatz != null && neuSatz != null) {
+      var ergebnis = StellenAufloeser.aufloese(gesetzAus(normen), befehl.stelle());
+      if (ergebnis instanceof StellenAufloeser.Ergebnis.NichtGefunden nicht) {
+        return manuell(befehl, nicht.begruendung());
+      }
+      var fundstelle = ((StellenAufloeser.Ergebnis.Gefunden) ergebnis).fundstelle();
+      if (fundstelle.bereich() != null && fundstelle.absatzIndex() != null) {
+        var norm = normen.get(fundstelle.normIndex());
+        var absaetze = new ArrayList<>(norm.absaetze());
+        var absatz = absaetze.get(fundstelle.absatzIndex());
+        var text = absatz.text();
+        var marker = Superskript.LAUF.matcher(text).region(fundstelle.bereich().von(), fundstelle.bereich().bis());
+        if (marker.lookingAt()
+            && Superskript.istSatzanfang(text, marker.start(), marker.end())) {
+          var neuerText =
+              text.substring(0, marker.start())
+                  + Superskript.zuSuperskript(neuSatz.nummer())
+                  + text.substring(marker.end());
+          absaetze.set(fundstelle.absatzIndex(), absatz.mitText(neuerText));
+          normen.set(fundstelle.normIndex(), norm.mitAbsaetzen(absaetze));
+          return angewandt(befehl, norm.enbez());
+        }
+      }
+    }
     return angewandt(befehl, "(keine Textänderung nötig)");
   }
 
+  /** Ein leerer Platzhalter-Absatz ohne Inhalt („(weggefallen)“, „(gegenstandslos)“). */
+  private static boolean istLeererPlatzhalter(String text) {
+    var t = text.strip();
+    return t.equals("(weggefallen)") || t.equals("(gegenstandslos)");
+  }
+
+  private static <K extends Stelle.Komponente> @Nullable K letzteKomponente(
+      Stelle stelle, Class<K> art) {
+    K letzte = null;
+    for (var komponente : stelle.komponenten()) {
+      if (art.isInstance(komponente)) {
+        letzte = art.cast(komponente);
+      }
+    }
+    return letzte;
+  }
+
   private static AngewandteAenderung wendeWortlautZuAbsatzAn(
       List<Norm> normen, WortlautZuAbsatz befehl) {
     var aufloesung = loeseNormAuf(normen, befehl.stelle());
@@ -894,6 +973,18 @@
       return manuell(befehl, aufloesung.fehler());
     }
     var norm = normen.get(aufloesung.normIndex());
+    // Steht genau ein unnummerierter Absatz zwischen nummerierten (bayerische Folge „Dem Wortlaut
+    // werden … Abs. 1 bis 4 vorangestellt“ → „Der bisherige Wortlaut wird Abs. 5“), erhält nur
+    // dieser die Nummer. Sind alle Absätze unnummeriert, wird der Gesamtwortlaut zu einem Absatz.
+    var unnummerierte =
+        norm.absaetze().stream().filter(a -> a.nummer() == null).toList();
+    if (unnummerierte.size() == 1 && norm.absaetze().size() > 1) {
+      var absaetze = new ArrayList<>(norm.absaetze());
+      int idx = absaetze.indexOf(unnummerierte.get(0));
+      absaetze.set(idx, new Absatz(befehl.nummer(), unnummerierte.get(0).text()));
+      normen.set(aufloesung.normIndex(), norm.mitAbsaetzen(absaetze));
+      return angewandt(befehl, norm.enbez());
+    }
     var sb = new StringBuilder();
     for (var absatz : norm.absaetze()) {
       if (sb.length() > 0) {
@@ -907,6 +998,109 @@
     return angewandt(befehl, norm.enbez());
   }
 
+  /** „Der Wortlaut wird Satz 1.“ — der Zieltext erhält die amtliche Satznummer als Superskript. */
+  private static AngewandteAenderung wendeWortlautZuSatzAn(
+      List<Norm> normen, WortlautZuSatz befehl) {
+    var ergebnis = StellenAufloeser.aufloese(gesetzAus(normen), befehl.stelle());
+    if (ergebnis instanceof StellenAufloeser.Ergebnis.NichtGefunden nicht) {
+      return manuell(befehl, nicht.begruendung());
+    }
+    var fundstelle = ((StellenAufloeser.Ergebnis.Gefunden) ergebnis).fundstelle();
+    var norm = normen.get(fundstelle.normIndex());
+    Integer absatzIndex = fundstelle.absatzIndex();
+    if (absatzIndex == null) {
+      if (norm.absaetze().size() != 1) {
+        return manuell(
+            befehl, norm.enbez() + " hat " + norm.absaetze().size() + " Absätze; Ziel unklar.");
+      }
+      absatzIndex = 0;
+    }
+    var absaetze = new ArrayList<>(norm.absaetze());
+    var absatz = absaetze.get(absatzIndex);
+    var marke = Superskript.zuSuperskript(befehl.nummer());
+    if (!absatz.text().startsWith(marke)) {
+      absaetze.set(absatzIndex, absatz.mitText(marke + absatz.text()));
+      normen.set(fundstelle.normIndex(), norm.mitAbsaetzen(absaetze));
+    }
+    return angewandt(befehl, norm.enbez());
+  }
+
+  /** „Dem Wortlaut werden die folgenden Abs. 1 bis 4 vorangestellt: „…““ */
+  private static AngewandteAenderung wendeWortlautVoranstellungAn(
+      List<Norm> normen, WortlautVoranstellung befehl) {
+    var aufloesung = loeseNormAuf(normen, befehl.stelle());
+    if (aufloesung.fehler() != null) {
+      return manuell(befehl, aufloesung.fehler());
+    }
+    var neue = parseAbsaetze(befehl.text());
+    if (neue.isEmpty()) {
+      return manuell(befehl, "Im Zitat wurde kein Absatz erkannt.");
+    }
+    var norm = normen.get(aufloesung.normIndex());
+    var absaetze = new ArrayList<>(neue);
+    absaetze.addAll(norm.absaetze());
+    normen.set(aufloesung.normIndex(), norm.mitAbsaetzen(absaetze));
+    return angewandt(befehl, norm.enbez());
+  }
+
+  /** „Fußnote 1 wird aufgehoben.“ — entfernt Fußnotenzeile und Inline-Marker in der Kontextnorm. */
+  private static AngewandteAenderung wendeFussnotenAufhebungAn(
+      List<Norm> normen, FussnotenAufhebung befehl) {
+    var aufloesung = loeseNormAuf(normen, befehl.stelle());
+    if (aufloesung.fehler() != null) {
+      return manuell(befehl, aufloesung.fehler());
+    }
+    var norm = normen.get(aufloesung.normIndex());
+    var absaetze = new ArrayList<>(norm.absaetze());
+    var fehlend = new ArrayList<String>();
+    for (var nummer : befehl.nummern()) {
+      var marke = Superskript.zuSuperskript(nummer) + ")";
+      var zeilenMuster =
+          Pattern.compile("(?m)^" + Pattern.quote(marke) + "\\s*\\[Amtl\\. Anm\\.:\\].*(?:\n|$)");
+      boolean gefunden = false;
+      for (int i = 0; i < absaetze.size(); i++) {
+        var text = absaetze.get(i).text();
+        var ohneZeile = zeilenMuster.matcher(text).replaceAll("");
+        var ohneMarker = ohneZeile.replace(marke, "");
+        if (!ohneMarker.equals(text)) {
+          absaetze.set(i, absaetze.get(i).mitText(ohneMarker.stripTrailing()));
+          gefunden = true;
+        }
+      }
+      if (!gefunden) {
+        fehlend.add(nummer);
+      }
+    }
+    if (!fehlend.isEmpty()) {
+      return manuell(
+          befehl,
+          "Fußnote "
+              + String.join(", ", fehlend)
+              + " kommt in "
+              + norm.enbez()
+              + " nicht vor.");
+    }
+    normen.set(aufloesung.normIndex(), norm.mitAbsaetzen(absaetze));
+    return angewandt(befehl, norm.enbez());
+  }
+
+  /** „In Satz 1 wird die Satznummerierung „1“ gestrichen.“ */
+  private static AngewandteAenderung wendeSatznummerierungStreichungAn(
+      List<Norm> normen, SatznummerierungStreichung befehl) {
+    return bearbeiteBereich(
+        normen,
+        befehl,
+        (text, bereich) -> {
+          var marke = Superskript.zuSuperskript(befehl.nummer());
+          if (!text.startsWith(marke, bereich.von())) {
+            return TextErgebnis.fehler(
+                "Die Satznummerierung „" + befehl.nummer() + "“ steht nicht am Anfang des Ziels.");
+          }
+          return TextErgebnis.ok(
+              text.substring(0, bereich.von()) + text.substring(bereich.von() + marke.length()));
+        });
+  }
+
   /**
    * Ein Mehrfachziel-Befehl („In A und B wird jeweils …“): wendet jeden Teilbefehl nacheinander an
    * (jeder mutiert den fortlaufenden Zwischenstand) und fasst sie zu einem Protokolleintrag
@@ -949,6 +1143,28 @@
     TextErgebnis wende(String text);
   }
 
+  // Fußnoten-Definitionszeile am Zeilenanfang („⁶) [Amtl. Anm.:] …“), die dem tragenden Absatz
+  // anhängt. Für wortweise Operationen (Streichen/Ersetzen/Einfügen) ist sie kein Inhalt: der
+  // eingebettete Marker „Gesetzbuchs²)“ soll getroffen werden, der gleichlautende Definitionskopf
+  // „²)“ nicht. Fußnoten werden daher vor der Operation abgetrennt und danach unverändert
+  // wieder angehängt (ihre eigene Aufhebung läuft über FussnotenAufhebung).
+  private static final Pattern FUSSNOTEN_DEFINITION = Pattern.compile("(?m)^[⁰¹²³⁴⁵⁶⁷⁸⁹]+\\)");
+
+  private static TextOperation ohneFussnoten(TextOperation operation) {
+    return text -> {
+      var m = FUSSNOTEN_DEFINITION.matcher(text);
+      if (!m.find()) {
+        return operation.wende(text);
+      }
+      int grenze = m.start();
+      var ergebnis = operation.wende(text.substring(0, grenze));
+      if (ergebnis.fehler() != null) {
+        return ergebnis;
+      }
+      return TextErgebnis.ok(ergebnis.text() + text.substring(grenze));
+    };
+  }
+
   private interface BereichsOperation {
     TextErgebnis wende(String text, SatzTeiler.SatzBereich bereich);
   }
@@ -1067,7 +1283,7 @@
   private static NormAufloesung loeseNormAuf(List<Norm> normen, Stelle stelle) {
     String enbez;
     if (stelle.paragraph().isPresent()) {
-      enbez = "§ " + stelle.paragraph().get().nummer();
+      enbez = stelle.paragraph().get().enbez();
     } else if (stelle.anlagenEnbez().isPresent()) {
       enbez = stelle.anlagenEnbez().get();
     } else {
@@ -1097,6 +1313,7 @@
         .noneMatch(
             k ->
                 k instanceof Stelle.SatzNr
+                    || k instanceof Stelle.HalbsatzNr
                     || k instanceof Stelle.NummerNr
                     || k instanceof Stelle.BuchstabeNr);
   }
@@ -1154,7 +1371,7 @@
   // die Untergliederungs- und Verbindungswörter aus, sodass an solchen Stellen nicht getrennt wird.
   private static final Pattern PARAGRAPH_UEBERSCHRIFT =
       Pattern.compile(
-          "(?=§\\s*\\d+[a-z]?\\s+"
+          "(?=(?:§|Art\\.)\\s*\\d+[a-z]?\\s+"
               + "(?!Absatz|Absätze|Abs|Satz|Sätze|Nummer|Nummern|Nr|Buchstabe|Buchstaben|Buchst"
               + "|und|bis|oder|sowie|des|der|dieses|genannten)"
               + "\\p{Lu})");
@@ -1167,11 +1384,11 @@
     var normen = new ArrayList<Norm>();
     for (var stueck : PARAGRAPH_UEBERSCHRIFT.split(block.strip())) {
       var s = stueck.strip();
-      var m = Pattern.compile("^§\\s*(\\d+[a-z]?)\\b").matcher(s);
+      var m = Pattern.compile("^(§|Art\\.)\\s*(\\d+[a-z]?)\\b").matcher(s);
       if (s.isEmpty() || !m.find()) {
         continue;
       }
-      var enbez = "§ " + m.group(1);
+      var enbez = m.group(1) + " " + m.group(2);
       normen.add(parseNorm(s, enbez, new Norm(enbez, null, gliederung, List.of(), false)));
     }
     return normen;
@@ -1188,7 +1405,7 @@
     if (erster >= 0) {
       var kopf = text.substring(0, erster).strip();
       if (!kopf.isEmpty()) {
-        titel = kopf.replaceFirst("^§\\s*\\S+\\s*", "").replaceAll("\\s+", " ").strip();
+        titel = kopf.replaceFirst("^(?:§|Art\\.)\\s*\\S+\\s*", "").replaceAll("\\s+", " ").strip();
         if (titel.isEmpty()) {
           titel = vorlage.titel();
         }
@@ -1201,7 +1418,7 @@
     // Steht „§ N“ allein auf der ersten Zeile, ist die zweite Zeile die Überschrift und der Rest
     // der Normtext.
     var zeilen = text.lines().map(String::strip).filter(z -> !z.isEmpty()).toList();
-    if (zeilen.size() >= 3 && zeilen.get(0).matches("§\\s*\\d+[a-z]?")) {
+    if (zeilen.size() >= 3 && zeilen.get(0).matches("(?:§|Art\\.)\\s*\\d+[a-z]?")) {
       titel = zeilen.get(1);
       var rest = String.join("\n", zeilen.subList(2, zeilen.size()));
       return new Norm(
@@ -1212,7 +1429,7 @@
           false);
     }
     // Fallback: gesamter Text (ohne „§ N“-Präfix) als unnummerierter Absatz, Titel unverändert.
-    var inhalt = text.replaceFirst("^§\\s*\\S+\\s*", "");
+    var inhalt = text.replaceFirst("^(?:§|Art\\.)\\s*\\S+\\s*", "");
     return new Norm(
         enbez,
         titel,
diff --git a/src/main/java/eu/mulk/aendggner/anwendung/InhaltsuebersichtAnwender.java b/src/main/java/eu/mulk/aendggner/anwendung/InhaltsuebersichtAnwender.java
index 4fb91b0..e9f84b6 100644
--- a/src/main/java/eu/mulk/aendggner/anwendung/InhaltsuebersichtAnwender.java
+++ b/src/main/java/eu/mulk/aendggner/anwendung/InhaltsuebersichtAnwender.java
@@ -229,7 +229,8 @@
   private static Pattern zeilenMuster(Stelle.Komponente ziel) {
     return switch (ziel) {
       case Stelle.Paragraph p ->
-          Pattern.compile("^§\\s*" + Pattern.quote(p.nummer()) + "(?![0-9a-z])");
+          Pattern.compile(
+              "^" + Pattern.quote(p.sigel()) + "\\s*" + Pattern.quote(p.nummer()) + "(?![0-9a-z])");
       case Stelle.Gliederungseinheit g -> {
         if (g.nummer().isEmpty()) {
           yield Pattern.compile("^" + Pattern.quote(g.art()) + "\\b");
@@ -279,7 +280,7 @@
       var m =
           Pattern.compile(
                   "^((?:Teil|Abschnitt|Unterabschnitt|Kapitel|Buch)\\s+\\d+[a-z]?|Anhang"
-                      + "|§\\s*\\d+[a-z]*)\\s*(.*)$")
+                      + "|(?:§|Art\\.)\\s*\\d+[a-z]*)\\s*(.*)$")
               .matcher(s);
       if (m.matches() && !m.group(2).isEmpty()) {
         zeilen.add(m.group(1) + " | " + m.group(2));
@@ -301,7 +302,7 @@
   // Zeilenanfänge einer Inhaltsübersicht: §-Angaben (nicht Querverweise) und Gliederungsmarken.
   private static final Pattern UEBERSICHT_MARKE =
       Pattern.compile(
-          "(?=§\\s*\\d+[a-z]?\\s+"
+          "(?=(?:§|Art\\.)\\s*\\d+[a-z]?\\s+"
               + "(?!Absatz|Absätze|Abs|Satz|Sätze|Nummer|Nummern|Nr|Buchstabe|Buchstaben"
               + "|und|bis|oder|sowie|des|der|dieses)"
               + "(?:\\(|\\p{Lu})"
@@ -315,13 +316,13 @@
   private static List<String> angabenZeilen(String zitat, String einrueckung) {
     var flach = zitat.strip().replaceAll("\\s+", " ");
     var zeilen = new ArrayList<String>();
-    if (flach.startsWith("§")) {
+    if (flach.startsWith("§") || flach.startsWith("Art.")) {
       for (var stueck : PARAGRAPH_ANGABE.split(flach)) {
         var s = stueck.strip();
         if (s.isEmpty()) {
           continue;
         }
-        var m = Pattern.compile("^(§\\s*\\d+[a-z]*)\\s*(.*)$").matcher(s);
+        var m = Pattern.compile("^((?:§|Art\\.)\\s*\\d+[a-z]*)\\s*(.*)$").matcher(s);
         if (m.matches() && !m.group(2).isEmpty()) {
           zeilen.add(einrueckung + m.group(1) + " | " + m.group(2));
         } else {
@@ -339,7 +340,7 @@
   // trennen nicht (nach ihnen folgt ein Kleinwort oder eine Strukturangabe statt eines Titels).
   private static final Pattern PARAGRAPH_ANGABE =
       Pattern.compile(
-          "(?=§\\s*\\d+[a-z]?\\s+"
+          "(?=(?:§|Art\\.)\\s*\\d+[a-z]?\\s+"
               + "(?!Absatz|Absätze|Abs|Satz|Sätze|Nummer|Nummern|Nr|Buchstabe|Buchstaben"
               + "|und|bis|oder|sowie|des|der|dieses)"
               + "(?:\\(|\\p{Lu}))");
@@ -362,7 +363,7 @@
 
   private static String anzeige(Stelle.Komponente ziel) {
     return switch (ziel) {
-      case Stelle.Paragraph p -> "§ " + p.nummer();
+      case Stelle.Paragraph p -> p.enbez();
       case Stelle.Gliederungseinheit g -> g.bezeichnung();
       default -> ziel.toString();
     };
diff --git a/src/main/java/eu/mulk/aendggner/anwendung/SatzTeiler.java b/src/main/java/eu/mulk/aendggner/anwendung/SatzTeiler.java
index a15aafa..6df6ea5 100644
--- a/src/main/java/eu/mulk/aendggner/anwendung/SatzTeiler.java
+++ b/src/main/java/eu/mulk/aendggner/anwendung/SatzTeiler.java
@@ -1,13 +1,18 @@
 package eu.mulk.aendggner.anwendung;
 
+import eu.mulk.aendggner.gesetz.Superskript;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Zerlegt einen Absatztext in Sätze im Rechtssinne, mit einer Stoppliste für juristische
  * Abkürzungen und Datumsangaben („Abs.“, „31. März 2021“).
+ *
+ * <p>Trägt der Text amtliche Satznummern als Unicode-Superskripte (bayerisches Landesrecht,
+ * „¹Die freilebende Tierwelt …“), wird exakt an diesen geteilt statt heuristisch.
  */
 public final class SatzTeiler {
 
@@ -63,6 +68,10 @@
   private SatzTeiler() {}
 
   public static List<SatzBereich> teile(String text) {
+    var nummeriert = teileAnSatznummern(text);
+    if (nummeriert != null) {
+      return nummeriert;
+    }
     var bereiche = new ArrayList<SatzBereich>();
     var matcher = SATZENDE.matcher(text);
     int start = 0;
@@ -85,6 +94,55 @@
     return teile(text).stream().map(b -> text.substring(b.von(), b.bis()).strip()).toList();
   }
 
+  /**
+   * Teilt an amtlichen Satznummern (Superskript-Läufe an Satzanfängen); {@code null}, wenn der Text
+   * keine trägt. Text vor der ersten Satznummer (und Fußnotenzeilen nach dem letzten Satz) bleibt
+   * dem jeweils angrenzenden Satz zugeschlagen.
+   */
+  private static @Nullable List<SatzBereich> teileAnSatznummern(String text) {
+    // Satzgrenzen: stets der Textanfang (Satz 1 samt etwaigem Vorspann vor „¹“) plus die Position
+    // jeder Satznummer ab „²“. Eine allein stehende Nummer ≥ 2 (weil Satz 1 unnummeriert ist oder
+    // seine Nummer zuvor gestrichen wurde, „Verboten … ²Art. 33 …“) bildet so eine eigene Grenze.
+    var matcher = Superskript.LAUF.matcher(text);
+    var grenzen = new ArrayList<Integer>();
+    grenzen.add(0);
+    boolean gefunden = false;
+    while (matcher.find()) {
+      if (Superskript.istSatzanfang(text, matcher.start(), matcher.end())) {
+        gefunden = true;
+        int nummer = Integer.parseInt(Superskript.zuZahl(matcher.group()));
+        if (nummer >= 2 && matcher.start() > 0) {
+          grenzen.add(matcher.start());
+        }
+      }
+    }
+    if (!gefunden) {
+      return null;
+    }
+    var bereiche = new ArrayList<SatzBereich>();
+    for (int k = 0; k < grenzen.size(); k++) {
+      int von = grenzen.get(k);
+      int bis = k + 1 < grenzen.size() ? grenzen.get(k + 1) : text.length();
+      while (bis > von && Character.isWhitespace(text.charAt(bis - 1))) {
+        bis--;
+      }
+      if (bis > von) {
+        bereiche.add(new SatzBereich(von, bis));
+      }
+    }
+    return bereiche;
+  }
+
+  /** Die amtliche Satznummer am Anfang des Satztexts; {@code null}, wenn er keine trägt. */
+  public static @Nullable Integer nummerVonSatz(String satzText) {
+    var s = satzText.stripLeading();
+    var matcher = Superskript.LAUF.matcher(s);
+    if (!matcher.lookingAt() || !Superskript.istSatzanfang(s, 0, matcher.end())) {
+      return null;
+    }
+    return Integer.parseInt(Superskript.zuZahl(matcher.group()));
+  }
+
   private static boolean istAbkuerzung(String text, int punktPosition) {
     var wort = wortVor(text, punktPosition);
     return ABKUERZUNGEN.contains(wort);
diff --git a/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java b/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java
index 9501f24..dd8409e 100644
--- a/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java
+++ b/src/main/java/eu/mulk/aendggner/anwendung/StellenAufloeser.java
@@ -39,7 +39,7 @@
     if (stelle.betrifftInhaltsuebersicht()) {
       enbez = "Inhaltsübersicht";
     } else if (stelle.paragraph().isPresent()) {
-      enbez = "§ " + stelle.paragraph().get().nummer();
+      enbez = stelle.paragraph().get().enbez();
     } else if (stelle.anlagenEnbez().isPresent()) {
       enbez = stelle.anlagenEnbez().get();
     } else {
@@ -136,6 +136,7 @@
         .anyMatch(
             k ->
                 k instanceof Stelle.SatzNr
+                    || k instanceof Stelle.HalbsatzNr
                     || k instanceof Stelle.NummerNr
                     || k instanceof Stelle.BuchstabeNr);
   }
@@ -174,15 +175,76 @@
     }
     for (var komponente : stelle.komponenten()) {
       if (komponente instanceof Stelle.SatzNr satz) {
-        int index = Integer.parseInt(satz.nummer().replaceAll("[a-z]$", "")) - 1;
+        int nummer = Integer.parseInt(satz.nummer().replaceAll("[a-z]$", ""));
         var saetze = SatzTeiler.teile(text);
-        return index >= 0 && index < saetze.size() ? saetze.get(index) : null;
+        var satzBereich = satzBereich(text, nummer, saetze);
+        return satzBereich == null ? null : halbsatzBereich(text, stelle, satzBereich);
       }
     }
+    // Halbsatz ohne Satzangabe („in Halbsatz 1“ im Rahmen eines Satzes bzw. Absatzes).
+    if (stelle.komponenten().stream().anyMatch(k -> k instanceof Stelle.HalbsatzNr)) {
+      return halbsatzBereich(text, stelle, new SatzTeiler.SatzBereich(0, text.length()));
+    }
     return null;
   }
 
   /**
+   * Der Bereich des Satzes mit der gegebenen Nummer. Amtlich nummerierte Sätze (bayerisches
+   * Landesrecht) werden nach Satznummer statt Position aufgelöst — nach Streichungen kann die
+   * Zählung von der Position abweichen. Trägt mindestens ein Satz eine Nummer, entscheidet allein
+   * das Label (kein Positions-Fallback, der einen falsch nummerierten Satz greifen könnte).
+   */
+  private static SatzTeiler.@Nullable SatzBereich satzBereich(
+      String text, int nummer, List<SatzTeiler.SatzBereich> saetze) {
+    boolean nummeriert = false;
+    for (var kandidat : saetze) {
+      var label = SatzTeiler.nummerVonSatz(text.substring(kandidat.von(), kandidat.bis()));
+      if (label != null && label == nummer) {
+        return kandidat;
+      }
+      nummeriert |= label != null;
+    }
+    if (nummeriert) {
+      return null;
+    }
+    int index = nummer - 1;
+    return index >= 0 && index < saetze.size() ? saetze.get(index) : null;
+  }
+
+  /**
+   * Verfeinert den Bereich um eine etwaige Halbsatz-Angabe: Halbsatz 1 reicht bis zum (ersten)
+   * Semikolon, Halbsatz 2 beginnt dahinter. Ohne Semikolon ist die Angabe nicht auflösbar
+   * (konservativ: {@code null} → manuell prüfen).
+   */
+  private static SatzTeiler.@Nullable SatzBereich halbsatzBereich(
+      String text, Stelle stelle, SatzTeiler.SatzBereich bereich) {
+    Stelle.HalbsatzNr halbsatz = null;
+    for (var komponente : stelle.komponenten()) {
+      if (komponente instanceof Stelle.HalbsatzNr h) {
+        halbsatz = h;
+      }
+    }
+    if (halbsatz == null) {
+      return bereich;
+    }
+    int semikolon = text.indexOf(';', bereich.von());
+    if (semikolon < 0 || semikolon >= bereich.bis()) {
+      return null;
+    }
+    return switch (halbsatz.nummer()) {
+      case "1" -> new SatzTeiler.SatzBereich(bereich.von(), semikolon);
+      case "2" -> {
+        int start = semikolon + 1;
+        while (start < bereich.bis() && Character.isWhitespace(text.charAt(start))) {
+          start++;
+        }
+        yield new SatzTeiler.SatzBereich(start, bereich.bis());
+      }
+      default -> null;
+    };
+  }
+
+  /**
    * Findet die (im Suchbereich eindeutige) Aufzählungszeile, die mit dem gegebenen Label beginnt,
    * und dehnt den Bereich auf die tiefer eingerückten Kindzeilen der Einheit aus.
    */
diff --git a/src/main/java/eu/mulk/aendggner/gesetz/Superskript.java b/src/main/java/eu/mulk/aendggner/gesetz/Superskript.java
new file mode 100644
index 0000000..777fe35
--- /dev/null
+++ b/src/main/java/eu/mulk/aendggner/gesetz/Superskript.java
@@ -0,0 +1,73 @@
+package eu.mulk.aendggner.gesetz;
+
+import java.util.regex.Pattern;
+
+/**
+ * Hochgestellte Ziffern (¹²³…), wie sie das bayerische Landesrecht als amtliche Satznummern und
+ * Fußnotenmarker führt. Die kanonische Textform des ÄndGgner stellt solche Ziffern als
+ * Unicode-Superskripte dar, damit Stammgesetz und zitierter Änderungstext dieselbe Schreibweise
+ * tragen und Befehle wie „In Satz 1 wird die Satznummerierung „1“ gestrichen“ anwendbar sind.
+ */
+public final class Superskript {
+
+  private static final String NORMAL = "0123456789";
+  private static final String HOCH = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+
+  /** Ein Lauf hochgestellter Ziffern. */
+  public static final Pattern LAUF = Pattern.compile("[" + HOCH + "]+");
+
+  private Superskript() {}
+
+  /** Wahr, wenn {@code c} eine hochgestellte Ziffer ist. */
+  public static boolean istHochgestellt(char c) {
+    return HOCH.indexOf(c) >= 0;
+  }
+
+  /** „12“ → „¹²“. Nicht-Ziffern bleiben unverändert. */
+  public static String zuSuperskript(String ziffern) {
+    var sb = new StringBuilder(ziffern.length());
+    for (int i = 0; i < ziffern.length(); i++) {
+      var c = ziffern.charAt(i);
+      int idx = NORMAL.indexOf(c);
+      sb.append(idx >= 0 ? HOCH.charAt(idx) : c);
+    }
+    return sb.toString();
+  }
+
+  /** „¹²“ → „12“. Nicht-Superskripte bleiben unverändert. */
+  public static String zuZahl(String superskript) {
+    var sb = new StringBuilder(superskript.length());
+    for (int i = 0; i < superskript.length(); i++) {
+      var c = superskript.charAt(i);
+      int idx = HOCH.indexOf(c);
+      sb.append(idx >= 0 ? NORMAL.charAt(idx) : c);
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Wahr, wenn der Superskript-Lauf {@code [start, ende)} in {@code text} eine amtliche Satznummer
+   * am Satzanfang ist — im Unterschied zum Fußnotenmarker, der einem Wort anhängt und auf den eine
+   * schließende Klammer folgt („Enteignung⁶)“).
+   */
+  public static boolean istSatzanfang(String text, int start, int ende) {
+    if (ende < text.length() && text.charAt(ende) == ')') {
+      return false; // Fußnotenmarker „⁶)“
+    }
+    if (start > 0) {
+      var davor = text.charAt(start - 1);
+      if (!Character.isWhitespace(davor) && davor != '„' && davor != '(') {
+        return false; // hängt einem Wort an → Fußnotenmarker ohne Klammer
+      }
+    }
+    // Nach der Satznummer beginnt der Satz: Buchstabe, Paragraphzeichen, öffnendes Zitat oder
+    // öffnende Klammer (z. B. „³§ 23 des Gesetzes …“).
+    return ende < text.length()
+        && (Character.isLetter(text.charAt(ende))
+            || text.charAt(ende) == '§'
+            || text.charAt(ende) == '„'
+            || text.charAt(ende) == '»'
+            || text.charAt(ende) == '"'
+            || text.charAt(ende) == '(');
+  }
+}
diff --git a/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtLoader.java b/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtLoader.java
new file mode 100644
index 0000000..4150af4
--- /dev/null
+++ b/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtLoader.java
@@ -0,0 +1,58 @@
+package eu.mulk.aendggner.gesetz.bayern;
+
+import eu.mulk.aendggner.aenderung.parse.PatchTextExtraktor;
+import eu.mulk.aendggner.aenderung.parse.SuperskriptModus;
+import eu.mulk.aendggner.aenderung.parse.TextBereiniger;
+import eu.mulk.aendggner.gesetz.Gesetz;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.apache.tika.Tika;
+import org.jboss.logging.Logger;
+
+/**
+ * Liest ein Stammgesetz des bayerischen Landesrechts aus der konsolidierten Fassung von
+ * gesetze-bayern.de — als PDF oder als kanonischer Klartext.
+ *
+ * <p>PDFs durchlaufen dieselbe Aufbereitung wie Änderungsgesetze (Fontgrößen-Filter mit
+ * Superskript-Erhalt, Textbereinigung); der bereinigte Lineartext ist zugleich das dokumentierte
+ * Klartext-Format (siehe {@link BayRechtTextParser}): Wo die PDF-Extraktion versagt oder nur eine
+ * andere Quelle verfügbar ist (etwa eine archivierte HTML-Fassung), kann der Text von Hand
+ * aufbereitet und als {@code .txt} eingespeist werden. Amtliche Satznummern und Fußnotenmarker
+ * stehen dabei als Unicode-Superskripte im Text (¹Die freilebende Tierwelt …, Enteignung⁶)).
+ */
+public final class BayRechtLoader {
+
+  private static final Logger log = Logger.getLogger(BayRechtLoader.class);
+
+  private final Tika tika = new Tika();
+
+  public Gesetz load(Path datei) throws IOException {
+    var mimeType = tika.detect(datei);
+    log.infof("Stammgesetz %s hat Typ %s.", datei, mimeType);
+
+    var text =
+        switch (mimeType) {
+          case "application/pdf" ->
+              nachSatzendeGetrennteNormkoepfe(
+                  TextBereiniger.bereinige(
+                      new PatchTextExtraktor(SuperskriptModus.BEHALTEN).extrahiere(datei)));
+          case "text/plain" -> Files.readString(datei, StandardCharsets.UTF_8);
+          default ->
+              throw new IOException(
+                  "Nicht unterstützter Dateityp %s für Stammgesetz %s (unterstützt: PDF, Klartext)"
+                      .formatted(mimeType, datei));
+        };
+    return BayRechtTextParser.parse(text);
+  }
+
+  /**
+   * Stellt einen vom Zeilen-Reflow an das Satzende der Vornorm geklebten Normkopf („… verlangen.
+   * Art. 17  Jagderlaubnis“) wieder auf eine eigene Zeile. Das doppelte Leerzeichen zwischen
+   * Artikelnummer und Titel unterscheidet den Normkopf von gewöhnlichen Querverweisen.
+   */
+  private static String nachSatzendeGetrennteNormkoepfe(String text) {
+    return text.replaceAll("(?<=[.“?!])[ \\t]+(?=Art\\.\\s\\d+[a-z]?[ \\t]{2})", "\n");
+  }
+}
diff --git a/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParser.java b/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParser.java
new file mode 100644
index 0000000..0744086
--- /dev/null
+++ b/src/main/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParser.java
@@ -0,0 +1,250 @@
+package eu.mulk.aendggner.gesetz.bayern;
+
+import eu.mulk.aendggner.gesetz.Absatz;
+import eu.mulk.aendggner.gesetz.Gesetz;
+import eu.mulk.aendggner.gesetz.Gliederung;
+import eu.mulk.aendggner.gesetz.Norm;
+import eu.mulk.aendggner.gesetz.Superskript;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+import org.jspecify.annotations.Nullable;
+
+/**
+ * Parst den kanonischen Lineartext eines bayerischen Stammgesetzes (gesetze-bayern.de) zu einem
+ * {@link Gesetz}. Das Layout entspricht der {@code --extract-only}-Ausgabe der konsolidierten
+ * PDF-Fassung (siehe {@link BayRechtLoader}):
+ *
+ * <pre>
+ * Bayerisches Jagdgesetz          ← Langtitel
+ * (BayJG)                         ← Juris-Abkürzung
+ * Vom 13. Oktober 1978            ← Datumszeile (übersprungen)
+ * (BayRS V S. 595)                ← Fundstellen (übersprungen)
+ * BayRS 792-1-W
+ * Vollzitat nach RedR: …          ← übersprungen (ggf. mehrzeilig)
+ * I. Abschnitt Grundsätze         ← Gliederungs-Überschrift
+ * 1. Allgemeine Vorschriften      ← nummerierte Unter-Überschrift (vor einem Art.-Kopf)
+ * Art. 1  Gesetzeszweck           ← Normkopf; „Art. 60  (aufgehoben)“ → weggefallen
+ * (1) ¹Die freilebende Tierwelt … ← Absätze mit amtlichen Satznummern als Superskript
+ * ⁶) [Amtl. Anm.:] …              ← Fußnotenzeile, verbleibt im Text des tragenden Absatzes
+ * </pre>
+ */
+final class BayRechtTextParser {
+
+  private static final Pattern ABSATZ_MARKER = Pattern.compile("^\\((\\d+[a-z]?)\\)\\s+");
+
+  private static final Pattern JURABK_ZEILE = Pattern.compile("^\\((\\S+)\\)$");
+
+  // Kopf der Druckfassung („BayJG: Bayerisches Jagdgesetz … (Art. 1–64)“), ggf. mit
+  // umbrochenem Rest („1–64)“) auf der Folgezeile.
+  private static final Pattern DRUCKKOPF = Pattern.compile("^\\S{1,20}: .+$");
+  private static final Pattern DRUCKKOPF_REST = Pattern.compile("^\\d+[–-]\\d+[a-z]?\\)$");
+
+  private static final Pattern GLIEDERUNG =
+      Pattern.compile("^([IVXLCDM]+)\\.\\s+(Abschnitt|Teil|Kapitel)\\b\\s*(.*)$");
+
+  private static final Pattern UNTER_GLIEDERUNG = Pattern.compile("^(\\d+[a-z]?)\\.\\s+(\\S.*)$");
+
+  // Normkopf: „Art. N“ plus Titel auf derselben Zeile. Die Negativliste schließt
+  // Querverweise am Zeilenanfang aus („Art. 4 Abs. 3 …“).
+  private static final Pattern NORM_KOPF =
+      Pattern.compile(
+          "^Art\\.\\s+(\\d+[a-z]?)\\s+"
+              + "(?!Absatz|Abs\\.|Satz|Sätze|Nummer|Nr\\.|Buchstabe|Buchst\\."
+              + "|und|bis|oder|sowie|des|der|dieses)"
+              + "((?:\\p{Lu}|\\().*)$");
+
+  private static final Pattern WEGGEFALLEN_TITEL =
+      Pattern.compile("^\\((?:aufgehoben|weggefallen)\\)$");
+
+  private static final Pattern FUSSNOTE =
+      Pattern.compile("^([⁰¹²³⁴⁵⁶⁷⁸⁹]+|\\d{1,3})\\)\\s*(\\[Amtl\\. Anm\\.:\\].*)$");
+
+  private BayRechtTextParser() {}
+
+  static Gesetz parse(String text) {
+    var zeilen = text.lines().toList();
+    int i = ueberspringeDruckkopf(zeilen);
+
+    // Titelblock.
+    while (i < zeilen.size() && zeilen.get(i).isBlank()) {
+      i++;
+    }
+    if (i >= zeilen.size()) {
+      throw new IllegalArgumentException("Leere Eingabe: kein Titel gefunden.");
+    }
+    var langue = zeilen.get(i++).strip();
+    String jurabk = null;
+    if (i < zeilen.size()) {
+      var m = JURABK_ZEILE.matcher(zeilen.get(i).strip());
+      if (m.matches()) {
+        jurabk = m.group(1);
+        i++;
+      }
+    }
+    // Rest des Titelblocks (Datum, Fundstellen, Vollzitat) bis zur ersten Struktur überspringen.
+    while (i < zeilen.size()
+        && !GLIEDERUNG.matcher(zeilen.get(i).strip()).matches()
+        && !NORM_KOPF.matcher(zeilen.get(i).strip()).matches()) {
+      i++;
+    }
+
+    var normen = new ArrayList<Norm>();
+    var gliederungen = new ArrayList<Gliederung>();
+    Gliederung aktuelleGliederung = null;
+    String elternKennzahl = null;
+    int gliederungsZaehler = 0;
+
+    String normNummer = null;
+    String normTitel = null;
+    var normZeilen = new ArrayList<String>();
+    int letzteNormNummer = 0;
+
+    for (; i <= zeilen.size(); i++) {
+      var zeile = i < zeilen.size() ? zeilen.get(i).strip() : null;
+
+      var gliederung = zeile != null ? GLIEDERUNG.matcher(zeile) : null;
+      var unterGliederung = zeile != null ? UNTER_GLIEDERUNG.matcher(zeile) : null;
+      var normKopf = zeile != null ? NORM_KOPF.matcher(zeile) : null;
+
+      if (zeile == null
+          || gliederung.matches()
+          || (normKopf.matches() && istNeuerNormKopf(normKopf.group(1), letzteNormNummer))
+          || (unterGliederung.matches() && istUnterGliederung(unterGliederung, zeilen, i))) {
+        // Laufende Norm abschließen.
+        if (normNummer != null) {
+          normen.add(baueNorm(normNummer, normTitel, aktuelleGliederung, normZeilen));
+        }
+        normNummer = null;
+        normZeilen.clear();
+
+        if (zeile == null) {
+          break;
+        }
+        if (gliederung.matches()) {
+          gliederungsZaehler++;
+          elternKennzahl = String.format("%03d", gliederungsZaehler);
+          var titel = gliederung.group(3).strip();
+          aktuelleGliederung =
+              new Gliederung(
+                  elternKennzahl,
+                  gliederung.group(1) + ". " + gliederung.group(2),
+                  titel.isEmpty() ? null : titel);
+          gliederungen.add(aktuelleGliederung);
+        } else if (normKopf.matches() && istNeuerNormKopf(normKopf.group(1), letzteNormNummer)) {
+          normNummer = normKopf.group(1);
+          normTitel = normKopf.group(2).strip();
+          letzteNormNummer = numerisch(normNummer);
+        } else {
+          var kennzahl =
+              (elternKennzahl != null ? elternKennzahl : "000") + "." + unterGliederung.group(1);
+          aktuelleGliederung =
+              new Gliederung(kennzahl, unterGliederung.group(1) + ".", unterGliederung.group(2));
+          gliederungen.add(aktuelleGliederung);
+        }
+        continue;
+      }
+
+      if (normNummer != null) {
+        normZeilen.add(zeilen.get(i));
+      }
+    }
+
+    if (normen.isEmpty()) {
+      throw new IllegalArgumentException(
+          "Kein „Art. N“-Normkopf gefunden — ist das eine konsolidierte Fassung von"
+              + " gesetze-bayern.de?");
+    }
+    return new Gesetz(jurabk != null ? jurabk : langue, langue, null, normen, gliederungen);
+  }
+
+  /** Überspringt die Kopfzeile der Druckfassung samt umbrochenem Rest. */
+  private static int ueberspringeDruckkopf(List<String> zeilen) {
+    int i = 0;
+    while (i < zeilen.size() && zeilen.get(i).isBlank()) {
+      i++;
+    }
+    if (i < zeilen.size() && DRUCKKOPF.matcher(zeilen.get(i).strip()).matches()) {
+      i++;
+      if (i < zeilen.size() && DRUCKKOPF_REST.matcher(zeilen.get(i).strip()).matches()) {
+        i++;
+      }
+    }
+    return i;
+  }
+
+  /**
+   * Ein Normkopf eröffnet nur dann eine neue Norm, wenn seine Nummer hinter der letzten liegt —
+   * das fängt Querverweise ab, die die Negativliste nicht ausschließt.
+   */
+  private static boolean istNeuerNormKopf(String nummer, int letzteNormNummer) {
+    return numerisch(nummer) >= letzteNormNummer;
+  }
+
+  private static int numerisch(String nummer) {
+    return Integer.parseInt(nummer.replaceAll("[a-z]+$", ""));
+  }
+
+  /**
+   * Eine nummerierte Zeile ist eine Unter-Überschrift (keine Aufzählung), wenn ihr Text kurz ist,
+   * großgeschrieben beginnt, nicht mit Satzzeichen endet und die nächste nicht-leere Zeile ein
+   * Normkopf oder eine weitere Überschrift ist.
+   */
+  private static boolean istUnterGliederung(
+      java.util.regex.Matcher unterGliederung, List<String> zeilen, int index) {
+    var titel = unterGliederung.group(2);
+    if (titel.length() > 80
+        || !Character.isUpperCase(titel.codePointAt(0))
+        || titel.matches(".*[.,;:]$")) {
+      return false;
+    }
+    for (int j = index + 1; j < zeilen.size(); j++) {
+      var naechste = zeilen.get(j).strip();
+      if (naechste.isEmpty()) {
+        continue;
+      }
+      return NORM_KOPF.matcher(naechste).matches()
+          || GLIEDERUNG.matcher(naechste).matches()
+          || UNTER_GLIEDERUNG.matcher(naechste).matches();
+    }
+    return false;
+  }
+
+  private static Norm baueNorm(
+      String nummer, @Nullable String titel, @Nullable Gliederung gliederung, List<String> zeilen) {
+    var enbez = "Art. " + nummer;
+    boolean weggefallen = titel != null && WEGGEFALLEN_TITEL.matcher(titel).matches();
+
+    var absaetze = new ArrayList<Absatz>();
+    String absatzNummer = null;
+    var absatzZeilen = new ArrayList<String>();
+    for (var zeile : zeilen) {
+      var gestutzt = zeile.strip();
+      if (gestutzt.isEmpty()) {
+        continue;
+      }
+      var fussnote = FUSSNOTE.matcher(gestutzt);
+      if (fussnote.matches()) {
+        // Fußnoten verbleiben superskript-normalisiert als eigene Zeile im tragenden Absatz.
+        absatzZeilen.add(Superskript.zuSuperskript(fussnote.group(1)) + ") " + fussnote.group(2));
+        continue;
+      }
+      var marker = ABSATZ_MARKER.matcher(gestutzt);
+      if (marker.find()) {
+        if (!absatzZeilen.isEmpty()) {
+          absaetze.add(new Absatz(absatzNummer, String.join("\n", absatzZeilen)));
+          absatzZeilen.clear();
+        }
+        absatzNummer = marker.group(1);
+        absatzZeilen.add(gestutzt.substring(marker.end()));
+      } else {
+        absatzZeilen.add(zeile.stripTrailing());
+      }
+    }
+    if (!absatzZeilen.isEmpty()) {
+      absaetze.add(new Absatz(absatzNummer, String.join("\n", absatzZeilen)));
+    }
+
+    return new Norm(enbez, titel == null || titel.isEmpty() ? null : titel, gliederung, absaetze, weggefallen);
+  }
+}
diff --git a/src/main/resources/sampledata/BayJG/BayJG-alt.txt b/src/main/resources/sampledata/BayJG/BayJG-alt.txt
new file mode 100644
index 0000000..de2ed2e
--- /dev/null
+++ b/src/main/resources/sampledata/BayJG/BayJG-alt.txt
@@ -0,0 +1,570 @@
+Bayerisches Jagdgesetz
+(BayJG)
+Vom 13. Oktober 1978
+(BayRS V S. 595)
+BayRS 792-1-W
+
+I. Abschnitt Grundsätze
+Art. 1  Gesetzeszweck
+
+(1) ¹Die freilebende Tierwelt ist wesentlicher Bestandteil der heimischen Natur. ²Sie ist als Teil des natürlichen Wirkungsgefüges in ihrer Vielfalt zu bewahren.
+(2) Dieses Gesetz soll neben dem Bundesjagdgesetz¹) dazu dienen:
+  1. einen artenreichen und gesunden Wildbestand in einem ausgewogenen Verhältnis zu seinen natürlichen Lebensgrundlagen zu erhalten,
+  2. die natürlichen Lebensgrundlagen des Wildes zu sichern und zu verbessern,
+  3. Beeinträchtigungen einer ordnungsgemäßen land-, forst- und fischereiwirtschaftlichen Nutzung durch das Wild möglichst zu vermeiden, insbesondere soll die Bejagung die natürliche Verjüngung der standortgemäßen Baumarten im Wesentlichen ohne Schutzmaßnahmen ermöglichen,
+  4. die jagdlichen Interessen mit den sonstigen öffentlichen Belangen, insbesondere mit den Belangen der Landeskultur, des Naturschutzes und der Landschaftspflege auszugleichen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 2  Staatliche Aufsicht und Förderung
+
+(1) Der Staat ordnet und beaufsichtigt das gesamte Jagdwesen und schützt die Jagd als Kulturgut.
+(2) ¹Das Jagdwesen wird aus dem Aufkommen der Jagdabgabe (Art. 26 und 27) gefördert. ²Die Förderung nach anderen Vorschriften und Programmen bleibt unberührt.
+
+II. Abschnitt Jagdreviere, Hegegemeinschaften
+Art. 3  Feststellung der Jagdreviere
+
+Bestand, Umfang und Grenzen eines Jagdreviers (Jagdbezirks) werden, falls erforderlich, durch die Jagdbehörde festgestellt.
+
+Art. 4  Gestaltung der Jagdreviere
+
+(1) ¹Jagdreviere sind durch Abtrennung, Angliederung oder Austausch von Grundflächen abzurunden, wenn Jagdpflege und Jagdausübung dies erfordern. ²Bei der Abrundung soll die Gesamtgröße der Jagdreviere möglichst wenig verändert werden; Möglichkeiten eines Flächenausgleichs sind auszuschöpfen. ³Durch Abrundung darf ein Jagdrevier seine gesetzliche Mindestgröße (Art. 8 Abs. 1, Art. 10 Abs. 1) nicht verlieren.
+(2) ¹Die Abrundung kann durch Vereinbarung der Beteiligten (Jagdgenossenschaft, Eigentümer oder Nutznießer eines Eigenjagdreviers) oder von Amts wegen vorgenommen werden. ²Die Vereinbarung bedarf der Schriftform und der Zustimmung der Jagdbehörde.
+(3) ¹Ist die Ausübung des Jagdrechts auf einer anzugliedernden oder abzutrennenden Grundfläche verpachtet, so darf während der Pachtdauer eine Abrundungsmaßnahme nur mit Zustimmung der Parteien des Jagdpachtvertrags durchgeführt werden. ²Wird der Abrundung nicht zugestimmt, so wird diese erst mit der Beendigung des Jagdpachtverhältnisses der nichtzustimmenden Vertragspartei, bei mehreren nichtzustimmenden Vertragsparteien mit Beendigung des am längsten laufenden Jagdpachtvertrags der nichtzustimmenden Vertragsparteien wirksam. ³Der Zustimmung bedarf es insoweit nicht, als Jagdpachtverträge vor ihrem Ablauf verlängert oder neu abgeschlossen werden und im Zeitpunkt der Verlängerung oder des Neuabschlusses ein Abrundungsverfahren bereits anhängig ist.
+
+Art. 5  Pachtpreisregelung und Entschädigung bei Angliederung von Flächen
+
+(1) Wird eine Grundfläche während der Laufzeit eines Jagdpachtvertrags einem Jagdrevier angegliedert oder von diesem abgetrennt, so erhöht oder ermäßigt sich der Pachtpreis entsprechend der Größe der angegliederten oder abgetrennten Fläche, falls nicht die Beteiligten etwas anderes vereinbaren.
+(2) ¹Wird eine Grundfläche einem Eigenjagdrevier angegliedert, so hat der Eigentümer der Grundfläche gegen den Eigentümer oder Nutznießer des Eigenjagdreviers einen Anspruch auf eine Entschädigung. ²Diese bemißt sich, wenn das Eigenjagdrevier verpachtet ist, nach Absatz 1. ³Ist das Eigenjagdrevier nicht verpachtet, so setzt, wenn sich die Beteiligten über die Höhe der Entschädigung nicht einigen, die Jagdbehörde eine angemessene Entschädigung fest. ⁴Auf das Rechtsverhältnis zwischen dem Eigentümer der Grundflächen und dem Eigentümer oder Nutznießer des Eigenjagdreviers finden im übrigen die Vorschriften des Bürgerlichen Gesetzbuchs²) über die Pacht sinngemäß Anwendung, soweit nichts anderes vereinbart ist.
+²) [Amtl. Anm.:] BGBl. FN 400-2
+
+Art. 6  Befriedete Bezirke; Ruhen der Jagd
+
+(1) Befriedete Bezirke (§ 6 des Bundesjagdgesetzes¹)) sind:
+  1. Gebäude, die zum Aufenthalt von Menschen dienen, und Gebäude, die mit solchen Gebäuden räumlich zusammenhängen,
+  2. Hofräume und Hausgärten, die unmittelbar an eine Behausung im Sinn der Nummer 1 anschließen und durch eine Umfriedung begrenzt sind,
+  3. sonstige überbaute Flächen im Geltungsbereich eines Bebauungsplans und Flächen innerhalb der im Zusammenhang bebauten Ortsteile,
+  4. Friedhöfe,
+  5. Tiergärten.
+(2) ¹Darüber hinaus kann die Jagdbehörde für befriedet erklären:
+  1. sonstige Flächen im Geltungsbereich eines Bebauungsplans mit Ausnahme der in § 9 Abs. 1 Nr. 18 des Bundesbaugesetzes³) genannten Flächen,
+  2. Grundflächen, die gegen das Ein- oder Auswechseln von Wild – ausgenommen Federwild, Wildkaninchen und Raubwild – und gegen unbefugten Zutritt von Menschen dauernd abgeschlossen und deren Eingänge absperrbar sind.
+²Auf Wildgehege (Art. 23 Abs. 1), die jagdlichen Zwecken dienen, und auf Wintergatter (Art. 25) findet Satz 1 keine Anwendung.
+(3) ¹In befriedeten Bezirken kann die Jagdbehörde dem Eigentümer, dem Nutzungsberechtigten, dem Revierinhaber oder deren Beauftragten bestimmte Jagdhandlungen unter Beschränkung auf bestimmte Wildarten und auf eine bestimmte Zeit gestatten. ²Eines Jagdscheins bedarf es nicht. ³Jagdhandlungen mit der Schußwaffe dürfen dem Eigentümer, dem Nutzungsberechtigten oder einem Beauftragten nur gestattet werden, wenn diese im Besitz eines gültigen Jagdscheins oder für den Gebrauch von Schußwaffen im Sinn des § 17 Abs. 1 Nr. 4 des Bundesjagdgesetzes¹) ausreichend versichert sind. ⁴Die waffenrechtlichen Vorschriften bleiben unberührt. ⁵Das Aneignungsrecht hat derjenige, dem oder dessen Beauftragten die Jagdhandlung gestattet wurde.
+(4) ¹Mit Zustimmung der Jagdbehörde kann der Eigentümer oder Nutznießer des Eigenjagdreviers oder die Jagdgenossenschaft die Jagd ruhen lassen. ²Die Zustimmung darf nur erteilt werden, wenn dadurch die Verwirklichung der in Art. 1 Abs. 2 genannten Ziele nicht gefährdet wird.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+³) [Amtl. Anm.:] BGBl. FN 213-1
+
+Art. 7  Verantwortlicher Revierinhaber
+
+(1) ¹Derjenige, dem die Ausübung des Jagdrechts in einem Jagdrevier zusteht (Jagdausübungsberechtigter), ist verpflichtet, dort das Jagdrecht auszuüben. ²Er ist der für die Ausübung des Jagdrechts einschließlich des Jagdschutzes verantwortliche Revierinhaber.
+(2) ¹Ist der Eigentümer oder Nutznießer eines Eigenjagdreviers eine Personenmehrheit, eine juristische Person oder nichtjagdpachtfähig (§ 11 Abs. 5 des Bundesjagdgesetzes¹)), so hat er der Jagdbehörde eine oder mehrere jagdpachtfähige Personen als im Sinn des Absatzes 1 Satz 2 verantwortliche Personen zu benennen, wenn die Jagd nicht durch Verpachtung ausgeübt wird. ²Es dürfen nicht mehr Personen als verantwortlich benannt werden als nach Art. 15 Abs. 1 Jagdpächter sein dürfen.
+(3) Absatz 2 gilt sinngemäß, wenn und solang der Revierinhaber aus Gründen, die in seiner Person liegen, an der Ausübung des Jagdrechts einschließlich des Jagdschutzes längere Zeit verhindert ist.
+(4) Mitpächter oder mehrere für ein Jagdrevier verantwortliche Personen im Sinn des Absatzes 2 haben auf Verlangen der Jagdbehörde einen von ihnen als Bevollmächtigten zu benennen, der gegenüber der Jagdbehörde in allen die Jagdausübung in dem Jagdrevier betreffenden Angelegenheiten zur Abgabe und Entgegennahme von Erklärungen sowie zum Empfang von Urkunden und Sachen berechtigt ist.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 8  Eigenjagdreviere
+
+(1) ¹Die Mindestgröße eines Eigenjagdreviers beträgt 81,755 ha, im Hochgebirge mit seinen Vorbergen 300 ha. ²Grundflächen, die kein Jagdrevier bilden und von mehreren Eigenjagdrevieren umschlossen werden, sind durch die Jagdbehörde einem oder mehreren dieser angrenzenden Jagdreviere anzugliedern; werden sie nur von einem Eigenjagdrevier umschlossen, so sind sie dessen Bestandteil. ³Die Art. 4 Abs. 3, Art. 5 Abs. 2 und Art. 11 Abs. 6 (Angliederungsgenossenschaft) sind entsprechend anzuwenden.
+(2) ¹Eigenjagdreviere können mit Zustimmung der Jagdbehörde in mehrere selbständige Jagdreviere aufgeteilt werden. ²Die Jagdbehörde darf nur zustimmen, wenn jeder Teil für sich die Mindestgröße von 250 ha, im Hochgebirge mit seinen Vorbergen von 500 ha hat, und wenn jedes Teilrevier eine ordnungsgemäße Jagdausübung gestattet.
+
+Art. 9  Staatsjagdreviere
+
+(1) Staatsjagdreviere sind die Eigenjagdreviere des Freistaates Bayern mit den angegliederten und ausschließlich der abgetrennten Grundflächen.
+(2) ¹Der Staat übt das Jagdrecht selbst oder durch Verpachtung aus, soweit nicht der Bayerischen Staatsforsten das Jagdausübungsrecht gemäß Art. 4 Abs. 1 des Staatsforstengesetzes zusteht. ²Übt der Staat das Jagdrecht selbst aus, findet Art. 7 Abs. 2 keine Anwendung.
+(3) Inhaber eines gültigen Jagdscheins können in den nichtverpachteten Staatsjagdrevieren neben dem Personal, durch das der Staat die Jagd ausüben läßt, als Jagdgäste zur Jagdausübung zugelassen werden; Jäger ohne ständige Jagdmöglichkeit auch durch Ausgabe befristeter Jagderlaubnisscheine.
+
+Art. 10  Gemeinschaftsjagdreviere
+
+(1) ¹Die Mindestgröße eines Gemeinschaftsjagdreviers beträgt 250 ha, im Hochgebirge mit seinen Vorbergen 500 ha. ²Befriedete Bezirke zählen bei der Berechnung der Mindestgröße nicht mit.
+(2) ¹Die außerhalb eines Gemeinschaftsjagdreviers liegenden Grundflächen eines Gemeindegebiets oder eines gemeindefreien Gebiets sind durch die Jagdbehörde angrenzenden Jagdrevieren anzugliedern, sofern sie nicht nach § 8 Abs. 2 des Bundesjagdgesetzes¹) zu einem Gemeinschaftsjagdrevier zusammengelegt werden. ²Werden solche Flächen von einem Jagdrevier ganz umschlossen, so sind sie dessen Bestandteil. ³Art. 4 Abs. 3 ist entsprechend anzuwenden.
+(3) Einem Antrag auf Zusammenlegung zusammenhängender Grundflächen zu einem Gemeinschaftsjagdrevier ist unter den Voraussetzungen des § 8 Abs. 2 des Bundesjagdgesetzes stattzugeben, wenn er von der Mehrheit der Grundstückseigentümer jeder der beteiligten Gemeinden gestellt wird und die Antragsteller in ihrer Gemeinde jeweils gemeinsam über mehr als die Hälfte der zusammenhängenden Grundflächen verfügen.
+(4) Die Teilung eines Gemeinschaftsjagdreviers in mehrere selbständige Jagdreviere (§ 8 Abs. 3 des Bundesjagdgesetzes) darf die Jagdbehörde nur zulassen, wenn die Jagdgenossenschaft dies beschlossen hat und jeder Teil für sich die gesetzliche Mindestgröße (Absatz 1) hat und eine ordnungsgemäße Jagdausübung gestattet.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 11  Jagdgenossenschaft
+
+(1) ¹Die Jagdgenossenschaft (§ 9 des Bundesjagdgesetzes¹)) ist eine Körperschaft des öffentlichen Rechts. ²Sie untersteht der staatlichen Aufsicht der Jagdbehörden. ³Diese haben ihr gegenüber die gleichen Befugnisse, wie sie den kommunalen Aufsichtsbehörden gegenüber den Gemeinden in Angelegenheiten des eigenen Wirkungskreises zustehen.
+(2) ¹Die Jagdgenossenschaft hat eine Satzung zu beschließen, die der Genehmigung der Jagdbehörden bedarf. ²Erläßt das Staatsministerium für Wirtschaft, Landesentwicklung und Energie Satzungsmuster, so ist eine Satzung von der Genehmigungspflicht befreit, wenn sie keine oder nur solche Abweichungen enthält, die im Satzungsmuster selbst vorgesehen sind; in diesem Fall soll die Satzung spätestens vier Wochen vor ihrem Inkrafttreten der Jagdbehörde vorgelegt werden. ³Die Satzung ist ortsüblich bekanntzumachen. ⁴Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Mindestanforderungen für die Satzungen aufzustellen, in denen auch Vorschriften über die Verwaltung des Vermögens der Jagdgenossenschaften enthalten sein sollen. ⁵Kommt die Jagdgenossenschaft der Aufforderung der Jagdbehörde zum Erlaß einer Satzung nicht innerhalb einer ihr gesetzten angemessenen Frist nach, so erläßt die Jagdbehörde eine Satzung für die Jagdgenossenschaft.
+(3) ¹Die Jagdgenossenschaft kann für ihren durch die sonstigen Einnahmen nicht gedeckten Bedarf Umlagen von den Jagdgenossen erheben. ²Die Umlagen können von der Jagdgenossenschaft wie Kommunalabgaben beigetrieben werden.
+(4) Die Kosten der vorübergehenden Geschäftsführung (§ 9 Abs. 2 Satz 3 des Bundesjagdgesetzes) bis zur Wahl des Jagdvorstands trägt die Jagdgenossenschaft.
+(5) Gehören zu einem Gemeinschaftsjagdrevier Flächen verschiedener Gemeinden oder gemeindefreier Gebiete, so nimmt der Bürgermeister der Gemeinde, in deren Gebiet der größte Flächenanteil des Gemeinschaftsjagdreviers liegt, nach § 9 Abs. 2 Satz 3 des Bundesjagdgesetzes bis zur Wahl des Jagdvorstands dessen Geschäfte wahr.
+(6) ¹Besteht die einem Eigenjagdrevier angegliederte Grundfläche aus mehreren selbständigen Grundstücken, die im Eigentum von mehr als 15 Personen stehen, so bilden diese Personen zur Vertretung ihrer Rechte, die sich aus der Angliederung ergeben, eine Jagdgenossenschaft (Angliederungsgenossenschaft). ²Auf die Angliederungsgenossenschaft finden die §§ 9 und 10 Abs. 3 des Bundesjagdgesetzes und die Absätze 1 bis 5 sinngemäß Anwendung.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 12  Jagdnutzung
+
+(1) ¹Die Jagdgenossenschaft kann die Verpachtung insbesondere auf den Kreis der Jagdgenossen (§ 10 Abs. 1 Satz 2 des Bundesjagdgesetzes¹)) oder der jagdpachtfähigen Personen beschränken, die ihre Hauptwohnung in einer bestimmten Höchstentfernung zum Jagdrevier haben. ²Sie kann außerdem ihre Zustimmung zur Weiter- und Unterverpachtung sowie zur Erteilung entgeltlicher Dauerjagderlaubnisscheine (Art. 15 Abs. 2, Art. 17 Abs. 2 Satz 1) davon abhängig machen, daß ortsansässige jagdpachtfähige Personen angemessen berücksichtigt werden. ³Die Inhaber von Dauerjagderlaubnisscheinen sind dem Jagdvorsteher mitzuteilen. ⁴Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Vorschriften über die Art der Verpachtung von Gemeinschaftsjagdrevieren (z.B. öffentliche Versteigerung, öffentliche Ausbietung, freihändige Vergabe) und das dabei anzuwendende Verfahren zu erlassen.
+(2) Wird die Jagd durch angestellte Jäger ausgeübt, so dürfen nicht mehr Personen angestellt werden, als nach Art. 15 Abs. 1 Jagdpächter sein dürfen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 13  Aufgaben und räumlicher Wirkungsbereich der Hegegemeinschaften
+
+(1) Die Revierinhaber von zusammenhängenden Jagdrevieren, die einen bestimmten Lebensraum für das Wild umfassen, können eine Hegegemeinschaft bilden, um eine ausgewogene Hege der vorkommenden Wildarten und eine einheitliche großräumige Abschußregelung zu ermöglichen (§ 10a Abs. 1 des Bundesjagdgesetzes).
+(2) ¹Zu den Aufgaben einer Hegegemeinschaft zählen insbesondere
+  1. Hegemaßnahmen in den einzelnen Jagdrevieren abzustimmen und gemeinsam durchzuführen,
+  2. bei der Wildbestandsermittlung mitzuwirken,
+  3. die Abschußplanvorschläge aufeinander abzustimmen,
+  4. auf die Erfüllung der Abschußpläne hinzuwirken.
+²An den Beratungen der Hegegemeinschaften, bei denen sich die Mitglieder auch vertreten lassen können, sind die Jagdvorstände der beteiligten Jagdgenossenschaften und die Inhaber der verpachteten Eigenjagdreviere zu beteiligen. ³Soweit Abschußpläne vom Revierinhaber nicht im Einvernehmen mit dem Jagdvorstand oder dem Inhaber des Eigenjagdreviers aufgestellt worden sind, hat die Hegegemeinschaft auf eine einvernehmliche Abschußplanung hinzuwirken (§ 21 Abs. 2 Sätze 3 und 4 des Bundesjagdgesetzes und Art. 32 Abs. 1 Satz 1 dieses Gesetzes).
+(3) Die Mitglieder der Hegegemeinschaft wählen in der Regel aus dem Kreis der ihr angehörenden Revierinhaber für eine bestimmte Amtszeit einen Vorsitzenden und einen Stellvertreter, die zuverlässig, jagdlich erfahren und mit den Verhältnissen in der Hegegemeinschaft vertraut sein sollen.
+(4) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Vorschriften zu erlassen über die Abgrenzung des räumlichen Wirkungsbereichs der Hegegemeinschaften und die Mitwirkung der anerkannten Vereinigungen der Jäger (Art. 51) dazu, ferner über die Abgabe von Empfehlungen der Hegegemeinschaften zur Abschußplanung und ihre Mitwirkung bei der Erfüllung der Abschußpläne. ²Dabei kann die Zuständigkeit für die Abgrenzung des räumlichen Wirkungsbereichs der Hegegemeinschaften auf nachgeordnete Jagdbehörden übertragen werden.
+(5) Beteiligt sich ein Revierinhaber nicht an der Hegegemeinschaft, so gibt der Vorsitzende der Hegegemeinschaft, in deren räumlichen Wirkungsbereich das Jagdrevier liegt, eine Empfehlung zur Abschußplanung ab, die dem Revierinhaber und der Jagdgenossenschaft oder, bei verpachteten Eigenjagdrevieren, dem Inhaber des Eigenjagdreviers sowie der Jagdbehörde zuzuleiten ist.
+
+III. Abschnitt Beteiligung Dritter an der Ausübung des Jagdrechts
+Art. 14  Verpachtung von Teilen eines Jagdreviers; Mindestpachtzeit; Beanstandungsverfahren; Änderung von Jagdpachtverträgen
+
+(1) ¹Die Verpachtung eines Teils eines Jagdreviers bedarf der Zustimmung der Jagdbehörde. ²Die für die Teilung von Jagdrevieren vorgeschriebenen Mindestgrößen gelten entsprechend. ³Die Jagdbehörde darf der Teilverpachtung nur zustimmen, wenn sowohl der verpachtete als auch der verbleibende Teil eine ordnungsgemäße Jagdausübung gestattet. ⁴Die Jagdbehörde kann die Verpachtung eines Teils von geringerer Größe an den Revierinhaber eines angrenzenden Jagdreviers zulassen, wenn dies einer besseren Reviergestaltung dient.
+(2) ¹Die Mindestpachtzeit beträgt für Niederwildreviere neun Jahre, für Hochwildreviere zwölf Jahre. ²Die Jagdbehörde kann im Fall des Absatzes 1 Satz 4 oder für die Aufnahme eines Mitpächters oder sonst, wenn besondere Gründe vorliegen, ausnahmsweise eine kürzere Pachtzeit zulassen.
+(3) Eine juristische Person des öffentlichen Rechts, die Inhaber eines oder mehrerer Eigenjagdreviere ist und Flächen zur Jagdausübung zupachten will, kann Jagdpächter sein.
+(4) ¹Ein Jagdpachtvertrag kann nach § 12 des Bundesjagdgesetzes¹) auch beanstandet werden, wenn im Verfahren bei der Verpachtung von Gemeinschaftsjagdrevieren zwingende Vorschriften der nach Art. 12 Abs. 1 Satz 4 erlassenen Rechtsverordnung verletzt worden sind. ²Das gleiche gilt, wenn zu erwarten ist, daß der Jagdpächter nicht die Gewähr für eine den Zielen des Art. 1 Abs. 2 entsprechende Jagdausübung bietet.
+(5) Die Bestimmungen über den Jagdpachtvertrag gelten sinngemäß für die Änderung oder Verlängerung eines Jagdpachtvertrags.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 15  Mehrzahl von Jagdpächtern
+
+(1) ¹Die Zahl der Jagdpächter wird bei Jagdrevieren mit einem Umfang bis zu 250 ha, im Hochgebirge mit seinen Vorbergen bis zu 500 ha auf zwei beschränkt (Mitpacht); in größeren Jagdrevieren ist für je weitere angefangene 250 ha, im Hochgebirge mit seinen Vorbergen für je weitere angefangene 500 ha ein weiterer Pächter zulässig. ²Bei der Berechnung der nach Satz 1 erforderlichen Reviergrößen bleiben die befriedeten Bezirke außer Betracht.
+(2) ¹Die Bestimmungen über den Jagdpachtvertrag gelten mit Ausnahme des Art. 14 Abs. 2 Satz 1 auch für die Weiter- und Unterverpachtung. ²In diesen Fällen darf die Zahl der jagdausübungsberechtigten Personen die zulässige Zahl der Jagdpächter nach Absatz 1 nicht überschreiten.
+
+Art. 16  Pachthöchstfläche; Eintragung in den Jagdschein
+
+(1) ¹Die Gesamtfläche, auf der einem Jagdpächter die Ausübung des Jagdrechts zusteht, darf im Hochgebirge mit seinen Vorbergen nicht mehr als 2000 ha umfassen (§ 11 Abs. 3 Satz 4 des Bundesjagdgesetzes¹)). ²Bei Anpachtungen im Hochgebirge mit seinen Vorbergen und außerhalb sind die Pachtflächen im Verhältnis zu den zulässigen Pachthöchstflächen aufeinander anzurechnen.
+(2) Auf den vertraglichen Flächenanteil eines Mitpächters (§ 11 Abs. 3 Satz 3 des Bundesjagdgesetzes) ist mindestens die Fläche anzurechnen, die bei Teilung der Fläche des Jagdreviers durch die nach Art. 15 Abs. 1 zulässige Zahl der Jagdpächter auf den einzelnen entfällt.
+(3) ¹Wer die Erteilung oder Verlängerung eines Jahresjagdscheins beantragt, hat dabei schriftlich anzugeben, ob er
+  1. als Inhaber eines Eigenjagdreviers,
+  2. als Jagdpächter oder Unterpächter oder
+  3. als Mitpächter
+in einem Jagdrevier zur Jagdausübung befugt ist und für welche Flächen, im Fall der Nummer 3 die anteilig auf ihn entfallende Fläche (§ 11 Abs. 3 Satz 3 des Bundesjagdgesetzes). ²Die Jagdbehörde kann die Erteilung oder Verlängerung des Jagdscheins aussetzen, bis die Angaben gemacht sind. ³Sie hat die Flächen in den Jagdschein einzutragen. ⁴Sie kann die Vorlage des Jagdpachtvertrags oder sonstige Nachweise verlangen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 17  Jagderlaubnis
+
+(1) ¹Der Revierinhaber kann einem Dritten (Jagdgast) eine Jagderlaubnis erteilen. ²Diese kann auch beschränkt erteilt werden. ³Bei mehreren Revierinhabern muß die Jagderlaubnis von allen Revierinhabern erteilt werden. ⁴Die Revierinhaber können sich gegenseitig zur Erteilung von Jagderlaubnissen schriftlich bevollmächtigen.
+(2) ¹Auf die entgeltliche Erteilung einer Jagderlaubnis sind § 11 Abs. 4 Satz 1 und Abs. 5, §§ 12 und 13 des Bundesjagdgesetzes¹) und Art. 15 Abs. 1 und Art. 16 dieses Gesetzes entsprechend anzuwenden. ²Dies gilt nicht für eine vorübergehende Überlassung der Jagdausübung.
+(3) Soweit der Jagdgast bei der Jagdausübung nicht von einem Revierinhaber, einem angestellten Jäger oder Jagdaufseher begleitet wird, hat er eine auf seinen Namen lautende schriftliche Jagderlaubnis bei sich zu führen, die er auf Verlangen den Jagdschutzberechtigten (§ 25 des Bundesjagdgesetzes, Art. 40 Abs. 2 und Art. 41) zur Prüfung auszuhändigen hat.
+(4) Der Jagdgast ist nicht Jagdausübungsberechtigter im Sinn des Bundesjagdgesetzes und dieses Gesetzes.
+(5) Angestellte Jäger und Jagdaufseher sind im Rahmen ihres Anstellungsvertrags zur Jagdausübung innerhalb ihres Dienstbereichs berechtigt; sie benötigen dazu keinen Jagderlaubnisschein.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 18  Nichtigkeit von Jagdpachtverträgen und Jagderlaubnisverträgen
+
+¹Ein Vertrag, der gegen die Bestimmungen der Art. 15, Art. 16 Abs. 2 und Art. 17 Abs. 1 und 2 verstößt, ist nichtig. ²Das gleiche gilt für einen Jagdpachtvertrag, der den Vorschriften des Art. 14 Abs. 1 nicht oder wegen Ausscheidens eines Inhabers einer entgeltlichen Jagderlaubnis den Vorschriften des § 11 Abs. 3 des Bundesjagdgesetzes¹) nicht mehr entspricht und dieser Mangel bis zum Beginn des nächsten Jagdjahres nicht behoben wird.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 19  Erlöschen des Jagdpachtvertrags
+
+Ist die Gültigkeitsdauer eines Jagdscheins abgelaufen, so erlischt der Jagdpachtvertrag oder Jagderlaubnisvertrag im Fall des § 13 Satz 2 des Bundesjagdgesetzes¹) nur dann, wenn der Jagdpächter oder Inhaber der entgeltlichen Dauerjagderlaubnis innerhalb einer von der Jagdbehörde gesetzten angemessenen Frist einen Jahresjagdschein nicht beantragt oder sonstige Voraussetzungen dafür nicht erfüllt.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 20  Tod des Jagdpächters
+
+¹Ist beim Tod des Jagdpächters der Erbe nichtjagdpachtfähig (§ 11 Abs. 5 des Bundesjagdgesetzes¹)) oder sind mehrere Erben vorhanden, so sind der Jagdbehörde eine oder mehrere jagdpachtfähige Personen als verantwortlich im Sinn des Art. 7 Abs. 1 Satz 2 zu benennen. ²Es dürfen nicht mehr Personen als verantwortlich benannt werden, als nach Art. 15 Abs. 1 Jagdpächter sein dürfen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+IV. Abschnitt Schutz des Wildes und seiner Lebensräume
+Art. 21  Wildschutzgebiete
+
+(1) ¹Flächen, die zum Schutz und zur Erhaltung von Wildarten, zur Wildschadensverhütung oder für die Wildforschung von besonderer Bedeutung sind, können zu Wildschutzgebieten erklärt werden. ²Das gilt insbesondere für Flächen, auf denen sich das Wild zum Brüten, Setzen oder zur Rast bevorzugt aufzuhalten pflegt, sowie für Bereiche, in denen es gefüttert werden muß.
+(2) ¹In Wildschutzgebieten kann das Betreten von Flächen und nichtöffentlichen Wegen zeitweise, insbesondere während der Fortpflanzungs-, Aufzucht- und Mauserzeiten verboten oder beschränkt werden, soweit es der Schutzzweck erfordert. ²Die ordnungsgemäße land-, forst- und fischereiwirtschaftliche Bodennutzung bleibt grundsätzlich unberührt.
+(3) ¹Wildschutzgebiete und die zur Erreichung des Schutzzwecks erforderlichen Gebote und Verbote werden durch Rechtsverordnung der unteren Jagdbehörde im Benehmen mit der unteren Naturschutzbehörde festgelegt. ²Vor Erlaß der Rechtsverordnung sind die betroffenen Eigentümer oder sonstigen Berechtigten zu hören. ³Art. 46 Abs. 1, 2, 4 und 5 und Art. 47 des Bayerischen Naturschutzgesetzes⁴) sind sinngemäß anzuwenden.
+(4) Die untere Jagdbehörde kann ferner durch Rechtsverordnung oder Einzelanordnung das Betreten von Teilen der freien Natur im erforderlichen Umfang zum Schutz der dem Wild als Nahrungsquellen, Aufzucht-, Brut- und Nistgelegenheiten dienenden Lebensbereiche (Biotope) sowie zur Durchführung der Wildfütterung in Notzeiten und von Gesellschaftsjagden vorübergehend untersagen oder beschränken.
+⁴) [Amtl. Anm.:] BayRS 791-1-U
+
+Art. 22  Schutz der Nist-, Brut- und Zufluchtstätten des Wildes
+
+(1) ¹Der Revierinhaber ist befugt, mit Genehmigung der Jagdbehörde Bild- und Schrifttafeln anzubringen, die auf die nach § 19a Satz 1 des Bundesjagdgesetzes¹) geschützten Zuflucht-, Nist-, Brut- und Wohnstätten des Wildes sowie auf die Folgen eines Verstoßes gegen diese Vorschrift (§ 39 Abs. 1 Nr. 5 des Bundesjagdgesetzes) hinweisen. ²Durch die Hinweistafeln darf das Landschaftsbild nicht verunstaltet werden.
+(2) ¹Das Verbot des § 19a Satz 1 des Bundesjagdgesetzes steht einer ordnungsgemäßen land- und forstwirtschaftlichen Bodennutzung sowie der rechtmäßigen Ausübung der Jagd und Fischerei nicht entgegen. ²Von dem Verbot kann ferner in Einzelfällen zu wissenschaftlichen Zwecken, Lehr- und Forschungszwecken Befreiung erteilt werden.
+(3) ¹Verboten ist, die Nester und Gelege des Federwildes zu beschädigen, wegzunehmen oder zu zerstören. ²Art. 33 Abs. 5 Nr. 1 bleibt unberührt.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 22a  Schutz kranken und verletzten Wildes
+
+Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung im Rahmen des § 36 Abs. 2 Nr. 2 und Abs. 3 des Bundesjagdgesetzes¹) Vorschriften über das Aufnehmen, die Pflege und die Aufzucht verletzten oder kranken Wildes und dessen Verbleib zu erlassen; diese Vorschriften können sich auch auf Eier oder sonstige Entwicklungsformen solchen Wildes erstrecken.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 23  Wildgehege
+
+(1) Wildgehege sind vollständig eingefriedete Grundflächen, auf denen überwiegend sonst wildlebende Tiere, die dem Jagdrecht unterliegen, dauernd oder vorübergehend gehalten oder zu Jagdzwecken gehegt werden.
+(2) ¹Die Errichtung, die Erweiterung und der Betrieb von Wildgehegen, in denen Wild zu Jagdzwecken gehegt wird, sind genehmigungspflichtig; für sonstige Wildgehege gilt dies ab einer Mindestgröße von 10 ha. ²Die Genehmigung erteilt die Jagdbehörde. ³Diese entscheidet insoweit auch als untere Naturschutzbehörde über die Voraussetzungen des Art. 20a des Bayerischen Naturschutzgesetzes⁴). ⁴Die Genehmigung wird durch eine nach anderen Vorschriften zugleich erforderliche behördliche Gestattung ersetzt; ist die zuständige Behörde nicht zugleich Jagdbehörde und Naturschutzbehörde, so entscheidet sie im Einvernehmen mit diesen Behörden.
+(3) ¹Die Genehmigung darf nur erteilt werden, wenn
+  1. durch das Wildgehege der Lebensraum der Wildarten außerhalb desselben nicht in unangemessener Weise eingeschränkt wird,
+  2. die Jagdausübung nicht wesentlich beeinträchtigt wird und
+  3. das Wildgehege so gesichert ist, daß die Tiere nicht entweichen können.
+²Die Errichtung von Wildgehegen, in denen Wild zu Jagdzwecken gehegt wird, darf außerdem nur genehmigt werden, wenn diese zusammenhängend mindestens die Größe eines Eigenjagdreviers haben und ihre Flächen im Eigentum einer Person oder einer Personengemeinschaft stehen.
+(4) ¹Die Genehmigung ist für bestimmte Tierarten zu erteilen. ²Sie kann mit Nebenbestimmungen versehen werden. ³Die Jagdbehörde kann auch nachträglich Auflagen anordnen. ⁴Sie kann insbesondere die Höchstzahlen der zu haltenden Tiere bestimmen. ⁵Das Beseitigungsverfahren richtet sich nach Art. 76 Sätze 1 und 3 der Bayerischen Bauordnung (BayBO)⁵).
+(5) ¹Wildgehege, die bei Inkrafttreten des Gesetzes bereits bestehen, sind innerhalb von drei Monaten nach Inkrafttreten dieses Gesetzes bei der Jagdbehörde anzuzeigen. ²Die Genehmigung gilt als erteilt, wenn das Wildgehege nach anderen gesetzlichen Bestimmungen genehmigt worden ist oder die Jagdbehörde nicht binnen drei Monaten nach Eingang der Anzeige die Genehmigung versagt; mit der Versagung der Genehmigung kann die Beseitigung des Wildgeheges nach Art. 76 Sätze 1 und 3 BayBO angeordnet werden. ³Soweit diese Maßnahmen enteignend wirken, ist den Betroffenen Entschädigung nach den Vorschriften des Bayerischen Gesetzes über die entschädigungspflichtige Enteignung⁶) zu gewähren. ⁴Entschädigungspflichtig ist der Freistaat Bayern. ⁵Zuständig für die Festsetzung der Entschädigung ist die Kreisverwaltungsbehörde.
+(6) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Vorschriften über die Registrierung und die Regulierung der Tierbestände in Wildgehegen sowie über die Gestaltung der Gehegeanlagen zu erlassen. ²Die Rechtsverordnung ergeht im Einvernehmen mit dem Staatsministerium für Umwelt und Verbraucherschutz, soweit sie die Gestaltung der Gehegeanlagen betrifft.
+⁴) [Amtl. Anm.:] BayRS 791-1-U
+⁵) [Amtl. Anm.:] BayRS 2132-1-I
+⁶) [Amtl. Anm.:] BayRS 2141-1-I
+
+Art. 24  Wildpark
+
+(1) ¹Wildgehege, in denen Schalenwild zu Jagdzwecken gehegt und durch Jagdhandlungen genutzt wird, können als Wildpark (§ 20 Abs. 2 des Bundesjagdgesetzes¹)) anerkannt werden. ²Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, die Voraussetzungen der Anerkennung durch Rechtsverordnung zu regeln.
+(2) Die Bezeichnung „Wildpark“ darf nur für die nach Absatz 1 Satz 1 anerkannten Wildgehege verwendet werden.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 25  Wintergatter
+
+¹Wintergatter sind Wildgehege, in denen Rotwild zur Vermeidung übermäßiger Wildschäden während der Notzeit zur Fütterung gehalten wird. ²Auf sie finden die Vorschriften des Art. 23 Abs. 2 Satz 1 Halbsatz 1, Sätze 2 bis 4, Abs. 4 Sätze 2, 3 und 5 und Abs. 5 Anwendung. ³Die Genehmigung darf im übrigen nur erteilt werden, wenn der Verfügungsberechtigte dem Vorhaben zugestimmt hat.
+
+V. Abschnitt Förderung des Jagdwesens
+Art. 26  Mittel und Gegenstand der Förderung
+
+(1) ¹Mit der Gebühr für den Jagdschein wird vom Jagdscheininhaber eine Jagdabgabe erhoben, die vom Staatsministerium für Wirtschaft, Landesentwicklung und Energie zur Förderung des Jagdwesens zu verwenden ist. ²Gefördert sollen insbesondere werden:
+  1. Maßnahmen zur Erhaltung und Verbesserung der Lebensgrundlagen des Wildes,
+  2. Erforschung der Lebens- und Umweltbedingungen der Wildarten,
+  3. Erforschung von Möglichkeiten zur Verhütung und Verhinderung von Wildschäden in der Land-, Forst- und Fischereiwirtschaft,
+  4. das Berufsjägerwesen,
+  5. die Errichtung und der Betrieb von Muster- und Lehrrevieren sowie sonstige Maßnahmen und Einrichtungen zur Information und Aus- und Fortbildung der Jäger, der Jagdvorsteher sowie der für den Vollzug der jagdrechtlichen Vorschriften zuständigen Organe.
+(2) ¹Die Höhe der Jagdabgabe beträgt für den Tagesjagdschein und den Einjahresjagdschein die Hälfte der Jagdscheingebühr. ²Für den Dreijahresjagdschein wird der dreifache Betrag der Jagdabgabe für den Einjahresjagdschein erhoben.
+
+Art. 27  Verfahren
+
+¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie entscheidet über die Verteilung der für Zwecke der Forschung und für sonstige zentrale Zwecke zu verwendenden Anteile der Jagdabgabe im Benehmen mit den anerkannten Vereinigungen der Jäger (Art. 51). ²Es stellt das verbleibende Aufkommen dem Landesjagdverband Bayern e.V. für die Förderung der Jagd zur Verfügung; der Haushalt des Landesjagdverbands Bayern e.V. unterliegt insoweit der Genehmigung des Staatsministeriums für Wirtschaft, Landesentwicklung und Energie. ³Bei der Festlegung der Förderanteile nach den Sätzen 1 und 2 ist der Jagdbeirat der obersten Jagdbehörde anzuhören.
+
+VI. Abschnitt Jagdausübung
+Art. 28  Jägerprüfung, Falknerprüfung, Jagdschein
+
+(1) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung eine Prüfungsordnung für die Jäger- und Falknerprüfung zu erlassen. ²In der Prüfungsordnung sind insbesondere die Zulassungsvoraussetzungen, die Grundsätze des Prüfungsverfahrens, die Prüfungsorgane, die Prüfungsanforderungen und die Prüfungsfächer festzulegen. ³Ferner können Bestimmungen über die Ausbildung der Prüfungsbewerber und über der Jägerprüfung gleichgestellte Prüfungen getroffen werden. ⁴Es ist weiter festzulegen, daß die erforderlichen Kenntnisse für die Jagd mit Fallen durch Teilnahme an einem Lehrgang nachzuweisen sind; auf diesen Nachweis kann verzichtet werden, wenn der Prüfungsbewerber bei der Anmeldung zur Jägerprüfung die Erklärung abgibt, auf die Ausübung der Fallenjagd zu verzichten; der Verzicht kann widerrufen werden, wenn die Teilnahme an einem Lehrgang zu einem späteren Zeitpunkt nachgeholt wird. ⁵Soweit die Rechtsverordnung nach Satz 1 Belange des Lebensmittelrechts (Wildbrethygiene), des Tierschutzrechts sowie des Naturschutz- und Landschaftspflegerechts betrifft, ergeht sie im Benehmen mit dem Staatsministerium für Umwelt und Verbraucherschutz.
+(2) Der Jahresjagdschein wird als Einjahresjagdschein und als Dreijahresjagdschein erteilt.
+(3) ¹Die Erteilung des Jagdscheins ist von dem Nachweis einer ausreichenden Jagdhaftpflichtversicherung (§ 17 Abs. 1 Nr. 4 des Bundesjagdgesetzes) abhängig zu machen. ²Besteht keine ausreichende Versicherung, so ist ein erteilter Jagdschein unverzüglich der zuständigen Jagdbehörde abzuliefern. ³Erfährt diese auf andere Weise, daß keine ausreichende Versicherung besteht, so hat sie den Jagdschein unverzüglich nach § 18 Satz 1 des Bundesjagdgesetzes für ungültig zu erklären und einzuziehen. ⁴Zuständige Stelle im Sinn des § 158c Abs. 2 des Gesetzes über den Versicherungsvertrag ist die für den Entzug des Jagdscheins zuständige Jagdbehörde. ⁵Kennt der Versicherer diese nicht, so ist die Anzeige an die Jagdbehörde zu richten, die den Jagdschein erteilt hat.
+
+Art. 29  Sachliche Gebote und Verbote
+
+(1) Auf krankgeschossenes Wild ist zeitgerecht und fachgemäß nachzusuchen.
+(2) Verboten ist – in Ergänzung zu § 19 des Bundesjagdgesetzes¹) –
+  1. Wild, insbesondere zur Abrichtung und Prüfung von Jagdhunden, absichtlich krankzuschießen,
+  2. die Jagd auf Wild mit Fanggeräten oder Fangvorrichtungen auszuüben; dies gilt vorbehaltlich des Art. 29a nicht für die Jagd auf Raubwild und Wildkaninchen,
+  3. die Jagd auf sonstiges Haarwild, mit Ausnahme von Schwarzwild und Raubwild, zur Nachtzeit (§ 19 Abs. 1 Nr. 4 des Bundesjagdgesetzes) auszuüben,
+  4. die Jagd auf Schalenwild, mit Ausnahme von Schwarzwild, als Treibjagd auszuüben,
+  5. das Wild durch Lappen oder sonstige Mittel zu hindern, aus seinen oder in seine Tageseinstände zu wechseln,
+  6. auf Wild, das durch Überflutungen, Lawinen oder sonstige Naturkatastrophen in Not geraten oder zum Verlassen der Einstände gezwungen worden ist, die Jagd auszuüben; dies gilt nicht, soweit die Not des Wildes nur durch Erlegung beendet werden kann,
+  7. die Jagd unter Verwendung von Betäubungs- oder Lähmungsmitteln, Sprengstoffen, Gasen oder von Schußwaffen mit Schalldämpfern auszuüben,
+  8. Wild aus Luftfahrzeugen, Kraftfahrzeugen oder maschinengetriebenen Wasserfahrzeugen zu beschießen; das Verbot umfasst nicht das Beschießen von Wild aus Kraftfahrzeugen durch Körperbehinderte mit Erlaubnis der Jagdbehörde.
+(3) Die Jagdbehörde kann Ausnahmen zulassen
+  1. in besonderen Einzelfällen, insbesondere zur Durchführung von Hegemaßnahmen oder zu wissenschaftlichen Zwecken, von dem Verbot des Absatzes 2 Nr. 2, soweit es sich nicht um die Verwendung von Schlagfallen (Art. 29a) handelt,
+  2. in begründeten Einzelfällen von den Verboten der Verwendung von Betäubungs- oder Lähmungsmittel oder von Schusswaffen mit Schalldämpfern (Abs. 2 Nr. 7),
+  3. von dem Verbot des § 19 Abs. 1 Nr. 4 des Bundesjagdgesetzes für die Nachtjagd auf Rotwild, soweit es die Landeskultur erfordert.
+(4) Das Verbot des § 19 Abs. 1 Nr. 10 des Bundesjagdgesetzes gilt nicht für Kirrungen.
+(5) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung die Verbote des § 19 Abs. 1 des Bundesjagdgesetzes¹), mit Ausnahme der Nummer 16, zu erweitern oder aus besonderen Gründen, insbesondere aus Gründen der Wildseuchenbekämpfung und Landeskultur, zur Beseitigung kranken oder kümmernden Wildes, zur Vermeidung von übermäßigen Wildschäden, zu wissenschaftlichen Zwecken, Lehr- und Forschungszwecken oder bei Störung des biologischen Gleichgewichts einzuschränken; soweit Federwild betroffen ist, ist die Einschränkung nur aus den in Art. 9 Abs. 1 der Richtlinie 79/409/EWG genannten Gründen und nach den in Art. 9 Abs. 2 dieser Richtlinie genannten Maßgaben zulässig. ²Unter den gleichen Voraussetzungen kann die Jagdbehörde die Verbote auch durch Einzelanordnung einschränken. ³Die tierseuchenrechtlichen Vorschriften bleiben unberührt.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 29a  Jagd mit Fallen
+
+(1) ¹Die verwendeten Fallen müssen ihrer Bauart nach Mindestanforderungen erfüllen, die ein sofortiges Töten oder einen unversehrten Lebendfang gewährleisten. ²Fangeisen dürfen nur verwendet werden, wenn zusätzlich
+  1. ihre Betriebssicherheit regelmäßig überprüft wird und
+  2. sie dauerhaft so gekennzeichnet sind, daß ihr Besitzer feststellbar ist.
+(2) ¹Fangeisen dürfen nur in geschlossenen Räumen, Fangbunkern oder Fanggärten, in denen die Schlagfalle nach oben verblendet ist, so aufgestellt werden, daß von ihnen keine Gefährdung von Menschen, geschützten Tieren und Haustieren ausgeht. ²Art. 42 Abs. 1 Nr. 2 bleibt unberührt.
+(3) Die Verwendung von Schlagfallen ist der Jagdbehörde anzuzeigen.
+(4) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, im Einvernehmen mit dem Staatsministerium für Umwelt und Verbraucherschutz das Nähere durch Rechtsverordnung zu regeln. ²Mit der Durchführung der Lehrgänge (Art. 28 Abs. 1 Satz 4), der Überprüfung der Fangeisen auf ihre Betriebssicherheit, ihrer Kennzeichnung und Registrierung (Absatz 1 Satz 2 Nrn. 1 und 2) kann der Landesjagdverband Bayern e. V. betraut werden; in diesem Fall hat der Landesjagdverband Bayern e. V. oder dessen zuständige Kreisgruppe der Jagdbehörde auf Verlangen die Ergebnisse der Funktionsprüfung sowie die Namen und Anschriften der Besitzer der gekennzeichneten Fangeisen mitzuteilen.
+
+Art. 30  Treibjagd, Gesellschaftsjagd
+
+(1) Treibjagd ist die Jagd, an der neben Schützen mehr als vier Personen als Treiber und Abwehrer teilnehmen.
+(2) Gesellschaftsjagd ist die Jagd, an der mehr als vier Personen teilnehmen.
+
+Art. 31  Örtliche Beschränkungen
+
+(1) ¹Die Ausübung der Jagd in Nationalparken wird durch Rechtsverordnung nach Art. 8 Abs. 4 des Bayerischen Naturschutzgesetzes⁴), in Naturschutzgebieten durch Rechtsverordnung nach den Art. 7 und 45 des Bayerischen Naturschutzgesetzes geregelt. ²Vorschriften über die Ausübung der Jagd in Wildparken erläßt das Staatsministerium für Wirtschaft, Landesentwicklung und Energie durch Rechtsverordnung (§ 20 Abs. 2 des Bundesjagdgesetzes¹)).
+(2) ¹In Wintergattern (Art. 25) darf Schalenwild, ausgenommen krankes und kümmerndes Wild, nicht erlegt werden. ²Ausnahmen können zugelassen werden, wenn dies mit Rücksicht auf das allgemeine Wohl, insbesondere auf die Interessen der Land- und Forstwirtschaft und die Belange des Naturschutzes und der Landschaftspflege notwendig ist.
+(3) Die höhere Jagdbehörde kann die Bejagung von Wildarten, die in ihrem Bestand bedroht erscheinen, in bestimmten Gebieten oder in bestimmten Jagdrevieren durch Rechtsverordnung oder durch Anordnung für den Einzelfall dauernd oder zeitweise gänzlich verbieten (§ 21 Abs. 3 des Bundesjagdgesetzes).
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+⁴) [Amtl. Anm.:] BayRS 791-1-U
+
+Art. 32  Regelung der Bejagung
+
+(1) ¹Der Abschußplan (§ 21 Abs. 2 des Bundesjagdgesetzes¹)) ist für den Zeitraum von ein bis drei Jahren zahlenmäßig getrennt nach Wildart und Geschlecht vom Revierinhaber im Einvernehmen mit dem Jagdvorstand, bei verpachteten Eigenjagdrevieren im Einvernehmen mit dem Jagdberechtigten aufzustellen und von der Jagdbehörde im Einvernehmen mit dem Jagdbeirat (Art. 50 Abs. 2 und 6) zu bestätigen oder festzusetzen. ²Bei der Abschußplanung ist neben der körperlichen Verfassung des Wildes vorrangig der Zustand der Vegetation, insbesondere der Waldverjüngung zu berücksichtigen. ³Den zuständigen Forstbehörden ist vorher Gelegenheit zu geben, sich auf der Grundlage eines forstlichen Gutachtens über eingetretene Wildschäden an forstlich genutzten Grundstücken zu äußern und ihre Auffassung zur Situation der Waldverjüngung darzulegen. ⁴Ist zwischen der Jagdbehörde und dem Jagdbeirat ein Einvernehmen nicht zu erzielen, so entscheidet die nächsthöhere Jagdbehörde.
+(2) ¹Der Revierinhaber ist verpflichtet, den Abschußplan für Schalenwild notfalls unter Hinzuziehung anderer Jagdscheininhaber zu erfüllen. ²Die Jagdbehörde trifft die zur Erfüllung des Abschußplans erforderlichen Anordnungen. ³Die Vorschrift des § 27 Abs. 2 des Bundesjagdgesetzes findet entsprechende Anwendung; Art. 32 Satz 2 des Bayerischen Verwaltungszustellungs- und Vollstreckungsgesetzes gilt nicht. ⁴Ein für den Fall der nicht ordnungsgemäßen Erfüllung des Abschußplans angedrohtes Zwangsgeld kann auch beigetrieben werden, wenn nach Ablauf der Jagdzeit feststeht, daß der Abschußplan nicht mehr erfüllt werden kann.
+(3) ¹Anordnungen nach Absatz 2 Satz 2 ergehen im Fall des Art. 7 Abs. 4 an den Bevollmächtigten, der auf die Erfüllung des Abschußplans durch die Mitpächter oder die verantwortlichen Personen im Sinn des Art. 7 Abs. 2 hinzuwirken hat. ²Handlungen des Bevollmächtigten, die zur Erfüllung des Abschußplans erforderlich sind, haben die übrigen Mitpächter oder verantwortlichen Personen zu dulden.
+(4) ¹Über erlegtes und verendetes Schalenwild mit Ausnahme des vor Beginn seiner Jagdzeit gefallenen Jungwildes ist
+  1. der Jagdbehörde eine schriftliche Abschußmeldung zu erstatten und
+  2. eine Streckenliste zu führen, die der Jagdbehörde auf Verlangen jederzeit vorzulegen ist.
+²Die Jagdbehörde kann vom Revierinhaber verlangen, ihr oder einem von ihr Beauftragten das erlegte Wild oder Teile desselben vorzulegen.
+(5) ¹Die Erlegung von krankem Wild außerhalb der Jagdzeiten sowie innerhalb der Jagdzeiten über den Abschußplan hinaus ist der Jagdbehörde unter Angabe der Art der Erkrankung oder Verletzung unverzüglich mitzuteilen. ²Auf Verlangen ist das erlegte Wild der Jagdbehörde oder einem von ihr Beauftragten vorzuzeigen.
+(6) ¹Für bestimmte Jagdreviere können zu wissenschaftlichen Zwecken, Lehr- und Forschungszwecken durch Einzelanordnung Ausnahmen von den Vorschriften über die Hege und Bejagung, insbesondere die zulässige Wilddichte zugelassen werden. ²Die Ausnahme darf nur erteilt werden, wenn dadurch weder eine Störung des biologischen Gleichgewichts noch eine Schädigung der Landeskultur zu befürchten ist und wenn der Revierinhaber und der Jagdberechtigte oder die Jagdgenossenschaft zugestimmt haben. ³Die Zustimmung ist unwiderruflich.
+(7) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung
+  1. nähere Vorschriften über die Abschußplanung sowie über die Bestätigung und Festsetzung der Abschußpläne, ferner über die Überwachung ihrer Durchführung und über die Erzwingung ihrer Erfüllung zu erlassen (§ 21 Abs. 2 Satz 7 des Bundesjagdgesetzes),
+  2. Vorschriften über die Erhebung von Daten über die Revierverhältnisse und das erlegte Wild, ferner über die Erhebung des Bestands der Wildarten sowie der Abschuß- und Fangergebnisse zu erlassen,
+  3. Gebiete für die Hege und Bejagung von Schalenwild festzulegen, diese Gebiete in Bezirke zu unterteilen, ferner die Jagd- und Forstbehörden zu bestimmen, die für die Abschußplanung in diesen Gebieten zuständig sind und erforderlichenfalls gemeinsame Jagdbeiräte vorzusehen.
+(8) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie kann Richtlinien für die Hege und Bejagung des Wildes erlassen.
+(9) Ohne Abschußplan bejagt werden darf Schalenwild in Gebieten, in denen die Hege auf Grund einer Verordnung nach Absatz 7 Nr. 3 untersagt ist.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 33  Jagd- und Schonzeiten
+
+(1) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung
+  1. Tierarten, die in § 2 Abs. 1 des Bundesjagdgesetzes¹) nicht genannt sind, dem Jagdrecht zu unterstellen und für diese Tierarten Jagdzeiten festzusetzen,
+  2. gemäß § 22 Abs. 1 Satz 3 des Bundesjagdgesetzes die Jagdzeiten abzukürzen oder aufzuheben,
+(2) Rechtsverordnungen nach Absatz 1 Nr. 1 ergehen im Einvernehmen mit dem Staatsministerium für Umwelt und Verbraucherschutz.
+(3) Die höhere Jagdbehörde wird ermächtigt, durch Rechtsverordnung
+  1. gemäß § 22 Abs. 1 Satz 3 des Bundesjagdgesetzes für bestimmte Gebiete oder für einzelne Jagdreviere aus besonderen Gründen, insbesondere aus Gründen der Wildseuchenbekämpfung und Landeskultur, zur Beseitigung kranken und kümmernden Wildes, zur Vermeidung von übermäßigen Wildschäden, zu wissenschaftlichen Zwecken, Lehr- und Forschungszwecken, bei Störung des biologischen Gleichgewichts oder der Wildhege die Schonzeiten aufzuheben,
+  2. gemäß § 22 Abs. 2 Satz 2 des Bundesjagdgesetzes bei Störung des biologischen Gleichgewichts oder bei schwerer Schädigung der Landeskultur Jagdzeiten festzusetzen,
+  3. gemäß § 22 Abs. 3 des Bundesjagdgesetzes aus Gründen der Landeskultur Schonzeiten für Wild gänzlich zu versagen,
+  4. gemäß § 22 Abs. 4 Satz 2 des Bundesjagdgesetzes Ausnahmen von dem Jagdverbot in den Setz- und Brutzeiten für Schwarzwild, Wildkaninchen, Fuchs, Ringel- und Türkentaube, Silber- und Lachmöwe sowie für die nach Landesrecht dem Jagdrecht unterstellten Tierarten zu bestimmen,
+  5. abweichend von § 22 Abs. 4 Satz 4 des Bundesjagdgesetzes unter Beachtung der in Art. 9 Abs. 2 der Richtlinie 2009/147/EG genannten Maßgaben das Ausnehmen oder Unfruchtbarmachen der Gelege von Federwild aus den in Art. 9 Abs. 1 der Richtlinie 2009/147/EG genannten Gründen zu gestatten, sofern es keine andere zufriedenstellende Lösung gibt.
+(4) ¹Rechtsverordnungen nach Absatz 3 werden, wenn eine landeseinheitliche Regelung erforderlich oder zweckmäßig ist, vom Staatsministerium für Wirtschaft, Landesentwicklung und Energie erlassen. ²Solche Rechtsverordnungen setzen entgegenstehende oder inhaltsgleiche Vorschriften der nachgeordneten Jagdbehörden außer Kraft. ³Haben solche Rechtsverordnungen die Bekämpfung von Wildseuchen zum Gegenstand, so ist das Staatsministerium für Umwelt und Verbraucherschutz zu beteiligen.
+(5) Die Jagdbehörde kann
+  1. in Einzelfällen für den Lebendfang von Wild Ausnahmen nach § 22 Abs. 1 Satz 4 des Bundesjagdgesetzes und zu wissenschaftlichen, Lehr- und Forschungszwecken oder für Zwecke der Aufzucht und Wiedereinsetzung Ausnahmen nach § 22 Abs. 4 Satz 5 des Bundesjagdgesetzes zulassen und das Sammeln der Eier von Ringel- und Türkentauben sowie von Silber- und Lachmöwen nach § 22 Abs. 4 Satz 6 des Bundesjagdgesetzes erlauben,
+  2. Regelungen nach Abs. 3 Nr. 1, 2 und 5 auch durch Einzelanordnung treffen und gemäß § 22 Abs. 2 Satz 2 des Bundesjagdgesetzes Ausnahmen zulassen,
+  3. gemäß § 22 Abs. 4 Satz 3 des Bundesjagdgesetzes im Einzelfall das Aushorsten von Nestlingen und Ästlingen der Habichte für Beizzwecke genehmigen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 34  Aussetzen von Tierarten
+
+(1) Als fremd im Sinn des § 28 Abs. 3 des Bundesjagdgesetzes¹) gelten Tierarten, die im Geltungsbereich des Bundesjagdgesetzes bei dessen Inkrafttreten (1. April 1953) freilebend nicht heimisch waren.
+(2) ¹Das Aussetzen oder das Ansiedeln fremder Tierarten in der freien Natur ist nur mit vorheriger schriftlicher Genehmigung der Jagdbehörde zulässig. ²Die Genehmigung darf nur erteilt werden, wenn durch das Aussetzen oder das Ansiedeln eine Störung des biologischen Gleichgewichts oder eine Schädigung der Landeskultur oder Gefahren für die öffentliche Sicherheit nicht zu befürchten sind.
+(3) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung das Hegen oder Aussetzen weiterer Tierarten im Sinn von § 28 Abs. 4 des Bundesjagdgesetzes, die dem Jagdrecht unterliegen, aus den in Absatz 2 Satz 2 genannten Gründen zu beschränken oder zu verbieten.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 35  Wegerecht
+
+(1) ¹Wer die Jagd ausübt, aber zum Jagdrevier nicht auf einem zum allgemeinen Gebrauch bestimmten Weg oder nur auf einem unzumutbaren Weg gelangen kann, ist zum Betreten fremder Jagdreviere in Jagdausrüstung auch auf einem nicht zum allgemeinen Gebrauch bestimmten Weg (Jägernotweg) befugt, der notfalls durch die Jagdbehörde bestimmt wird. ²Der Eigentümer des Grundstücks, über das der Jägernotweg führt, kann eine angemessene Entschädigung verlangen, die auf Antrag der Beteiligten durch die Jagdbehörde festgesetzt wird.
+(2) Bei Benutzung des Jägernotwegs dürfen Langwaffen nur ungeladen und Hunde nur angeleint mitgeführt werden.
+
+Art. 36  Jagdeinrichtungen
+
+¹Der Revierinhaber darf auf land- oder forstwirtschaftlich genutzten Grundstücken besondere, das Eigentum wesentlich beeinträchtigende Anlagen nur mit Einwilligung des Grundstückseigentümers oder Nutzungsberechtigten errichten; die Einwilligung kann durch die Jagdbehörde ersetzt werden, wenn dem Eigentümer des Grundstücks die Duldung der Anlage unter Berücksichtigung der jagdlichen Erfordernisse zumutbar ist. ²Der Eigentümer des Grundstücks kann eine angemessene Entschädigung verlangen, die auf Antrag eines der Beteiligten durch die Jagdbehörde festgesetzt wird.
+
+Art. 37  Wildfolge
+
+(1) ¹Wechselt krankgeschossenes Wild in ein benachbartes Revier, so hat der Jagdausübende den Anschuß und die Stelle des Überwechselns nach Möglichkeit kenntlich zu machen. ²Außerdem hat er das Überwechseln dem Inhaber des Nachbarreviers oder dessen Vertreter unverzüglich anzuzeigen; das gilt auch für Wild, das aufgrund anderer Ursachen schwer krank oder verletzt ist. ³Für die Nachsuche hat er sich selbst oder eine mit den Vorgängen vertraute Person zur Verfügung zu stellen.
+(2) Ist der Schütze ein Jagdgast, so ist neben diesem auch der Revierinhaber, wenn er vom Überwechseln des krankgeschossenen Wildes Kenntnis erhält, zur Anzeige verpflichtet.
+(3) ¹Wechselt krankgeschossenes Wild über die Grenze und ist es für einen sicheren Schuß erreichbar, so ist es vom Jagdausübenden zu erlegen und zu versorgen. ²Die Pflicht zur Versorgung erstreckt sich auch auf krankgeschossenes Wild, das nach dem Überwechseln in Sichtweite von der Grenze im benachbarten Revier verendet. ³Langwaffen dürfen beim Überschreiten der Grenze nur ungeladen mitgeführt werden. ⁴Das Fortschaffen des erlegten Schalenwildes ist unzulässig. ⁵Das Erlegen ist dem Inhaber des benachbarten Jagdreviers oder dessen Vertreter unverzüglich anzuzeigen. ⁶Fortgeschafftes oder vom Hund aus dem Nachbarrevier gebrachtes Wild ist dem Inhaber des Nachbarreviers abzuliefern.
+(4) ¹Unbeschadet einer anderweitigen Vereinbarung gehören in den Fällen der Abs. 1, 3 und 6 das Wildbret und die Erinnerungsstücke (Kopfschmuck und Grandeln des Schalenwildes, Waffen des Schwarzwildes) dem Revierinhaber, in dessen Jagdrevier das Wild zur Strecke kommt. ²Das erlegte Wild ist auf den Abschußplan desjenigen Reviers anzurechnen, in dem es angeschossen wurde.
+(5) Über die Vorschriften der Absätze 1, 3 und 4 hinausgehende Vereinbarungen bedürfen der Schriftform.
+(6) ¹Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung abweichend von den Abs. 1, 2 und 3 Vorschriften zur Wildfolge durch anerkannte Nachsuchengespanne zu erlassen. ²Es kann insbesondere die Anforderungen, die Anerkennung und die Befugnisse von Nachsuchengespannen einschließlich des Führens von und des Schießens mit Schusswaffen regeln.
+
+Art. 38  Verfolgung kranken oder krankgeschossenen Wildes in befriedeten Bezirken
+
+¹Die Verfolgung kranken oder krankgeschossenen Wildes im eigenen Jagdrevier ist in Gebieten zulässig, in denen die Jagd ruht oder nur eine beschränkte Jagdausübung gestattet ist. ²Das gilt nicht für Gebäude, Hofräume und Hausgärten im Sinn von Art. 6 Abs. 1 Nrn. 1 und 2; dem Revierinhaber steht jedoch auch in diesen Fällen das Aneignungsrecht zu; der Grundstückseigentümer oder Nutzungsberechtigte ist zur Herausgabe verpflichtet.
+
+Art. 39  Verwendung von Jagdhunden
+
+(1) ¹Bei jeder Such-, Drück-, Riegel- und Treibjagd sowie bei jeder Jagdart auf Wasserwild sind brauchbare Jagdhunde in genügender Zahl zu verwenden. ²Auch der bei einer anderen Jagdart zur Nachsuche verwendete Hund muß brauchbar sein.
+(2) Die Jagdbehörde kann dem Revierinhaber die Verpflichtung zur Haltung eines zur Nachsuche brauchbaren Jagdhunds auferlegen.
+(3) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Vorschriften über die Feststellung der Brauchbarkeit von Jagdhunden zu erlassen und hierbei Prüfungen vorzuschreiben sowie ihre Durchführung und die Prüfungszulassung zu regeln; mit der Durchführung von Brauchbarkeitsprüfungen und der Feststellung der Brauchbarkeit von Jagdhunden können die anerkannten Vereinigungen der Jäger (Art. 51) betraut werden.
+
+VII. Abschnitt Jagdschutz
+Art. 40  Inhalt des Jagdschutzes; Pflicht zur Ausübung des Jagdschutzes
+
+(1) Der Jagdschutz umfaßt auch den Schutz des Wildes vor Beeinträchtigungen durch dem Jagdrecht nicht unterliegende Tierarten, soweit diese keinem besonderen Schutz nach Naturschutzrecht unterstellt sind, sowie vor aufsichtslosen Hunden und Katzen.
+(2) Der Revierinhaber (Art. 7 Abs. 1 Satz 2) ist verpflichtet, den Jagdschutz (§ 23 des Bundesjagdgesetzes¹) und Absatz 1) in seinem Jagdrevier auszuüben.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 41  Jagdschutzberechtigte
+
+(1) Der Revierinhaber kann zum Schutz der Jagd volljährige, zuverlässige Personen als Jagdaufseher anstellen.
+(2) ¹Für die Bestätigung von Jagdaufsehern (§ 25 Abs. 1 Satz 1 des Bundesjagdgesetzes¹)) ist die Jagdbehörde zuständig. ²Die Bestätigung darf nur versagt werden, wenn der Jagdaufseher nicht Inhaber eines gültigen Jahresjagdscheins ist oder Bedenken gegen seine persönliche Zuverlässigkeit oder fachliche Eignung bestehen. ³ (aufgehoben)
+(3) Neben dem Revierinhaber und dem bestätigten Jagdaufseher übt den Jagdschutz auch die Bayerische Staatliche Polizei aus, soweit er die Sorge für die Einhaltung der zum Schutz des Wildes erlassenen Vorschriften und den Schutz vor Wilderern umfaßt.
+(4) ¹Der Revierinhaber kann auch einem Jagdgast die Ausübung des Jagdschutzes erlauben, soweit er den Schutz des Wildes vor Tieren im Sinn des Art. 40 Abs. 1, vor Futternot und Wildseuchen umfaßt. ²Art. 17 Abs. 3 gilt sinngemäß.
+(5) ¹Die Jagdbehörde kann die Anstellung eines oder mehrerer bestätigter Jagdaufseher verlangen, wenn es zumutbar und zum Jagdschutz notwendig ist oder der Revierinhaber seinen Verpflichtungen zur Hege oder Regulierung des Wildbestands trotz schriftlicher Aufforderung nicht nachkommt. ²Soweit es Reviergröße, Revierbeschaffenheit oder Wildbestand erfordern, kann die Jagdbehörde auch die Anstellung eines oder mehrerer hauptberuflich angestellter bestätigter Jagdaufseher verlangen. ³Bei Hochwildrevieren über 1000 ha soll der bestätigte Jagdaufseher Berufsjäger oder forstlich ausgebildet sein. ⁴Wer Berufsjäger oder forstlich ausgebildet im Sinn von § 25 Abs. 1 Satz 2 des Bundesjagdgesetzes ist, wird durch Rechtsverordnung des Staatsministeriums für Wirtschaft, Landesentwicklung und Energie bestimmt.
+(6) ¹Der Revierinhaber und der bestätigte Jagdaufseher sind verpflichtet, bei Ausübung des Jagdschutzes auf Verlangen des Betroffenen sich auszuweisen, und zwar der Revierinhaber durch Vorzeigen seines Jagdscheins, der Jagdaufseher durch Vorzeigen des Ausweises über seine Bestätigung; dies gilt nicht, wenn die Ausweisung aus Sicherheitsgründen nicht zugemutet werden kann. ²Die bestätigten Jagdaufseher müssen bei der Ausübung ihrer Tätigkeit außerdem ein Dienstabzeichen tragen. ³Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie erläßt im Einvernehmen mit dem Staatsministerium des Innern, für Sport und Integration durch Rechtsverordnung Vorschriften über die Dienstabzeichen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 42  Aufgaben und Befugnisse der Jagdschutzberechtigten
+
+(1) Die zur Ausübung des Jagdschutzes berechtigten Personen sind befugt,
+  1. Personen, die in einem Jagdrevier unberechtigt jagen oder eine sonstige Zuwiderhandlung gegen jagdrechtliche Vorschriften begehen oder außerhalb der zum allgemeinen Gebrauch bestimmten Wege ohne Berechtigung hierzu zur Jagd ausgerüstet angetroffen werden, zur Feststellung ihrer Personalien anzuhalten und ihnen gefangenes oder erlegtes Wild, Waffen, Jagd- und Fanggeräte, Hunde und Frettchen sowie Beizvögel abzunehmen,
+  2. wildernde Hunde und Katzen zu töten. Hunde gelten als wildernd, wenn sie im Jagdrevier erkennbar dem Wild nachstellen und dieses gefährden können. Katzen gelten als wildernd, wenn sie im Jagdrevier in einer Entfernung von mehr als 300 Meter vom nächsten bewohnten Gebäude angetroffen werden. Diese Befugnis erstreckt sich auch auf solche Katzen, die sich in Fallen gefangen haben, die in einer Entfernung von mehr als 300 Meter vom nächsten bewohnten Gebäude aufgestellt worden sind. Sie gilt nicht gegenüber Jagd-, Dienst-, Blinden- und Hirtenhunden, soweit sie als solche kenntlich sind und solange sie von der führenden Person zu ihrem Dienst verwendet werden oder sich aus Anlaß des Dienstes ihrer Einwirkung entzogen haben sowie gegenüber in Fallen gefangenen Katzen, deren Besitzer eindeutig und für den Jagdschutzberechtigten in zumutbarer Weise festgestellt werden können.
+(2) Soweit der Revierinhaber einem Jagdgast nach Art. 41 Abs. 4 die Ausübung des Jagdschutzes übertragen hat, stehen diesem die Befugnisse nach Absatz 1 Nr. 2 ebenfalls zu.
+(3) Die bestätigten Jagdaufseher, die Berufsjäger oder forstlich ausgebildet sind, haben die Aufgaben und Befugnisse der Naturschutzwacht.
+
+Art. 43  Natürliche Äsung; Fütterung des Wildes
+
+(1) ¹Der Schutz und die Pflege der natürlichen Lebensgrundlagen des Wildes sind Aufgabe des Revierinhabers, der im Einvernehmen mit den Grundstückseigentümern oder Nutzungsberechtigten durch Maßnahmen der Reviergestaltung und Äsungsverbesserung die Voraussetzungen dafür schaffen soll, daß das Wild auch in der vegetationsarmen Zeit natürliche Äsung findet. ²Auf Grund anderer Vorschriften bestehende Verpflichtungen bleiben unberührt.
+(2) ¹Durch die Fütterung des Wildes darf die Verwirklichung des Hegeziels (§ 1 Abs. 2 des Bundesjagdgesetzes¹)) nicht gefährdet werden. ²Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung Vorschriften zur Verhinderung einer mißbräuchlichen Wildfütterung zu erlassen.
+(3) ¹Der Revierinhaber ist verpflichtet, in der Notzeit für angemessene Wildfütterung zu sorgen und die dazu erforderlichen Fütterungsanlagen zu unterhalten. ²Das gilt nicht für Rotwild, das auf Grund einer Rechtsverordnung nach Art. 32 Abs. 7 Nr. 3 nicht gehegt werden darf.
+(4) Kommt der Revierinhaber der Verpflichtung nach Absatz 3 trotz Aufforderung durch die Jagdbehörde nicht nach, so kann die Jagdbehörde auf seine Rechnung die Fütterung vornehmen und ausreichende Fütterungsanlagen aufstellen lassen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+VIII. Abschnitt Wild- und Jagdschaden
+Art. 44  Verhinderung übermäßigen Wildschadens auf eingezäunten Waldflächen
+
+Zum Schutz von Forstkulturen und forstlichen Verjüngungsflächen, die gegen das Eindringen von Schalenwild mit den üblichen Schutzvorrichtungen (§ 32 Abs. 2 des Bundesjagdgesetzes¹), Art. 47 Nr. 2) versehen sind und deren Größe 10 ha nicht überschreitet, kann die Jagdbehörde nach § 27 des Bundesjagdgesetzes auf Antrag des Grundeigentümers oder Nutzungsberechtigten anordnen, daß der Revierinhaber unabhängig von den Schonzeiten innerhalb einer bestimmten Frist in bestimmtem Umfang eingewechseltes Schalenwild zu erlegen hat.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 45  Erstattungsausschluß
+
+¹Wildschaden an Grundflächen, auf denen die Jagd nicht ausgeübt werden darf, ist nicht zu ersetzen. ²Die Grundflächen bleiben bei der Berechnung der anteiligen Ersatzleistung für den Wildschaden an anderen Grundstücken (§ 29 Abs. 1 Satz 2 des Bundesjagdgesetzes¹)) außer Ansatz.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 46  Ersatz weiterer Wildschäden
+
+Ist für den ganzen oder teilweisen Verlust der Ernte Ersatz geleistet, so kann wegen eines weiteren Schadens im gleichen Wirtschaftsjahr Ersatz nur verlangt werden, wenn die Neubestellung im Rahmen der üblichen Bewirtschaftung liegt.
+
+Art. 47  Ermächtigungen
+
+Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung
+  1. im Rahmen des § 29 Abs. 4 des Bundesjagdgesetzes¹) die Wildschadensersatzpflicht auf andere Wildarten auszudehnen,
+  2. Bestimmungen über die Verpflichtung zur Leistung von Wildschadensersatz in den Fällen des § 32 Abs. 2 Satz 1 des Bundesjagdgesetzes zu erlassen, soweit sie zur Vermeidung unzumutbarer Wildschäden in der Land- und Forstwirtschaft unerläßlich sind, sowie darüber zu erlassen, welche Schutzvorrichtungen als üblich anzusehen sind (§ 32 Abs. 2 Satz 2 des Bundesjagdgesetzes),
+  3. Vorschriften über die Erhebung von Daten über die Wildschadenssituation (Art, Ausmaß und regionale Verteilung der Wildschäden) und über geleistete Wildschadensbeträge zu erlassen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 47a  Verfahren in Wild- und Jagdschadenssachen
+
+(1) ¹Wild- und Jagdschäden können im ordentlichen Rechtsweg erst geltend gemacht werden, wenn das Vorverfahren nach § 35 des Bundesjagdgesetzes stattgefunden hat. ²Das Vorverfahren führt die Gemeinde im eigenen Wirkungskreis durch; im Fall ihrer Beteiligung die Rechtsaufsichtsbehörde. ³Verspätet angemeldete Ansprüche oder wegen Fehlens eines ersatzfähigen Wild- oder Jagdschadens offensichtlich unbegründete Anträge sind zurückzuweisen. ⁴Im Übrigen wird das Vorverfahren mit der Niederschrift über die gütliche Einigung oder, wenn eine solche nicht erreicht wird, mit dem Erlass des Vorbescheids abgeschlossen. ⁵Gegen den Zurückweisungs- oder Vorbescheid kann binnen einer Notfrist von vier Wochen nach Zustellung Klage vor den ordentlichen Gerichten erhoben werden. ⁶§ 23 des Gerichtsverfassungsgesetzes findet Anwendung.
+(2) Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung die Einzelheiten der Anmeldung (§ 34 des Bundesjagdgesetzes) und des Vorverfahrens zu regeln, einschließlich der Kostentragung und der Zwangsvollstreckung aus der Niederschrift über die gütliche Einigung oder aus dem Vorbescheid.
+
+IX. Abschnitt Wildhandel
+Art. 48  Überwachung des Wildhandels
+
+Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung im Einvernehmen mit dem Staatsministerium für Umwelt und Verbraucherschutz Vorschriften über die behördliche Überwachung des gewerbsmäßigen Ankaufs, Verkaufs und Tausches sowie der gewerbsmäßigen Verarbeitung von Wildbret und die behördliche Überwachung der Wildhandelsbücher zu erlassen (§ 36 Abs. 2 Nr. 1 des Bundesjagdgesetzes¹)).
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+X. Abschnitt Organisation, Zuständigkeit, Verfahren
+Art. 49  Jagdbehörden, Jagdberater
+
+(1) ¹Der Vollzug des Bundesjagdgesetzes¹), dieses Gesetzes und der auf Grund dieser Gesetze erlassenen Rechtsverordnungen ist grundsätzlich Aufgabe des Staates. ²Er obliegt den Jagdbehörden. ³Soweit wesentliche Belange der Land- und Forstwirtschaft berührt sind, sind die Ämter für Ernährung, Landwirtschaft und Forsten zu beteiligen. ⁴Soweit wesentliche Belange des Naturschutzes oder der Landschaftspflege berührt werden, sind diejenigen Naturschutzbehörden zu beteiligen, die dem Zuständigkeitsbereich der Jagdbehörde der vergleichbaren Verwaltungsstufe entsprechen.
+(2) Jagdbehörden im Sinn dieses Gesetzes sind
+  1. das Staatsministerium für Wirtschaft, Landesentwicklung und Energie als oberste Jagdbehörde,
+  2. die Regierungen als höhere Jagdbehörden,
+  3. die Kreisverwaltungsbehörden als untere Jagdbehörden.
+(3) ¹Zur laufenden sachverständigen Beratung der Jagdbehörden sind nach Anhörung des Jagdbeirats (Art. 50) ehrenamtliche Berater (Jagdberater) zu bestellen. ²Die Jagdberater und je ein Stellvertreter werden aus dem Kreis der Jagdscheininhaber für fünf Jagdjahre widerruflich bestellt. ³Die Zahl der Jagdberater soll je Behörde zwei nicht überschreiten. ⁴Ihre Aufgabe und Stellung innerhalb der Jagdbehörde und die Aufwandsentschädigung werden durch Rechtsverordnung geregelt, die vom Staatsministerium für Wirtschaft, Landesentwicklung und Energie zu erlassen ist. ⁵In der Regel sollen die Jagdberater kein wichtiges Amt in einer Organisation der im Jagdbeirat vertretenen Interessengruppen bekleiden.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 50  Jagdbeirat
+
+(1) Zur Beratung aller Angelegenheiten von grundsätzlicher Bedeutung sowie wichtiger Einzelfragen wird bei jeder Jagdbehörde ein Jagdbeirat (§ 37 Abs. 1 des Bundesjagdgesetzes¹)) gebildet.
+(2) Der Jagdbeirat bei der unteren Jagdbehörde besteht aus deren Vertreter als Vorsitzendem und aus fünf Mitgliedern, nämlich je einem Vertreter der Landwirtschaft, der Forstwirtschaft, der Jagdgenossenschaften, der Jäger und des Natur- und Waldschutzes.
+(3) Der Jagdbeirat bei der höheren Jagdbehörde besteht aus deren Vertreter als Vorsitzendem und aus neun Mitgliedern, nämlich aus zwei der Jagdgenossenschaften und je einem Vertreter der Landwirtschaft, der staatlichen und privaten Forstwirtschaft, der Teich- und Fischereiwirtschaft, der Jäger, des Naturschutzes und Waldschutzes.
+(4) ¹Der Jagdbeirat bei der obersten Jagdbehörde besteht aus deren Vertreter als Vorsitzendem und aus 14 Mitgliedern. ²Von diesen müssen drei den Jagdgenossenschaften, je zwei der Landwirtschaft und den Jägern sowie je ein Mitglied der staatlichen und privaten Forstwirtschaft, den Berufsjägern, der Fischerei, dem Tierschutz, dem Naturschutz und Waldschutz angehören.
+(5) ¹Zu den Beratungen des Jagdbeirats können vom Vorsitzenden weitere Sachkundige zugezogen werden. ²Den Trägern öffentlicher Belange ist auf Verlangen Gelegenheit zur Äußerung zu geben.
+(6) ¹Die Mitglieder des Jagdbeirats und je ein Stellvertreter werden durch die Jagdbehörde für fünf Jagdjahre widerruflich bestellt. ²Sie sind ehrenamtlich tätig. ³Sie erhalten auf Antrag Ersatz der ihnen bei der Ausübung der Beiratstätigkeit entstandenen notwendigen Auslagen. ⁴Ein Verdienstausfall wird nicht ersetzt. ⁵Das gleiche gilt für den nach Absatz 5 zugezogenen Sachkundigen. ⁶Das Nähere, insbesondere Bestellung, Aufgaben und Aufwandsentschädigung der Beiräte, regelt das Staatsministerium für Wirtschaft, Landesentwicklung und Energie durch Rechtsverordnung im Einvernehmen mit dem Staatsministerium der Finanzen und für Heimat.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 51  Vereinigungen der Jäger
+
+Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie wird ermächtigt, durch Rechtsverordnung die Mitwirkung von Vereinigungen der Jäger für die Fälle vorzusehen, in denen Jagdscheininhaber gegen die Grundsätze der Weidgerechtigkeit verstoßen (§ 1 Abs. 3, § 37 Abs. 2 des Bundesjagdgesetzes¹)), ferner Voraussetzungen und Verfahren für die Anerkennung von Vereinigungen der Jäger zu bestimmen und diesen über Art. 39 Abs. 3 hinaus weitere nichthoheitliche Aufgaben auf dem Gebiet des Jagdwesens zu übertragen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 52  Sachliche Zuständigkeit
+
+(1) Die oberste Jagdbehörde ist zuständig für
+  1. die Anerkennung von Fachinstituten nach § 19 Abs. 3 des Bundesjagdgesetzes¹),
+  2. die Genehmigung zum Aussetzen oder Ansiedeln fremder Tierarten nach Art. 34 Abs. 2 Satz 1, soweit es sich um Tierarten handelt, die dem Jagdrecht unterliegen; bei anderen Tierarten im Sinn des Art. 34 Abs. 1 entscheidet das Staatsministerium für Umwelt und Verbraucherschutz im Einvernehmen mit dem Staatsministerium für Wirtschaft, Landesentwicklung und Energie,
+  3. die Bestellung ihres Jagdberaters nach Art. 49 Abs. 3 und ihres Jagdbeirats nach Art. 50 Abs. 4 und 6.
+(2) Die höheren Jagdbehörden sind zuständig für
+  1. die Anerkennung von Wildgehegen als Wildpark nach Art. 24 Abs. 1 Satz 1,
+  2. die Zulassung von Ausnahmen nach Art. 31 Abs. 2 Satz 2 und für die Einzelanordnungen nach Art. 31 Abs. 3,
+  3. die Zulassung von Ausnahmen nach Art. 32 Abs. 6 Satz 1,
+  4. die Anerkennung von Nachsuchengespannen nach Art. 37 Abs. 6,
+  5. die Bestellung ihrer Jagdberater nach Art. 49 Abs. 3 und ihrer Jagdbeiräte nach Art. 50 Abs. 3 und 6.
+(3) Die unteren Jagdbehörden sind für die übrigen staatlichen Aufgaben auf dem Gebiet des Jagdwesens zuständig, soweit nicht ausdrücklich etwas anderes bestimmt ist.
+(4) ¹Die oberste Jagdbehörde kann einzelne der ihr oder den höheren Jagdbehörden zustehenden Verwaltungsbefugnisse durch Rechtsverordnung auf nachgeordnete Jagdbehörden übertragen. ²Die oberste Jagdbehörde bestimmt durch Rechtsverordnung die für die Abnahme der Jäger- und Falknerprüfung nach § 15 Abs. 5 Satz 1 und Abs. 7 Satz 1 des Bundesjagdgesetzes zuständigen Behörden.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 53  Örtliche Zuständigkeit
+
+Die für die Erteilung von Jagdscheinen zuständige Jagdbehörde nimmt auch die Eintragungen nach § 11 Abs. 7 des Bundesjagdgesetzes¹) vor.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 54  (aufgehoben)
+
+
+Art. 55  Vorläufige Anordnung
+
+Die Jagdbehörde kann die Ausübung der Jagd und des Jagdschutzes regeln, insbesondere durch einen bestätigten Jagdaufseher für Rechnung der Jagdgenossenschaft, des Jagdberechtigten oder des Revierinhabers vornehmen lassen und die Jagdausübung durch andere verbieten, wenn und solang
+  1. für ein Gebiet der verantwortliche Revierinhaber (Art. 7 Abs. 1 Satz 2) nicht festgestellt werden kann oder eine verantwortliche jagdpachtfähige Person nicht benannt wird (Art. 7 Abs. 2 und 3, Art. 20),
+  2. der Revierinhaber durch ein Verbot nach § 41a des Bundesjagdgesetzes¹) oder Art. 57 gehindert ist, die Jagd auszuüben, oder wenn und solang der Revierinhaber oder die an seiner Stelle verantwortliche Person der Verantwortung nach Art. 7 Abs. 1 trotz wiederholter Aufforderung weiterhin zuwiderhandelt,
+  3. im Fall des Art. 7 Abs. 4 nach zweimaliger Aufforderung der Jagdbehörde ein Mitpächter oder eine verantwortliche Person im Sinn von Art. 7 Abs. 2 nicht als Bevollmächtigter benannt wird und die Mitpächter oder die verantwortlichen Personen ihren Verpflichtungen gegenüber der Jagdbehörde gemeinsam nicht nachkommen; mit der Ausübung der Jagd und des Jagdschutzes kann auch ein Mitpächter oder eine verantwortliche Person beauftragt werden,
+  4. ein bestätigter Jagdaufseher oder Berufsjäger auf Verlangen der Jagdbehörde nicht angestellt wird (Art. 41 Abs. 5),
+  5. nach Beendigung eines Jagdpachtvertrags die Jagd oder der Jagdschutz nicht ausgeübt wird,
+  6. während eines Beanstandungsverfahrens der Jagdpächter die Jagd nach § 12 Abs. 4 des Bundesjagdgesetzes nicht ausüben darf,
+  7. über die Rechtsgültigkeit oder Beendigung des Jagdpachtvertrags ein Rechtsstreit anhängig ist oder trotz befristeter Aufforderung der Vertragsparteien durch die Jagdbehörde nicht anhängig gemacht wird; die Aufforderung ist ohne Rücksicht darauf zulässig, ob zwischen den Vertragsparteien Meinungsverschiedenheiten über die Gültigkeit des Jagdpachtvertrags bestehen.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+XI. Abschnitt Ahndungsvorschriften
+Art. 56  Ordnungswidrigkeiten
+
+(1) Mit Geldbuße bis zu fünftausend Euro kann belegt werden, wer
+  1. vorsätzlich oder fahrlässig einer vollziehbaren Anordnung nach Art. 21 Abs. 4 zuwiderhandelt,
+  2. entgegen Art. 22 Abs. 3 Satz 1 die Nester und Gelege des Federwildes beschädigt, wegnimmt oder zerstört,
+  3. vorsätzlich oder fahrlässig entgegen Art. 23 Abs. 2 Satz 1, Abs. 4 Sätze 2 bis 4, Art. 25 Satz 2 Wildgehege oder Wintergatter errichtet, erweitert oder betreibt,
+  3a. vorsätzlich oder fahrlässig die Jagd mit Fallen ausübt, ohne den erforderlichen Nachweis der Kenntnisse über die Ausübung der Jagd mit Fallen zu besitzen,
+  4. entgegen Art. 29 Abs. 1, Abs. 2 Nrn. 2 bis 7 und Art. 29a Abs. 1 Satz 2, Abs. 2 Satz 1 und Abs. 3
+    a) als Jagdausübender eine zeitgerechte und fachgemäße Nachsuche auf krankgeschossenes Wild weder selbst durchführt noch veranlaßt,
+    b) die Jagd auf Wild mit Fanggeräten oder Fangvorrichtungen ausübt,
+    c) die Jagd auf sonstiges Haarwild zur Nachtzeit ausübt,
+    d) die Jagd auf Schalenwild, mit Ausnahme von Schwarzwild, als Treibjagd ausübt,
+    e) das Wild durch Lappen oder sonstige Mittel hindert, aus seinen oder in seine Tageseinstände zu wechseln,
+    f) die Jagd auf Wild ausübt, das durch Naturkatastrophen in Not geraten oder zum Verlassen der Einstände gezwungen worden ist,
+    g) die Jagd unter Verwendung von Betäubungs- oder Lähmungsmitteln, Sprengstoffen, Gasen, elektrischem Strom oder von Schußwaffen mit Schalldämpfern ausübt oder
+    h) Fangeisen verwendet, deren Betriebssicherheit nicht überprüft ist oder die nicht dauerhaft gekennzeichnet sind, Fangeisen außerhalb geschlossener Räume oder Fangbunker oder Fanggärten aufstellt oder nicht ordnungsgemäß verblendet oder die Verwendung von Schlagfallen nicht der Jagdbehörde anzeigt,
+  5. entgegen Art. 31 Abs. 2 Satz 1 Schalenwild in Wintergattern erlegt,
+  6. vorsätzlich oder fahrlässig entgegen Art. 32 Abs. 2 Satz 1, Abs. 4 oder 5
+    a) den Abschußplan für Schalenwild nicht ordnungsgemäß erfüllt,
+    b) die schriftliche Abschußmeldung oder die Streckenliste nicht ordnungsgemäß erstattet oder führt oder diese der Jagdbehörde auf Verlangen nicht vorzeigt oder
+    c) der Jagdbehörde den Abschuß von krankem Wild über den Abschußplan hinaus oder während der Schonzeit nicht unverzüglich mitteilt oder ihr oder einem von ihr Beauftragten das erlegte Wild auf Verlangen nicht vorzeigt,
+  7. (aufgehoben)
+  8. vorsätzlich oder fahrlässig entgegen Art. 37 Abs. 1, 2 oder 3
+    a) es unterläßt, das Überwechseln von krankgeschossenem Wild dem Inhaber des Nachbarreviers oder dessen Vertreter unverzüglich anzuzeigen oder
+    b) beim Überschreiten der Grenze geladene Langwaffen mit sich führt, Wild fortschafft, das Erlegen nicht unverzüglich anzeigt oder Wild dem Inhaber des Nachbarreviers nicht abliefert,
+  9. vorsätzlich oder fahrlässig entgegen Art. 39 Abs. 1 bei der Such-, Drück-, Riegel- oder Treibjagd oder bei der Jagd auf Wasserwild sowie bei der Nachsuche auf krankgeschossenes Wild brauchbare Jagdhunde nicht verwendet,
+  10. (aufgehoben)
+  11. ohne Begleitung oder schriftliche Erlaubnis des Revierinhabers aufsichtslosen Hunden oder Katzen mit der Schußwaffe nachstellt oder solche erlegt,
+  12. (aufgehoben)
+  13. vorsätzlich oder fahrlässig entgegen Art. 43 Abs. 3 Satz 1 seiner Verpflichtung, in der Notzeit für angemessene Wildfütterung zu sorgen und die dazu erforderlichen Fütterungsanlagen zu unterhalten, nicht nachkommt,
+  14. einer vollziehbaren Anordnung nach Art. 55 über die Ausübung der Jagd und des Jagdschutzes zuwiderhandelt,
+  15. vorsätzlich oder fahrlässig den Vorschriften einer auf Grund der Art. 21, 22a, 23 Abs. 7, Art. 29 Abs. 5 Satz 1, Art. 29a Abs. 4 Satz 1, Art. 31 Abs. 1 Satz 2 und Abs. 3, Art. 32 Abs. 7, Art. 33 Abs. 1 Nr. 4, Art. 34 Abs. 3, Art. 43 Abs. 2 Satz 2, Art. 47 Nr. 3 und Art. 48 erlassenen Rechtsverordnung, die für einen bestimmten Tatbestand auf diese Bußgeldvorschrift verweist, zuwiderhandelt,
+  16. (aufgehoben)
+(2) Mit Geldbuße kann belegt werden, wer
+  1. (aufgehoben)
+  2. entgegen Art. 16 Abs. 3, auch in Verbindung mit Art. 17 Abs. 2 Satz 1, der Jagdbehörde beim Erwerb des Jagdscheins unrichtige Angaben macht,
+  3. vorsätzlich oder fahrlässig entgegen Art. 17 Abs. 3 als Jagdgast ohne Begleitung eines Revierinhabers, eines angestellten Jägers oder Jagdaufsehers die Jagd ausübt, ohne den Erlaubnisschein bei sich zu führen, oder diesen dem Jagdschutzberechtigten auf Verlangen nicht zur Prüfung aushändigt,
+  4. (aufgehoben)
+  5. einer vollziehbaren Anordnung nach Art. 32 Abs. 4 Satz 2 über den körperlichen Nachweis der Erfüllung des Abschußplans zuwiderhandelt,
+  6. entgegen Art. 35 Abs. 2 bei der Benutzung eines Jägernotwegs geladene Langwaffen oder nichtangeleinte Hunde mitführt,
+  7. trotz Aufforderung des Berechtigten Jagdeinrichtungen nicht verläßt,
+  8. trotz Abmahnung durch den Berechtigten die Jagdausübung dadurch vereitelt, daß er, ohne die Land-, Forst- oder Fischereiwirtschaft auszuüben, das Wild vergrämt,
+  9. Hunde in einem Jagdrevier unbeaufsichtigt frei laufen läßt,
+  10. entgegen Art. 41 Abs. 6 Satz 1 als Revierinhaber oder bestätigter Jagdaufseher bei Ausübung des Jagdschutzes auf Verlangen des Betroffenen sich nicht ausweist,
+  11. entgegen Art. 42 Abs. 1 Nr. 1 und Abs. 3, auch in Verbindung mit Art. 43 Abs. 3 Nr. 1 des Bayerischen Naturschutzgesetzes⁴), der Aufforderung eines für das Jagdrevier zuständigen Jagdschutzberechtigten, Angaben über die Person zu machen, nicht oder nicht richtig nachkommt, soweit die Tat nicht nach § 111 des Gesetzes über Ordnungswidrigkeiten⁸) mit Geldbuße bedroht ist,
+  12.
+    a) vorsätzlich oder fahrlässig an Orten, an denen ihm die Ausübung des Jagdrechts nicht zusteht, Besitz an lebendem oder verendetem Wild oder an Fallwild und Abwurfstangen sowie Eiern des dem Jagdrecht unterliegenden Federwildes erlangt und diese Gegenstände nicht binnen drei Tagen entweder dem Revierinhaber (Art. 7 Abs. 1) oder der nächsterreichbaren Polizeidienststelle abliefert oder den Sachverhalt anzeigt,
+    b) als Führer eines Fahrzeugs Schalenwild (§ 2 Abs. 3 des Bundesjagdgesetzes¹)) durch An- oder Überfahren verletzt oder tötet und dies nicht unverzüglich einer der in Buchstabe a genannten Stellen anzeigt.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+⁴) [Amtl. Anm.:] BayRS 791-1-U
+⁸) [Amtl. Anm.:] BGBl. FN 454-1
+
+Art. 57  Verbot der Jagdausübung
+
+(1) Wird gegen jemanden wegen einer Ordnungswidrigkeit nach Art. 56, die er unter grober oder beharrlicher Verletzung der Pflichten bei der Jagdausübung begangen hat, eine Geldbuße festgesetzt, so kann ihm in der Entscheidung für die Dauer von einem Monat bis zu sechs Monaten verboten werden, die Jagd auszuüben.
+(2) ¹Das Verbot der Jagdausübung wird mit der Rechtskraft der Entscheidung wirksam. ²Für seine Dauer wird ein erteilter Jagdschein amtlich verwahrt. ³Wird er nicht freiwillig herausgegeben, so ist er zu beschlagnahmen.
+(3) ¹Ist ein Jagdschein amtlich zu verwahren, so wird die Verbotsfrist erst von dem Tag an gerechnet, an dem dies geschieht. ²In die Verbotsfrist wird die Zeit nicht eingerechnet, in welcher der Täter auf behördliche Anordnung in einer Anstalt verwahrt wird.
+(4) Über den Beginn der Verbotsfrist nach Absatz 3 Satz 1 ist der Täter im Anschluß an die Verkündung der Entscheidung oder bei deren Zustellung zu belehren.
+
+Art. 58  Einziehung
+
+¹Die durch eine Ordnungswidrigkeit nach Art. 56 gewonnenen oder erlangten oder die zu ihrer Begehung gebrauchten oder dazu bestimmten Gegenstände einschließlich der bei der Ordnungswidrigkeit verwendeten Verpackungs- und Beförderungsmittel können eingezogen werden. ²Es können auch Gegenstände eingezogen werden, auf die sich die Ordnungswidrigkeit bezieht. ³§ 23 des Gesetzes über Ordnungswidrigkeiten⁸) ist anzuwenden.
+⁸) [Amtl. Anm.:] BGBl. FN 454-1
+
+XII. Abschnitt Übergangs- und Schlußvorschriften
+Art. 59  Enteignende Maßnahmen
+
+(1) Hat eine Behörde auf Grund dieses Gesetzes eine Maßnahme getroffen, die eine Enteignung darstellt oder einer solchen gleichkommt, insbesondere weil sie eine wesentliche Nutzungsbeschränkung darstellt, so ist dem Eigentümer oder dem sonstigen Berechtigten nach den Vorschriften des Bayerischen Gesetzes über die entschädigungspflichtige Enteignung⁶) Entschädigung in Geld zu leisten.
+(2) ¹Der Grundstückseigentümer kann verlangen, daß der Entschädigungspflichtige das Grundstück übernimmt, soweit es ihm infolge der enteignenden Maßnahme wirtschaftlich nicht mehr zumutbar ist, das Grundstück zu behalten oder es in der bisherigen oder in einer anderen zulässigen Art zu nutzen. ²Kommt eine Einigung über die Übernahme des Grundstücks nicht zustande, kann der Eigentümer das Enteignungsverfahren beantragen; im übrigen gelten die Vorschriften des Bayerischen Gesetzes über die entschädigungspflichtige Enteignung sinngemäß.
+⁶) [Amtl. Anm.:] BayRS 2141-1-I
+
+Art. 60  (aufgehoben)
+
+
+Art. 61  Ausführungsvorschriften
+
+Das Staatsministerium für Wirtschaft, Landesentwicklung und Energie erläßt im Einvernehmen mit den beteiligten Staatsministerien die zum Vollzug dieses Gesetzes erforderlichen Ausführungsvorschriften und die Rechtsverordnungen, die das Bundesjagdgesetz¹) und seine Ausführungsvorschriften den Ländern vorbehalten.
+¹) [Amtl. Anm.:] BGBl. FN 792-1
+
+Art. 62  Verweisungen auf aufgehobene Vorschriften
+
+Soweit in anderen Gesetzen und Verordnungen auf durch dieses Gesetz aufgehobene Vorschriften verwiesen wird, treten die entsprechenden Vorschriften dieses Gesetzes an ihre Stelle.
+
+Art. 63  (Änderungsbestimmung)
+
+
+Art. 64  Inkrafttreten; Aufhebung von Vorschriften
+
+(1) Dieses Gesetz tritt am 1. Januar 1979 in Kraft.⁹)
+(2) (gegenstandslos)
+(3) Das Gesetz über das Verfahren in Wild- und Jagdschadenssachen¹⁰) vom 12. August 1953 (BayBS IV S. 575) tritt mit Inkrafttreten der Rechtsverordnung nach Art. 47 Nr. 3 außer Kraft.
+⁹) [Amtl. Anm.:] Betrifft die ursprüngliche Fassung vom 13. Oktober 1978 (GVBl S. 678).
+¹⁰) [Amtl. Anm.:] BayRS 792-4-E
+
diff --git a/src/main/resources/sampledata/BayJG/SOURCES b/src/main/resources/sampledata/BayJG/SOURCES
index cff1afe..964ecc4 100644
--- a/src/main/resources/sampledata/BayJG/SOURCES
+++ b/src/main/resources/sampledata/BayJG/SOURCES
@@ -2,6 +2,16 @@
 - Bayerisches Jagdgesetz (BayJG) vom 13. Oktober 1978 (BayRS 792-1-W)
 - https://www.gesetze-bayern.de/Content/Document/BayJG
   (BayJG.pdf, konsolidierte Fassung nach dem Änderungsgesetz)
+- BayJG-alt.txt: die vor dem Änderungsgesetz geltende Fassung (Stand
+  nach der Änderung vom 23.07.2024, GVBl. S. 247) im kanonischen
+  Klartext-Format des BayRechtLoaders. Abgeleitet am 17.07.2026 aus den
+  in der Wayback Machine archivierten Einzelnorm-Seiten
+  http://web.archive.org/web/<ts>/https://www.gesetze-bayern.de/Content/Document/BayJG-<n>
+  (je Artikel der jüngste Schnappschuss vor dem 31.03.2026;
+  <sup>-Satznummern und Fußnotenmarker als Unicode-Superskripte,
+  Aufzählungen in gii-üblicher Einrückung, Gliederungs-Überschriften aus
+  den BayJG-G<k>-Abschnittsseiten). Basis des Akzeptanztests
+  EndToEndTest.bayJgGvblAcceptance.
 
 Änderungsgesetz:
 - Gesetz zur Änderung des Bayerischen Jagdgesetzes und weiterer
diff --git a/src/test/java/eu/mulk/aendggner/EndToEndTest.java b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
index 0b7820d..2e19090 100644
--- a/src/test/java/eu/mulk/aendggner/EndToEndTest.java
+++ b/src/test/java/eu/mulk/aendggner/EndToEndTest.java
@@ -217,4 +217,97 @@
     assertThat(neueNorm.titel()).isEqualTo("Außerkrafttreten");
     assertThat(neueNorm.gesamtText()).contains("9. Dezember 2026 außer Kraft");
   }
+
+  /**
+   * Bayerisches Landesrecht (Akzeptanzfall der fünften Welle): altes BayJG (Klartext, aus der
+   * archivierten Fassung von gesetze-bayern.de abgeleitet) + GVBl-Heft 6/2026. §§ 1 und 2 des
+   * Änderungsgesetzes betreffen das BayJG; alle Befehle werden erkannt und angewandt.
+   */
+  @Test
+  void bayJgGvblAcceptance() throws Exception {
+    var alt = SAMPLEDATA.resolve("BayJG/BayJG-alt.txt");
+    var pdf = SAMPLEDATA.resolve("BayJG/gvbl-2026-06.pdf");
+    assumeTrue(Files.exists(alt) && Files.exists(pdf), "BayJG-Beispieldaten fehlen");
+
+    // 1. Stammgesetz laden (Art.-gegliedert, amtliche Satznummern als Superskripte).
+    var gesetz = new eu.mulk.aendggner.gesetz.bayern.BayRechtLoader().load(alt);
+    assertThat(gesetz.jurabk()).isEqualTo("BayJG");
+    assertThat(gesetz.langue()).isEqualTo("Bayerisches Jagdgesetz");
+    assertThat(gesetz.norm("Art. 1").orElseThrow().absaetze().get(0).text())
+        .startsWith("¹Die freilebende Tierwelt");
+
+    // 2. GVBl-Heft extrahieren (Superskript-Erhalt; Kolumnentitel entfernt).
+    var text =
+        TextBereiniger.bereinige(
+            new PatchTextExtraktor(eu.mulk.aendggner.aenderung.parse.SuperskriptModus.BEHALTEN)
+                .extrahiere(pdf));
+    assertThat(text).doesNotContain("Gesetz- und Verordnungsblatt Nr. 6/2026 ");
+    assertThat(text).contains("für die kurzfristige Vermietung");
+
+    // 3. Parsen: §§ 1 und 2 betreffen das BayJG (nicht aber die AVBayJG-§§ 4 und 5,
+    //    deren Titel das BayJG nur als Genitiv-Attribut nennt); alles wird erkannt.
+    var parseErgebnis = new AenderungsgesetzParser().parse(text, gesetz, null);
+    assertThat(parseErgebnis.artikel()).containsExactly("1", "2");
+    assertThat(parseErgebnis.befehle()).hasSize(154);
+    assertThat(parseErgebnis.befehle()).noneMatch(b -> b instanceof UnbekannterBefehl);
+
+    // 4. Anwenden auf die alte Fassung. Von 154 Befehlen bleiben genau fünf als „manuell prüfen“
+    //    stehen — allesamt Folgeänderungen innerhalb zweier mehrschrittiger Umnummerierungs-
+    //    sequenzen, die ÄndGgner bewusst nicht automatisch auflöst (statt fehlerhaft zu raten):
+    //      * Art. 29a (§ 1 Nr. 23): ein vorangestellter Absatz und die Bereichs-Umnummerierung
+    //        „Die bisherigen Abs. 1 bis 3 werden die Abs. 2 bis 4“ verschieben die Absatzzählung;
+    //        die auf den neuen Abs. 5 zielenden Wort-/Satzbefehle finden ihren Alttext nicht mehr.
+    //      * Art. 56 (§ 1 Nr. 48): eine umfangreiche Neunummerierung des Bußgeldkatalogs
+    //        (Einfügen der Nrn. 5–7 und 13, Verschieben von Nr. 6→9, 11→12 …) verschiebt die
+    //        Zielnummern der begleitenden Buchstaben-/Wortänderungen.
+    //    Diese Residuen sind exakt gepinnt; sie landen mit Begründung im Abschnitt „Manuell prüfen“
+    //    der Synopse und werden nie stillschweigend verworfen.
+    var anwendung = BefehlAnwender.anwenden(gesetz, parseErgebnis.befehle());
+    assertThat(anwendung.protokoll()).hasSameSizeAs(parseErgebnis.befehle());
+    var manuellPfade =
+        anwendung.protokoll().stream()
+            .filter(a -> a.status() == BefehlAnwender.Status.MANUELL_PRUEFEN)
+            .map(a -> a.befehl().provenienz().gliederungsPfad())
+            .toList();
+    assertThat(manuellPfade)
+        .containsExactlyInAnyOrder(
+            "23. c) aa)", "23. c) cc)", "48. a) ee)", "48. a) gg)", "48. b) cc)");
+
+    // 5. Stichproben: § 2 (in Kraft 1.1.2027) hebt Art. 28 Abs. 1 Satz 4 auf und nummeriert
+    //    Satz 5 um; § 1 Nr. 16 stellt Art. 22a die Abs. 1 bis 4 voran.
+    var art28 = anwendung.neu().norm("Art. 28").orElseThrow();
+    var abs1 = art28.absaetze().get(0);
+    assertThat(abs1.text()).doesNotContain("⁵");
+    var art22a = anwendung.neu().norm("Art. 22a").orElseThrow();
+    assertThat(art22a.absaetze().size()).isGreaterThanOrEqualTo(5);
+    assertThat(art22a.absaetze().get(0).nummer()).isEqualTo("1");
+
+    // 6. Synopse rendern.
+    var synopse = SynopseBuilder.baue(gesetz, anwendung, parseErgebnis.warnungen(), false);
+    var html = HtmlRenderer.rendere(synopse, "E2E-Test BayJG");
+    assertThat(html).contains("Art. 29");
+  }
+
+  /** Landtags-Gesetzentwurf (Ltg-Drs. 19/9707) auf derselben alten Fassung. */
+  @Test
+  void bayJgLandtagsEntwurf() throws Exception {
+    var alt = SAMPLEDATA.resolve("BayJG/BayJG-alt.txt");
+    var pdf = SAMPLEDATA.resolve("BayJG/Ltg-Drs-19-9707_Gesetzentwurf.pdf");
+    assumeTrue(Files.exists(alt) && Files.exists(pdf), "BayJG-Beispieldaten fehlen");
+
+    var gesetz = new eu.mulk.aendggner.gesetz.bayern.BayRechtLoader().load(alt);
+    var text =
+        TextBereiniger.bereinige(
+            new PatchTextExtraktor(eu.mulk.aendggner.aenderung.parse.SuperskriptModus.BEHALTEN)
+                .extrahiere(pdf));
+    var parseErgebnis = new AenderungsgesetzParser().parse(text, gesetz, null);
+
+    // Nur § 1 des Entwurfs ändert das BayJG; Vorblatt und Begründung erzeugen keine Befehle.
+    assertThat(parseErgebnis.artikel()).containsExactly("1");
+    assertThat(parseErgebnis.befehle()).hasSize(154);
+    assertThat(parseErgebnis.befehle()).noneMatch(b -> b instanceof UnbekannterBefehl);
+
+    var anwendung = BefehlAnwender.anwenden(gesetz, parseErgebnis.befehle());
+    assertThat(anwendung.protokoll()).hasSameSizeAs(parseErgebnis.befehle());
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParserTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParserTest.java
new file mode 100644
index 0000000..a8ec3aa
--- /dev/null
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/AenderungsgesetzParserTest.java
@@ -0,0 +1,128 @@
+package eu.mulk.aendggner.aenderung.parse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import eu.mulk.aendggner.aenderung.Aenderungsbefehl;
+import eu.mulk.aendggner.gesetz.Gesetz;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class AenderungsgesetzParserTest {
+
+  private static final Gesetz BAYJG =
+      new Gesetz("BayJG", "Bayerisches Jagdgesetz", null, List.of(), List.of());
+
+  private static final Gesetz UWG =
+      new Gesetz(
+          "UWG", "Gesetz gegen den unlauteren Wettbewerb", "UWG-Langtitel", List.of(), List.of());
+
+  @Test
+  void teiltParagraphenGegliedertesAenderungsgesetz() {
+    // Bayerischer Stil: das Änderungsgesetz gliedert sich in §§; § 1 und § 2 treffen dasselbe
+    // Stammgesetz, § 3 ein anderes; Inkrafttretens-§ ohne Änderungsformel wird nicht gewählt.
+    var text =
+        """
+        § 1
+        Änderung des
+        Bayerischen Jagdgesetzes
+        Das Bayerische Jagdgesetz (BayJG) in der in der Bayerischen Rechtssammlung (BayRS 792-1-W) veröffentlichten bereinigten Fassung, das zuletzt durch § 5 des Gesetzes vom 23. Juli 2024 (GVBl. S. 247) geändert worden ist, wird wie folgt geändert:
+        1. Art. 1 wird wie folgt geändert:
+        a) In Abs. 2 Satzteil vor Nr. 1 wird die Angabe „Bundesjagdgesetz“ durch die Angabe „BJagdG“ ersetzt.
+        b) Fußnote 1 wird aufgehoben.
+        § 2
+        Weitere Änderung des
+        Bayerischen Jagdgesetzes
+        Das Bayerische Jagdgesetz (BayJG) in der in der Bayerischen Rechtssammlung (BayRS 792-1-W) veröffentlichten bereinigten Fassung, das zuletzt durch § 1 dieses Gesetzes geändert worden ist, wird wie folgt geändert:
+        Art. 28 Abs. 1 wird wie folgt geändert:
+        1. Satz 4 wird aufgehoben.
+        2. Satz 5 wird Satz 4.
+        § 3
+        Änderung des
+        Bayerischen Umweltinformationsgesetzes
+        Art. 7 Abs. 2 des Bayerischen Umweltinformationsgesetzes (BayUIG) vom 8. Dezember 2006 (GVBl. S. 933, BayRS 2129-1-4-U), das zuletzt durch § 10 des Gesetzes vom 23. Dezember 2024 (GVBl. S. 605) geändert worden ist, wird wie folgt geändert:
+        1. Der Wortlaut wird Satz 1.
+        § 4
+        Inkrafttreten
+        Dieses Gesetz tritt am 1. April 2026 in Kraft.
+        """;
+
+    var ergebnis = new AenderungsgesetzParser().parse(text, BAYJG, null);
+
+    assertThat(ergebnis.artikel()).containsExactly("1", "2");
+    // § 2: Vorspann-Rahmen „Art. 28 Abs. 1“ wird Kontext der Punkte.
+    var aufhebung =
+        ergebnis.befehle().stream()
+            .filter(b -> b instanceof Aenderungsbefehl.Aufhebung)
+            .map(Aenderungsbefehl::stelle)
+            .map(s -> s.anzeigeText())
+            .toList();
+    assertThat(aufhebung).contains("Art. 28 Absatz 1 Satz 4");
+  }
+
+  @Test
+  void eingebettetesRahmenzielSetztKontext() {
+    var bayUig =
+        new Gesetz(
+            "BayUIG", "Bayerisches Umweltinformationsgesetz", null, List.of(), List.of());
+    var text =
+        """
+        § 3
+        Änderung des
+        Bayerischen Umweltinformationsgesetzes
+        Art. 7 Abs. 2 des Bayerischen Umweltinformationsgesetzes (BayUIG) vom 8. Dezember 2006 (GVBl. S. 933, BayRS 2129-1-4-U), das zuletzt durch § 10 des Gesetzes vom 23. Dezember 2024 (GVBl. S. 605) geändert worden ist, wird wie folgt geändert:
+        1. Der Wortlaut wird Satz 1.
+        2. Folgender Satz 2 wird angefügt:
+        „²Die Voraussetzungen nach Satz 1 Nr. 2 sind insbesondere gegeben.“
+        """;
+
+    var ergebnis = new AenderungsgesetzParser().parse(text, bayUig, null);
+
+    assertThat(ergebnis.artikel()).containsExactly("3");
+    // Das eingebettete Ziel „Art. 7 Abs. 2“ ist Kontext aller Punkte — nicht etwa das „§ 10“
+    // aus der Zitierkette der Änderungshistorie.
+    assertThat(ergebnis.befehle())
+        .allSatisfy(
+            befehl ->
+                assertThat(befehl.stelle().anzeigeText()).startsWith("Art. 7 Absatz 2"));
+  }
+
+  @Test
+  void artikelUeberschriftenUnterdrueckenParagraphenModus() {
+    // Ein Bundes-Änderungsgesetz mit unzitiert abgedrucktem Ablösegesetz enthält freistehende
+    // „§ N“-Zeilen — sie dürfen nicht als äußere Gliederung gedeutet werden.
+    var text =
+        """
+        Artikel 1
+        Das Gesetz gegen den unlauteren Wettbewerb vom 3. Juli 2004, das zuletzt geändert worden ist, wird wie folgt geändert:
+        1. In § 5 wird die Angabe „alt“ durch die Angabe „neu“ ersetzt.
+        Artikel 2
+        § 1
+        Dieses Gesetz tritt am 1. Januar 2027 in Kraft.
+        """;
+
+    var ergebnis = new AenderungsgesetzParser().parse(text, UWG, null);
+
+    assertThat(ergebnis.artikel()).containsExactly("1");
+    assertThat(ergebnis.befehle()).hasSize(1);
+    assertThat(ergebnis.befehle().get(0)).isInstanceOf(Aenderungsbefehl.Ersetzung.class);
+  }
+
+  @Test
+  void artikelFilterImParagraphenModusVerlangtAenderungsformel() {
+    var text =
+        """
+        § 1
+        Das Bayerische Jagdgesetz (BayJG), das zuletzt geändert worden ist, wird wie folgt geändert:
+        1. In Art. 1 wird die Angabe „alt“ durch die Angabe „neu“ ersetzt.
+        § 2
+        Dieses Gesetz tritt am 1. April 2026 in Kraft.
+        """;
+
+    // § 2 ist der Inkrafttretens-§ ohne Änderungsformel: der Filter wählt ihn nicht.
+    var ergebnis = new AenderungsgesetzParser().parse(text, BAYJG, "2");
+    assertThat(ergebnis.artikel()).isEmpty();
+
+    var eins = new AenderungsgesetzParser().parse(text, BAYJG, "1");
+    assertThat(eins.artikel()).containsExactly("1");
+  }
+}
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
index f8cfe82..8cf9eea 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/BefehlErkennerTest.java
@@ -1026,4 +1026,121 @@
     assertThat(ersetzung.alt()).isEqualTo("einer Rechtsverordnung nach § 14,");
     assertThat(ersetzung.neu()).isEqualTo("§ 14 Absatz 8,");
   }
+
+  // --- Bayerisches Landesrecht ---------------------------------------------------------------
+
+  private static final Stelle ART_22 = new Stelle(List.of(new Stelle.Paragraph("22", "Art.")));
+
+  @Test
+  void erkenntBayerischeErsetzungMitAbkuerzungen() {
+    var befehl =
+        erkenne(
+            "In Abs. 2 Satz 1 Nr. 1 wird die Angabe „des Bundesbaugesetzes“ durch die Angabe"
+                + " „des Baugesetzbuchs (BauGB)“ ersetzt.",
+            new Stelle(List.of(new Stelle.Paragraph("6", "Art."))));
+
+    assertThat(befehl).containsInstanceOf(Ersetzung.class);
+    var ersetzung = (Ersetzung) befehl.orElseThrow();
+    assertThat(ersetzung.stelle().anzeigeText()).isEqualTo("Art. 6 Absatz 2 Satz 1 Nummer 1");
+  }
+
+  @Test
+  void erkenntFussnotenAufhebung() {
+    var einzeln = erkenne("Fußnote 1 wird aufgehoben.", ART_22);
+    assertThat(einzeln).containsInstanceOf(Aenderungsbefehl.FussnotenAufhebung.class);
+    assertThat(((Aenderungsbefehl.FussnotenAufhebung) einzeln.orElseThrow()).nummern())
+        .containsExactly("1");
+
+    var mehrere = erkenne("Die Fußnoten 9 und 10 werden aufgehoben.", ART_22);
+    assertThat(mehrere).containsInstanceOf(Aenderungsbefehl.FussnotenAufhebung.class);
+    assertThat(((Aenderungsbefehl.FussnotenAufhebung) mehrere.orElseThrow()).nummern())
+        .containsExactly("9", "10");
+  }
+
+  @Test
+  void erkenntSatznummerierungsStreichungImVerbund() {
+    // GVBl 2026 S. 113, Nr. 15 c) aa) — exakt die Verbundform des Belegdokuments.
+    var befehl =
+        erkenne(
+            "In Satz 1 wird die Satznummerierung „1“ gestrichen und die Angabe „Absätzen 1"
+                + " und 2“ wird durch die Angabe „Abs. 1 und 2“ ersetzt.",
+            ART_22);
+
+    assertThat(befehl).containsInstanceOf(Sammelbefehl.class);
+    var teile = ((Sammelbefehl) befehl.orElseThrow()).teilbefehle();
+    assertThat(teile.get(0)).isInstanceOf(Aenderungsbefehl.SatznummerierungStreichung.class);
+    var streichung = (Aenderungsbefehl.SatznummerierungStreichung) teile.get(0);
+    assertThat(streichung.nummer()).isEqualTo("1");
+    assertThat(streichung.stelle().anzeigeText()).isEqualTo("Art. 22 Satz 1");
+    assertThat(teile.get(1)).isInstanceOf(Ersetzung.class);
+
+    var einfach = erkenne("In Satz 1 wird die Satznummerierung „1“ gestrichen.", ART_22);
+    assertThat(einfach).containsInstanceOf(Aenderungsbefehl.SatznummerierungStreichung.class);
+  }
+
+  @Test
+  void erkenntBayerischeWortlautFormen() {
+    var zuSatz = erkenne("Der Wortlaut wird Satz 1.", ART_22);
+    assertThat(zuSatz).containsInstanceOf(Aenderungsbefehl.WortlautZuSatz.class);
+
+    var zuAbsatz = erkenne("Der bisherige Wortlaut wird Abs. 5.", ART_22);
+    assertThat(zuAbsatz).containsInstanceOf(WortlautZuAbsatz.class);
+    assertThat(((WortlautZuAbsatz) zuAbsatz.orElseThrow()).nummer()).isEqualTo("5");
+
+    var voranstellung =
+        erkenne(
+            "Dem Wortlaut werden die folgenden Abs. 1 bis 4 vorangestellt: „(1) Erster."
+                + " (2) Zweiter. (3) Dritter. (4) Vierter.“",
+            ART_22);
+    assertThat(voranstellung).containsInstanceOf(Aenderungsbefehl.WortlautVoranstellung.class);
+    assertThat(((Aenderungsbefehl.WortlautVoranstellung) voranstellung.orElseThrow()).text())
+        .contains("(3) Dritter.");
+  }
+
+  @Test
+  void erkenntWortlautZuAbsatzMitFolgeklausel() {
+    // „Der bisherige Wortlaut wird Abs. 5 und in Halbsatz 1 wird …“ — die lokative Folgeklausel
+    // bezieht sich auf den soeben nummerierten Absatz.
+    var befehl =
+        erkenne(
+            "Der bisherige Wortlaut wird Abs. 5 und in Halbsatz 1 wird die Angabe „Das"
+                + " Staatsministerium“ durch die Angabe „Die oberste Jagdbehörde“ ersetzt.",
+            ART_22);
+
+    assertThat(befehl).containsInstanceOf(Sammelbefehl.class);
+    var teile = ((Sammelbefehl) befehl.orElseThrow()).teilbefehle();
+    assertThat(teile.get(0)).isInstanceOf(WortlautZuAbsatz.class);
+    assertThat(teile.get(1)).isInstanceOf(Ersetzung.class);
+    assertThat(((Ersetzung) teile.get(1)).stelle().anzeigeText())
+        .isEqualTo("Art. 22 Absatz 5 Halbsatz 1");
+  }
+
+  @Test
+  void erkenntSatzUmnummerierungMitErsetzungsKlausel() {
+    // GVBl 2026 S. 113, Nr. 23 c) cc).
+    var befehl =
+        erkenne(
+            "Der bisherige Satz 2 wird Satz 3 und die Angabe „der Durchführung der Lehrgänge"
+                + " (Art. 28 Abs. 1 Satz 4),“ wird durch die Angabe „einer Durchführung von"
+                + " Lehrgängen für die Fallenjagd“ ersetzt.",
+            ART_22);
+
+    assertThat(befehl).containsInstanceOf(Sammelbefehl.class);
+    var teile = ((Sammelbefehl) befehl.orElseThrow()).teilbefehle();
+    assertThat(teile.get(0)).isInstanceOf(Umnummerierung.class);
+    assertThat(teile.get(1)).isInstanceOf(Ersetzung.class);
+  }
+
+  @Test
+  void erkenntBayerischeUmnummerierungsVerbuende() {
+    // „Abs. 3 wird Abs. 2 und wird wie folgt geändert:“ läuft über rahmenMitBefehl;
+    // „Satz 5 wird Satz 4.“ ist eine gewöhnliche Umnummerierung.
+    var satz = erkenne("Satz 5 wird Satz 4.", ART_22);
+    assertThat(satz).containsInstanceOf(Umnummerierung.class);
+    assertThat(((Umnummerierung) satz.orElseThrow()).neu().anzeigeText())
+        .isEqualTo("Art. 22 Satz 4");
+
+    var abs = erkenne("Abs. 3 wird Abs. 2.", ART_22);
+    assertThat(abs).containsInstanceOf(Umnummerierung.class);
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java b/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
index 9389534..f15b98f 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/StellenParserTest.java
@@ -83,6 +83,33 @@
   }
 
   @Test
+  void parstBayerischeArtikelStelle() {
+    // Bayerisches Landesrecht: Normen heißen „Art. N“, Unterkomponenten sind abgekürzt.
+    var stelle = StellenParser.parse("Art. 6 Abs. 2 Satz 1 Nr. 2").orElseThrow();
+    assertThat(stelle.anzeigeText()).isEqualTo("Art. 6 Absatz 2 Satz 1 Nummer 2");
+    assertThat(stelle.paragraph().orElseThrow().enbez()).isEqualTo("Art. 6");
+  }
+
+  @Test
+  void parstBayerischenBereichMitAbkuerzung() {
+    // „In den Abs. 4 und 5“ und Bereiche wie „Art. 4 bis 6“ mit erhaltenem Sigel.
+    var stellen = StellenParser.parseMehrfach("Art. 4 Abs. 3, Art. 5 Abs. 2 und Art. 11 Abs. 6");
+    assertThat(stellen).extracting(Stelle::anzeigeText)
+        .containsExactly("Art. 4 Absatz 3", "Art. 5 Absatz 2", "Art. 11 Absatz 6");
+    var bereich = StellenParser.parseMehrfach("Abs. 1 bis 3");
+    assertThat(bereich).extracting(Stelle::anzeigeText)
+        .containsExactly("Absatz 1", "Absatz 2", "Absatz 3");
+  }
+
+  @Test
+  void ignoriertBayerischenChapeauZusatz() {
+    assertThat(StellenParser.parse("Abs. 2 Satzteil vor Nr. 1").orElseThrow().anzeigeText())
+        .isEqualTo("Absatz 2");
+    assertThat(StellenParser.parse("in dem Satzteil nach Nr. 3").isEmpty()).isTrue();
+    assertThat(StellenParser.istNurChapeau("in dem Satzteil nach Nr. 3")).isTrue();
+  }
+
+  @Test
   void ignoriertChapeauZusatz() {
     // „in der Angabe vor Nummer 1“ ist ein verfeinernder Zusatz ohne eigene Komponente.
     assertThat(StellenParser.parse("Absatz 1 in der Angabe vor Nummer 1").orElseThrow().anzeigeText())
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 8a7cf12..755db46 100644
--- a/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java
+++ b/src/test/java/eu/mulk/aendggner/aenderung/parse/TextBereinigerTest.java
@@ -48,6 +48,36 @@
   }
 
   @Test
+  void entferntGvblKolumnentitel() {
+    // Gerade Seiten kleben die Seitenzahl ohne Zwischenraum an die Jahreszahl („…/202676“);
+    // eine am Seitenwechsel unterbrochene Silbentrennung heilt nach der Kopfentfernung.
+    var roh =
+        "Einheiten über Online-Plattformen für die kurz-\n"
+            + "Bayerisches Gesetz- und Verordnungsblatt Nr. 6/202676\n"
+            + "fristige Vermietung von Unterkünften anbietet, \n"
+            + "Bayerisches Gesetz- und Verordnungsblatt Nr. 6/2026 77\n"
+            + "Zweiter Satz. ";
+
+    assertThat(TextBereiniger.bereinige(roh))
+        .isEqualTo(
+            "Einheiten über Online-Plattformen für die kurzfristige Vermietung von Unterkünften"
+                + " anbietet,\nZweiter Satz.");
+  }
+
+  @Test
+  void entferntLandtagsKolumnentitel() {
+    var roh =
+        "Bayerischer Landtag \n"
+            + "19. Wahlperiode 28.01.2026  Drucksache 19/9707 \n"
+            + "Erster Satz. \n"
+            + "Drucksache 19/9707 Bayerischer Landtag 19. Wahlperiode Seite 2 \n"
+            + "Zweiter Satz. \n"
+            + "19. Wahlperiode Drucksache 19/9707 ";
+
+    assertThat(TextBereiniger.bereinige(roh)).isEqualTo("Erster Satz.\nZweiter Satz.");
+  }
+
+  @Test
   void entferntKopfzeilenDesNeuenBgblFormats() {
     var roh =
         "Erster Satz. \n"
diff --git a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
index aa658dd..a23f444 100644
--- a/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
+++ b/src/test/java/eu/mulk/aendggner/anwendung/BefehlAnwenderTest.java
@@ -984,4 +984,154 @@
   private static String absatzText(Gesetz gesetz, String enbez, int index) {
     return gesetz.norm(enbez).orElseThrow().absaetze().get(index).text();
   }
+
+  // --- Bayerisches Landesrecht ---------------------------------------------------------------
+
+  /** Ein Gesetz nach bayerischem Muster: Art.-Normen, amtliche Satznummern, Fußnoten. */
+  private static Gesetz bayGesetz() {
+    return new Gesetz(
+        "BayTestG",
+        "Bayerisches Testgesetz",
+        null,
+        List.of(
+            new Norm(
+                "Art. 1",
+                "Zweck",
+                null,
+                List.of(
+                    new Absatz(
+                        "1",
+                        "¹Die Erprobung ist Zweck dieses Gesetzes⁶). ²Sie erfolgt sorgfältig.\n"
+                            + "⁶) [Amtl. Anm.:] BayRS 0-0-T"),
+                    new Absatz("2", "¹Erster Satz. ²Zweiter Satz.")),
+                false),
+            new Norm(
+                "Art. 2",
+                "Begriffe",
+                null,
+                List.of(
+                    new Absatz(
+                        null,
+                        "Erprobung ist die Prüfung der Tauglichkeit; sie endet mit einem"
+                            + " Bericht.")),
+                false)),
+        List.of());
+  }
+
+  @Test
+  void wendetFussnotenAufhebungAn() {
+    var befehl =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.FussnotenAufhebung(
+            stelle(new Stelle.Paragraph("1", "Art.")), List.of("6"), PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    var text = absatzText(ergebnis.neu(), "Art. 1", 0);
+    assertThat(text).doesNotContain("⁶").doesNotContain("[Amtl. Anm.:]");
+    assertThat(text).startsWith("¹Die Erprobung ist Zweck dieses Gesetzes.");
+  }
+
+  @Test
+  void meldetFehlendeFussnoteAlsManuellPruefen() {
+    var befehl =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.FussnotenAufhebung(
+            stelle(new Stelle.Paragraph("1", "Art.")), List.of("7"), PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.MANUELL_PRUEFEN);
+    assertThat(ergebnis.protokoll().get(0).begruendung()).contains("Fußnote 7");
+  }
+
+  @Test
+  void wendetSatznummerierungsStreichungAn() {
+    var befehl =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.SatznummerierungStreichung(
+            stelle(
+                new Stelle.Paragraph("1", "Art."),
+                new Stelle.AbsatzNr("2"),
+                new Stelle.SatzNr("1")),
+            "1",
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "Art. 1", 1)).isEqualTo("Erster Satz. ²Zweiter Satz.");
+  }
+
+  @Test
+  void satzUmnummerierungSchreibtSuperskriptUm() {
+    // „Satz 2 wird Satz 3.“ — die amtliche Satznummer im Text wird umgeschrieben.
+    var befehl =
+        new Umnummerierung(
+            stelle(
+                new Stelle.Paragraph("1", "Art."),
+                new Stelle.AbsatzNr("2"),
+                new Stelle.SatzNr("2")),
+            stelle(
+                new Stelle.Paragraph("1", "Art."),
+                new Stelle.AbsatzNr("2"),
+                new Stelle.SatzNr("3")),
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "Art. 1", 1)).isEqualTo("¹Erster Satz. ³Zweiter Satz.");
+  }
+
+  @Test
+  void wendetWortlautZuSatzAn() {
+    var befehl =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuSatz(
+            stelle(new Stelle.Paragraph("2", "Art.")), "1", PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "Art. 2", 0)).startsWith("¹Erprobung ist die Prüfung");
+  }
+
+  @Test
+  void wendetWortlautVoranstellungUndNummerierungAn() {
+    // Bayerische Folge: erst „Dem Wortlaut werden die folgenden Abs. 1 und 2 vorangestellt“,
+    // dann „Der bisherige Wortlaut wird Abs. 3“ — nur der unnummerierte Absatz erhält die Nummer.
+    var voranstellung =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautVoranstellung(
+            stelle(new Stelle.Paragraph("2", "Art.")), "(1) Erstens. (2) Zweitens.", PROV);
+    var nummerierung =
+        new eu.mulk.aendggner.aenderung.Aenderungsbefehl.WortlautZuAbsatz(
+            stelle(new Stelle.Paragraph("2", "Art.")), "3", PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(voranstellung, nummerierung));
+
+    assertThat(ergebnis.protokoll())
+        .allSatisfy(eintrag -> assertThat(eintrag.status()).isEqualTo(Status.ANGEWANDT));
+    var norm = ergebnis.neu().norm("Art. 2").orElseThrow();
+    assertThat(norm.absaetze()).hasSize(3);
+    assertThat(norm.absaetze().get(0).nummer()).isEqualTo("1");
+    assertThat(norm.absaetze().get(1).nummer()).isEqualTo("2");
+    assertThat(norm.absaetze().get(2).nummer()).isEqualTo("3");
+    assertThat(norm.absaetze().get(2).text()).startsWith("Erprobung ist");
+  }
+
+  @Test
+  void wendetHalbsatzErsetzungAn() {
+    var befehl =
+        new Ersetzung(
+            stelle(new Stelle.Paragraph("2", "Art."), new Stelle.HalbsatzNr("2")),
+            "sie endet",
+            "sie schließt",
+            false,
+            false,
+            PROV);
+
+    var ergebnis = BefehlAnwender.anwenden(bayGesetz(), List.of(befehl));
+
+    assertThat(ergebnis.protokoll().get(0).status()).isEqualTo(Status.ANGEWANDT);
+    assertThat(absatzText(ergebnis.neu(), "Art. 2", 0))
+        .isEqualTo("Erprobung ist die Prüfung der Tauglichkeit; sie schließt mit einem Bericht.");
+  }
 }
diff --git a/src/test/java/eu/mulk/aendggner/anwendung/SatzTeilerTest.java b/src/test/java/eu/mulk/aendggner/anwendung/SatzTeilerTest.java
index 7df8f37..a97fc03 100644
--- a/src/test/java/eu/mulk/aendggner/anwendung/SatzTeilerTest.java
+++ b/src/test/java/eu/mulk/aendggner/anwendung/SatzTeilerTest.java
@@ -38,6 +38,30 @@
   }
 
   @Test
+  void teiltAnAmtlichenSatznummern() {
+    // Bayerisches Landesrecht: hochgestellte Satznummern sind exakte Satzgrenzen — auch dort,
+    // wo die Heuristik versagen würde (Abkürzung am Satzende).
+    var text = "¹Die Förderung erfolgt gem. Art. 26 und 27. ²Sie ist als Teil zu bewahren.";
+    assertThat(SatzTeiler.teileTexte(text))
+        .containsExactly(
+            "¹Die Förderung erfolgt gem. Art. 26 und 27.", "²Sie ist als Teil zu bewahren.");
+    assertThat(SatzTeiler.nummerVonSatz("²Sie ist als Teil zu bewahren.")).isEqualTo(2);
+    assertThat(SatzTeiler.nummerVonSatz("Ohne Nummer.")).isNull();
+  }
+
+  @Test
+  void fussnotenmarkerIstKeinSatzanfang() {
+    // „Enteignung⁶)“ mitten im Satz und die Fußnotenzeile „⁶) …“ eröffnen keinen neuen Satz.
+    var text =
+        "¹Es gilt das Gesetz über die entschädigungspflichtige Enteignung⁶) entsprechend."
+            + " ²Näheres regelt die Verordnung.\n⁶) [Amtl. Anm.:] BayRS 2141-1-I";
+    var saetze = SatzTeiler.teileTexte(text);
+    assertThat(saetze).hasSize(2);
+    assertThat(saetze.get(0)).contains("Enteignung⁶)");
+    assertThat(saetze.get(1)).startsWith("²Näheres").contains("⁶) [Amtl. Anm.:]");
+  }
+
+  @Test
   void behandeltAufzaehlungenAlsTeilDesSatzes() {
     var text =
         "Die Erprobung umfasst\n"
diff --git a/src/test/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParserTest.java b/src/test/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParserTest.java
new file mode 100644
index 0000000..a5fc67a
--- /dev/null
+++ b/src/test/java/eu/mulk/aendggner/gesetz/bayern/BayRechtTextParserTest.java
@@ -0,0 +1,120 @@
+package eu.mulk.aendggner.gesetz.bayern;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import eu.mulk.aendggner.gesetz.Gliederung;
+import org.junit.jupiter.api.Test;
+
+class BayRechtTextParserTest {
+
+  private static final String BEISPIEL =
+      """
+      BayJG: Bayerisches Jagdgesetz (BayJG) Vom 13. Oktober 1978 (BayRS V S. 595) BayRS 792-1-W (Art.
+      1–64)
+      Bayerisches Jagdgesetz
+      (BayJG)
+      Vom 13. Oktober 1978
+      (BayRS V S. 595)
+      BayRS 792-1-W
+      Vollzitat nach RedR: Bayerisches Jagdgesetz (BayJG) in der in der Bayerischen Rechtssammlung (BayRS
+      792-1-L) veröffentlichten bereinigten Fassung
+      I. Abschnitt Grundsätze
+      Art. 1  Gesetzeszweck
+
+      (1) ¹Die freilebende Tierwelt ist wesentlicher Bestandteil der heimischen Natur. ²Sie ist zu bewahren.
+      (2) Dieses Gesetz soll dazu dienen:
+      1.  einen artenreichen Wildbestand zu erhalten,
+
+      2.  die Lebensgrundlagen des Wildes zu sichern.
+
+      II. Abschnitt Jagdreviere, Hegegemeinschaften
+      1. Allgemeine Vorschriften
+      Art. 3  Feststellung der Jagdreviere
+
+      Bestand, Umfang und Grenzen eines Jagdreviers werden durch die
+      Jagdbehörde festgestellt.
+      2. Jagdreviere
+      Art. 8  Eigenjagdreviere
+
+      (1) ¹Die Mindestgröße beträgt 81,755 ha. ²Die Art. 4 Abs. 3, Art. 5 Abs. 2 und
+      Art. 11 Abs. 6 sind entsprechend anzuwenden.
+      Art. 59  Enteignende Maßnahmen
+
+      (1) Es ist nach den Vorschriften des Gesetzes über die entschädigungspflichtige Enteignung⁶) Entschädigung zu leisten.
+      6) [Amtl. Anm.:] BayRS 2141-1-I
+      Art. 60  (aufgehoben)
+
+      Art. 63 (Änderungsbestimmung)
+
+      Art. 64  Inkrafttreten; Aufhebung von Vorschriften
+
+      (1) Dieses Gesetz tritt am 1. Januar 1979 in Kraft.
+      """;
+
+  @Test
+  void parstTitelblock() {
+    var gesetz = BayRechtTextParser.parse(BEISPIEL);
+    assertThat(gesetz.jurabk()).isEqualTo("BayJG");
+    assertThat(gesetz.langue()).isEqualTo("Bayerisches Jagdgesetz");
+    assertThat(gesetz.kurzue()).isNull();
+  }
+
+  @Test
+  void parstNormenMitTitelnUndAbsaetzen() {
+    var gesetz = BayRechtTextParser.parse(BEISPIEL);
+    assertThat(gesetz.normen())
+        .extracting(n -> n.enbez())
+        .containsExactly("Art. 1", "Art. 3", "Art. 8", "Art. 59", "Art. 60", "Art. 63", "Art. 64");
+
+    var art1 = gesetz.norm("Art. 1").orElseThrow();
+    assertThat(art1.titel()).isEqualTo("Gesetzeszweck");
+    assertThat(art1.absaetze()).hasSize(2);
+    assertThat(art1.absaetze().get(0).nummer()).isEqualTo("1");
+    assertThat(art1.absaetze().get(0).text()).startsWith("¹Die freilebende Tierwelt");
+    assertThat(art1.absaetze().get(1).text()).contains("1.  einen artenreichen");
+
+    // Unnummerierter Einzelabsatz.
+    var art3 = gesetz.norm("Art. 3").orElseThrow();
+    assertThat(art3.absaetze()).hasSize(1);
+    assertThat(art3.absaetze().get(0).nummer()).isNull();
+  }
+
+  @Test
+  void querverweiseAmZeilenanfangEroeffnenKeineNorm() {
+    // „Art. 11 Abs. 6 …“ am Zeilenanfang in Art. 8 ist ein Querverweis, kein Normkopf.
+    var gesetz = BayRechtTextParser.parse(BEISPIEL);
+    var art8 = gesetz.norm("Art. 8").orElseThrow();
+    assertThat(art8.absaetze().get(0).text()).contains("Art. 11 Abs. 6 sind entsprechend");
+    assertThat(gesetz.norm("Art. 11")).isEmpty();
+  }
+
+  @Test
+  void parstGliederungenMitUnterUeberschriften() {
+    var gesetz = BayRechtTextParser.parse(BEISPIEL);
+    assertThat(gesetz.gliederungen())
+        .extracting(Gliederung::anzeigeText)
+        .containsExactly(
+            "I. Abschnitt — Grundsätze",
+            "II. Abschnitt — Jagdreviere, Hegegemeinschaften",
+            "1. — Allgemeine Vorschriften",
+            "2. — Jagdreviere");
+    // Kennzahlen sind eindeutig und hängen an der Eltern-Gliederung.
+    assertThat(gesetz.gliederungen())
+        .extracting(Gliederung::kennzahl)
+        .containsExactly("001", "002", "002.1", "002.2");
+    assertThat(gesetz.norm("Art. 8").orElseThrow().gliederung().kennzahl()).isEqualTo("002.2");
+  }
+
+  @Test
+  void erkenntWeggefalleneNormenUndFussnoten() {
+    var gesetz = BayRechtTextParser.parse(BEISPIEL);
+    assertThat(gesetz.norm("Art. 60").orElseThrow().weggefallen()).isTrue();
+    assertThat(gesetz.norm("Art. 63").orElseThrow().weggefallen()).isFalse();
+
+    // Fußnotenzeile bleibt superskript-normalisiert im tragenden Absatz.
+    var art59 = gesetz.norm("Art. 59").orElseThrow();
+    assertThat(art59.absaetze().get(0).text())
+        .contains("Enteignung⁶)")
+        .contains("⁶) [Amtl. Anm.:] BayRS 2141-1-I");
+  }
+}