From 0d0d1f3f5973bf0ef5ff51edf4c4a1e922cbf534 Mon Sep 17 00:00:00 2001 From: Eldar <3009675@stud.hs-mannheim.de> Date: Wed, 19 Jun 2024 11:58:17 +0200 Subject: [PATCH] Update --- PR2_UIB/Indexdatei.txt | Bin 0 -> 40 bytes PR2_UIB/src/DynamicTree/DynamicTree.java | 17 +++ PR2_UIB/src/Indexverwaltung/.DS_Store | Bin 0 -> 6148 bytes PR2_UIB/src/Indexverwaltung/Datei.java | 81 +++++++++++++++ PR2_UIB/src/Indexverwaltung/Index.java | 97 ++++++++++++++++++ PR2_UIB/src/Indexverwaltung/IndexUI.java | 96 +++++++++++++++++ .../InvalidIndexException.java | 23 +++++ PR2_UIB/src/Uebung2/Unterzaehler.java | 6 +- .../Uebung_15_04/BufferedReader_Writer.java | 21 ++-- .../src/Uebung_15_04/MainSerialisierung.java | 18 +++- .../src/Uebung_Collections/Uebung1_Stack.java | 35 +++++++ .../src/Uebung_Collections/Uebung2_Set.java | 64 ++++++++++++ .../src/Uebung_Collections/Uebung3_Queue.java | 41 ++++++++ PR2_UIB/src/Uebung_Exceptions/Aufgabe1.java | 9 ++ PR2_UIB/src/Uebung_Generics/Aufgabe2.java | 10 ++ .../Uebung_Generics/Sortierung_Aufgabe.java | 36 +++++++ .../Aufgabe1.java | 39 +++++++ .../Aufgabe2.java | 34 ++++++ .../Aufgabe3.java | 43 ++++++++ PR2_UIB/stammdatei.txt | Bin 0 -> 600 bytes 20 files changed, 656 insertions(+), 14 deletions(-) create mode 100644 PR2_UIB/Indexdatei.txt create mode 100644 PR2_UIB/src/DynamicTree/DynamicTree.java create mode 100644 PR2_UIB/src/Indexverwaltung/.DS_Store create mode 100644 PR2_UIB/src/Indexverwaltung/Datei.java create mode 100644 PR2_UIB/src/Indexverwaltung/Index.java create mode 100644 PR2_UIB/src/Indexverwaltung/IndexUI.java create mode 100644 PR2_UIB/src/Indexverwaltung/InvalidIndexException.java create mode 100644 PR2_UIB/src/Uebung_Collections/Uebung1_Stack.java create mode 100644 PR2_UIB/src/Uebung_Collections/Uebung2_Set.java create mode 100644 PR2_UIB/src/Uebung_Collections/Uebung3_Queue.java create mode 100644 PR2_UIB/src/Uebung_Exceptions/Aufgabe1.java create mode 100644 PR2_UIB/src/Uebung_Generics/Aufgabe2.java create mode 100644 PR2_UIB/src/Uebung_Generics/Sortierung_Aufgabe.java create mode 100644 PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe1.java create mode 100644 PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe2.java create mode 100644 PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe3.java create mode 100644 PR2_UIB/stammdatei.txt diff --git a/PR2_UIB/Indexdatei.txt b/PR2_UIB/Indexdatei.txt new file mode 100644 index 0000000000000000000000000000000000000000..7f936d9712228bd8f7babdaedd00d2a797fdd0b8 GIT binary patch literal 40 dcmezW|Nnmm1_nkT1)`ZiGzb9M3=kHC1ONn+8|VN4 literal 0 HcmV?d00001 diff --git a/PR2_UIB/src/DynamicTree/DynamicTree.java b/PR2_UIB/src/DynamicTree/DynamicTree.java new file mode 100644 index 0000000..7c9da33 --- /dev/null +++ b/PR2_UIB/src/DynamicTree/DynamicTree.java @@ -0,0 +1,17 @@ +package DynamicTree; + +public class DynamicTree > { + + public void add(T e) { + if(root == null) { + root = new TreeElement(e); + } else { + if(e.compareTo(root.value) < 0 ) + root.left = new TreeElement (e); + + else + root.right = new TreeElement (e); + } + } + +} diff --git a/PR2_UIB/src/Indexverwaltung/.DS_Store b/PR2_UIB/src/Indexverwaltung/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 0) + satz.append(eineStammDatei.readChar()); + + return satz.toString(); + } + + private void writeFixedString(String einDatensatz, int laenge) throws IOException + { + StringBuffer sb = new StringBuffer(einDatensatz); + + while(sb.length() != laenge) + sb.append('\0'); + + for(int index = 0; index < laenge; index++) { + + eineStammDatei.writeChar(sb.charAt(index)); + } + } +} diff --git a/PR2_UIB/src/Indexverwaltung/Index.java b/PR2_UIB/src/Indexverwaltung/Index.java new file mode 100644 index 0000000..34e7061 --- /dev/null +++ b/PR2_UIB/src/Indexverwaltung/Index.java @@ -0,0 +1,97 @@ +package Indexverwaltung; + +import java.io.*; + +public class Index { + // Attribute + private final int MAX = 10; + private String dateiname = "Indexdatei.txt"; + private int indextabelle[]; // 0 .. MAX-1 + private RandomAccessFile eineIndexDatei; + + // Konstruktor + public Index() { + + indextabelle = new int[MAX]; + // Initialisierung der indextabelle + for (int i = 0; i < MAX; i++) + indextabelle[i] = -1; + // Kein Datensatz zu Schluessel vorhanden + + } + + // Methoden + public void erzeugeEintrag(int schluessel, int index) throws IOException { + /** + * Speichert zu einen Schluessel den zugehoerigen Datensatz-Index in der + * indextabelle + */ + if (schluessel < MAX) + indextabelle[schluessel] = index; + // Aktualisieren der Indexdatei, + // d. h. Abspeichern der Datei + aktualisiereIndexDatei(schluessel); + } + + public int gibIndexZuSchluessel(int schluessel) throws InvalidIndexException { + /* + * // Gibt zu dem Schluessel den gefundenen // Datensatz-Index zurueck + * if(schluessel < MAX) return indextabelle[schluessel]; // oder -1, wenn + * Schluessel zu gross ist else return -1; + */ + + if (schluessel >= MAX || indextabelle[schluessel] == -1) + throw new InvalidIndexException(schluessel); + + return indextabelle[schluessel]; + + } + + public void ladeIndexDatei() throws IOException { + /** + * Liest die Indextabelle vollstaendig aus einer Datei Dies geschieht nur beim + * Start des Programms + */ + eineIndexDatei = new RandomAccessFile(dateiname, "r"); + int index; + for (int schluessel = 0; schluessel < MAX; schluessel++) { + index = eineIndexDatei.readInt(); + indextabelle[schluessel] = index; + } + eineIndexDatei.close(); + } + + public void speichereIndexDatei() throws IOException { + /** + * Speichert die Indextabelle vollstaendig in einer Datei Dies geschieht beim + * Beenden des Programs + */ + eineIndexDatei = new RandomAccessFile(dateiname, "rw"); + for (int schluessel = 0; schluessel < MAX; schluessel++) + eineIndexDatei.writeInt(indextabelle[schluessel]); + eineIndexDatei.close(); + } + + private void aktualisiereIndexDatei(int schluessel) throws IOException { + /** + * Aktualisiert die indextabelle in der Indexdatei Dies geschieht beim + * Hinzufuegen eines neuen Indexes oder Aendern eines alten Indexes + */ + eineIndexDatei = new RandomAccessFile(dateiname, "rw"); + // eine int-Zahl belegt 4 Bytes + eineIndexDatei.seek((long) (schluessel * 4)); + eineIndexDatei.writeInt(indextabelle[schluessel]); + eineIndexDatei.close(); + } + + // Zum Testen + public void gibIndextabelleAus() { + int schluessel = 0; + for (int element : indextabelle) { + System.out.println(schluessel + " " + element); + schluessel++; + + } + } + +} diff --git a/PR2_UIB/src/Indexverwaltung/IndexUI.java b/PR2_UIB/src/Indexverwaltung/IndexUI.java new file mode 100644 index 0000000..db958a0 --- /dev/null +++ b/PR2_UIB/src/Indexverwaltung/IndexUI.java @@ -0,0 +1,96 @@ +package Indexverwaltung; + +import java.io.IOException; +import java.util.Scanner; + +public class IndexUI { + + public static void main(String[] args) { + // TODO Auto-generated method stub + Index indexDatei = new Index(); + Datei stammDatei = new Datei(); + Scanner sc = new Scanner(System.in); + + try { + indexDatei.ladeIndexDatei(); + } + catch(IOException e) + { + System.err.println("INFO - Dateien nicht vorhanden - Erzeuge Beispiel!"); + + int idx = 0; + try { + stammDatei.oeffneDatei("stammdatei.txt"); + + indexDatei.erzeugeEintrag(6, idx); + stammDatei.speichereSatz("Satz 1", idx); + + idx++; + indexDatei.erzeugeEintrag(1, idx); + stammDatei.speichereSatz("Satz 2", idx); + + idx++; + indexDatei.erzeugeEintrag(3, idx); + stammDatei.speichereSatz("Satz 3", idx); + + idx++; + indexDatei.speichereIndexDatei(); + stammDatei.schliesseDatei(); + + } catch (IOException ee) { + ee.printStackTrace(); + } + } + + indexDatei.gibIndextabelleAus(); + + try { + stammDatei.oeffneDatei("stammdatei.txt"); + + while(true) { + System.out.print("Bitte geben Sie einen Schluessel ein:"); + String schluessel = sc.nextLine(); + + if(schluessel.isEmpty()) + break; + + try { + int index = indexDatei.gibIndexZuSchluessel(Integer.parseInt(schluessel)); + + String satz = stammDatei.leseSatz(index); + + System.out.println("Der zu " + schluessel + " gewuenschte Satz lautet: ==> " + satz + " <=="); + + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } catch (InvalidIndexException e) { + System.err.println("\n==> Zugriff auf nicht vorhandenen Schluessel: " + e.gibSchluessel() + " <=="); + } + + } + + } catch (IOException e1) { + e1.printStackTrace(); + } catch (NumberFormatException e2) { + e2.printStackTrace(); + } + finally { + try { + + indexDatei.speichereIndexDatei(); + + stammDatei.schliesseDatei(); + + System.err.println("Dateien geschlossen!"); + + } catch (IOException e) { + e.printStackTrace(); + } + } + + System.out.println("Programm beendet!"); + + } + +} diff --git a/PR2_UIB/src/Indexverwaltung/InvalidIndexException.java b/PR2_UIB/src/Indexverwaltung/InvalidIndexException.java new file mode 100644 index 0000000..c332ca0 --- /dev/null +++ b/PR2_UIB/src/Indexverwaltung/InvalidIndexException.java @@ -0,0 +1,23 @@ +package Indexverwaltung; + +public class InvalidIndexException extends Exception { + private int schluessel; + + public InvalidIndexException(int s) { + super("Access to Unknown Index"); + schluessel = s; + } + + public InvalidIndexException(int s, String fehlermeldung) { + super(fehlermeldung); + schluessel = s; + } + + public int gibSchluessel() { + return schluessel; + } + + public void neueException() throws Exception { + throw new Exception("Index überschreitet Maximum"); + } +} diff --git a/PR2_UIB/src/Uebung2/Unterzaehler.java b/PR2_UIB/src/Uebung2/Unterzaehler.java index 1c64935..7156c5d 100644 --- a/PR2_UIB/src/Uebung2/Unterzaehler.java +++ b/PR2_UIB/src/Uebung2/Unterzaehler.java @@ -3,15 +3,15 @@ package Uebung2; public class Unterzaehler extends Zaehler { private int unterzaehlerStand; - + public Unterzaehler(String art, Verbraucher meinVerbraucher, int zaehlerStand) { super(art, meinVerbraucher, zaehlerStand); this.unterzaehlerStand = unterzaehlerStand; } - protected Unterzaehler clone() throws CloneNotSupportedException{ + protected Unterzaehler clone() throws CloneNotSupportedException { return (Unterzaehler) super.clone(); - + } public int getUnterzaehlerstand() { diff --git a/PR2_UIB/src/Uebung_15_04/BufferedReader_Writer.java b/PR2_UIB/src/Uebung_15_04/BufferedReader_Writer.java index c68b843..e3c481a 100644 --- a/PR2_UIB/src/Uebung_15_04/BufferedReader_Writer.java +++ b/PR2_UIB/src/Uebung_15_04/BufferedReader_Writer.java @@ -3,36 +3,41 @@ package Uebung_15_04; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; - +import java.io.LineNumberReader; public class BufferedReader_Writer { public static void main(String[] args) throws IOException { BufferedReader reader = new BufferedReader(new FileReader("src/Uebung_15_04/Mondnacht.txt")); - int i = 0; + LineNumberReader lnr = new LineNumberReader(reader); int counter = 0; int wortAnzahl = 0; - String zeile = reader.readLine(); + String zeile = lnr.readLine(); while (zeile != null) { - i++; - System.out.println("Zeile " + i + ": " + zeile); + System.out.println("Zeile " + lnr.getLineNumber() + ": " + zeile); String[] w = zeile.split(" "); wortAnzahl += w.length; for (String wort : w) { - counter += wort.length(); + char[] c = wort.toCharArray(); + for (int i = 0; i <= c.length - 1; i++) { + if (Character.isLetter(c[i])) { + counter++; + } + } + } - zeile = reader.readLine(); + zeile = lnr.readLine(); } reader.close(); System.out.println("Anzahl der Wörter: " + wortAnzahl); System.out.println("Anzahl der Buchstaben: " + counter); - System.out.println("Anzahl der Zeilen: " + i); + System.out.println("Anzahl der Zeilen: " + lnr.getLineNumber()); } } diff --git a/PR2_UIB/src/Uebung_15_04/MainSerialisierung.java b/PR2_UIB/src/Uebung_15_04/MainSerialisierung.java index 306f59a..3b56cce 100644 --- a/PR2_UIB/src/Uebung_15_04/MainSerialisierung.java +++ b/PR2_UIB/src/Uebung_15_04/MainSerialisierung.java @@ -1,10 +1,22 @@ package Uebung_15_04; -public class MainSerialisierung { +import java.io.*; +public class MainSerialisierung { public static void main(String[] args) { - // TODO Auto-generated method stub + // Erstelle ein Produkt + Product produkt1 = new Product("Handy" , "Schwarz" , 599.99); + + // Dateiname für die Serialisierung + + // Serialisierung + + // Deserialisierung und Ausgabe } -} + // Methode zur Serialisierung eines Produkts + + // Methode zur Deserialisierung eines Produkts + +} \ No newline at end of file diff --git a/PR2_UIB/src/Uebung_Collections/Uebung1_Stack.java b/PR2_UIB/src/Uebung_Collections/Uebung1_Stack.java new file mode 100644 index 0000000..6dadb76 --- /dev/null +++ b/PR2_UIB/src/Uebung_Collections/Uebung1_Stack.java @@ -0,0 +1,35 @@ +package Uebung_Collections; + +import java.io.StreamTokenizer; +import java.util.Scanner; + +public class Uebung1_Stack { + + public static void main(String[] args) { + Scanner sc = new Scanner (System.in); + String eingabe; + while(!(eingabe = sc.nextLine()).equals("q")) { + String ausdruck = ""; + + + for(int i = 0 ; i < eingabe.length(); i++) { + ausdruck += eingabe.charAt(i); + } + StreamTokenizer st = new StreamTokenizer(ausdruck); + } + + } + + class Item { + + // Konstruktor + Item(char z, int w) { + zeichen = z; + prio = w; + } + + char zeichen; + int prio; + } + +} diff --git a/PR2_UIB/src/Uebung_Collections/Uebung2_Set.java b/PR2_UIB/src/Uebung_Collections/Uebung2_Set.java new file mode 100644 index 0000000..bf8c458 --- /dev/null +++ b/PR2_UIB/src/Uebung_Collections/Uebung2_Set.java @@ -0,0 +1,64 @@ +package Uebung_Collections; + +import java.util.HashMap; +import java.util.Map; + +public class Uebung2_Set { + + public static void main(String[] args) { + + Pruefung p1 = new Pruefung(10); + + Student student1 = new Student(12345, "Max Mustermann"); + Student student2 = new Student(12346, "Beispiel Student"); + Student student3 = new Student(12345, "Max Mustermann"); + + p1.anmelden(student1); + p1.anmelden(student2); + p1.anmelden(student3); + + // Ausgabe der angemeldeten Studenten + for (Student s : p1.getAnmeldungen().values()) { + System.out.println(s); + } + } +} + +class Student { + private int matrikelNum; + private String studName; + + public Student(int matrikelNum, String studName) { + this.matrikelNum = matrikelNum; + this.studName = studName; + } + + public String toString() { + return "Student mit der Matrikelnummer " + matrikelNum + " und Name " + studName + + " hat sich erfolgreich für die Prüfung angemeldet"; + } + + public Integer getMatrikelNum() { + // TODO Auto-generated method stub + return matrikelNum; + } + +} + +class Pruefung { + private int pruefungsNum; + private Map anmeldungen; + + public Pruefung(int pruefungsNum) { + this.anmeldungen = new HashMap<>(); + this.pruefungsNum = pruefungsNum; + } + + public void anmelden(Student student) { + anmeldungen.put(student.getMatrikelNum(), student); + } + + public Map getAnmeldungen() { + return anmeldungen; + } +} diff --git a/PR2_UIB/src/Uebung_Collections/Uebung3_Queue.java b/PR2_UIB/src/Uebung_Collections/Uebung3_Queue.java new file mode 100644 index 0000000..a3b7734 --- /dev/null +++ b/PR2_UIB/src/Uebung_Collections/Uebung3_Queue.java @@ -0,0 +1,41 @@ +package Uebung_Collections; + +import java.util.*; + +public class Uebung3_Queue implements Comparator { + + public static void main(String[] args) { + + Queue statusQueue = new PriorityQueue(); + + statusQueue.offer("Gold"); + statusQueue.offer("Bronze"); + statusQueue.offer("Silber"); + + Queue ausgabe = sortiereNachPrio(statusQueue); + + for (String string : ausgabe) { + System.out.println(string); + } + } + + public Queue sortiereNachPrio(Queue status){ + + Queue queue = new PriorityQueue(status); + + + Iterator it = queue.iterator(); + + while(it.hasNext()) { + + + + } + } + + @Override + public int compare(String o1, String o2) { + + return 0; + } +} diff --git a/PR2_UIB/src/Uebung_Exceptions/Aufgabe1.java b/PR2_UIB/src/Uebung_Exceptions/Aufgabe1.java new file mode 100644 index 0000000..95beb0a --- /dev/null +++ b/PR2_UIB/src/Uebung_Exceptions/Aufgabe1.java @@ -0,0 +1,9 @@ +package Uebung_Exceptions; + +public class Aufgabe1 { + + public static void main(String[] args) { + + } + +} diff --git a/PR2_UIB/src/Uebung_Generics/Aufgabe2.java b/PR2_UIB/src/Uebung_Generics/Aufgabe2.java new file mode 100644 index 0000000..bd9a147 --- /dev/null +++ b/PR2_UIB/src/Uebung_Generics/Aufgabe2.java @@ -0,0 +1,10 @@ +package Uebung_Generics; + +public class Aufgabe2 { + + public static void main(String[] args) { + // TODO Auto-generated method stub + + } + +} diff --git a/PR2_UIB/src/Uebung_Generics/Sortierung_Aufgabe.java b/PR2_UIB/src/Uebung_Generics/Sortierung_Aufgabe.java new file mode 100644 index 0000000..004741a --- /dev/null +++ b/PR2_UIB/src/Uebung_Generics/Sortierung_Aufgabe.java @@ -0,0 +1,36 @@ +package Uebung_Generics; + +import java.util.Arrays; + +public class Sortierung_Aufgabe { + + public static void main(String[] args) { + + int[] zahlen = new int[10]; + + for (int i = 0; i < zahlen.length; i++) { + int random = (int) (Math.random() * 100) + 1; + zahlen[i] = random; + } + // Arrays.sort(zahlen); + sortieren(zahlen); + System.out.println(Arrays.toString(zahlen)); + + } + + public static > void sortieren(T[] arr) { + + for (int i = 0; i < arr.length; i++) { + int minIndex = i; + for (int j = i + 1; j < arr.length; j++) { + if (arr[j].compareTo(arr[minIndex]) < 0) { + minIndex = j; + } + } + T temp = arr[minIndex]; + arr[minIndex] = arr[i]; + arr[i] = temp; + } + } + +} diff --git a/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe1.java b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe1.java new file mode 100644 index 0000000..a724f38 --- /dev/null +++ b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe1.java @@ -0,0 +1,39 @@ +package Übungsstunde_Collections_27_05; + +import java.util.*; + +public class Aufgabe1 { + + public static void main(String[] args) { + + List list1 = new ArrayList(); + + list1.add(2); + list1.add(5); + list1.add(7); + list1.add(4); + list1.add(2); + + List liste2 = listeOhneDoppelteWerte(list1); + System.out.println(liste2); + } + + public static List listeOhneDoppelteWerte(List liste) { + + // Set neueListe = new HashSet(); + List neueListe = new ArrayList(); + + for (Integer intWert : liste) { + + if (!neueListe.contains(intWert)) { + neueListe.add(intWert); + + } + + } + // List ausgabeListe = new ArrayList<>(neueListe); + + return neueListe; + } + +} diff --git a/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe2.java b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe2.java new file mode 100644 index 0000000..889cedf --- /dev/null +++ b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe2.java @@ -0,0 +1,34 @@ +package Übungsstunde_Collections_27_05; + +import java.util.*; + +public class Aufgabe2 { + + public static void main(String[] args) { + + Set set1 = new HashSet<>(); + set1.add("hallo"); +// set1.add("wie"); + set1.add("wie gehts?"); + + Set set2 = new HashSet<>(); + set2.add("gut"); +// set2.add("und"); + set2.add("dir?"); + + Set vereinigtesSet = setsVereinigen(set1, set2); + + System.out.println(vereinigtesSet); + + } + + public static Set setsVereinigen(Set set1, Set set2) { + + Set neuerSet = new HashSet<>(set1); + + neuerSet.addAll(set2); + + return neuerSet; + } + +} diff --git a/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe3.java b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe3.java new file mode 100644 index 0000000..1288ffb --- /dev/null +++ b/PR2_UIB/src/Übungsstunde_Collections_27_05/Aufgabe3.java @@ -0,0 +1,43 @@ +package Übungsstunde_Collections_27_05; + +import java.util.LinkedList; +import java.util.Queue; + +public class Aufgabe3 { + + public static void main(String[] args) { + + Queue queueTest = new LinkedList(); + + queueTest.offer(2); + queueTest.offer(6); + queueTest.offer(4); + queueTest.offer(3); + queueTest.offer(1); + + int n = 2; + + Queue ausgabeQueue = entferneVonQueue(queueTest, n); + + for (Integer ausgabe : ausgabeQueue) { + System.out.println(ausgabe); + } + } + + public static Queue entferneVonQueue(Queue queueIn, int n) { + + Queue queueOut = new LinkedList(queueIn); + int i = 0; + + if (n == 0) { + System.out.println("n darf nicht 0 sein!"); + } + while (!queueOut.isEmpty() && i < n) { + i++; + queueOut.poll(); + } + + return queueOut; + } + +} diff --git a/PR2_UIB/stammdatei.txt b/PR2_UIB/stammdatei.txt new file mode 100644 index 0000000000000000000000000000000000000000..d3b913d221f76996e49923a85d28fdcc62b1d700 GIT binary patch literal 600 jcmZPwW=LcxVW?tIU@&AD$^hXHqoM2#282J1hq6Ba3JnF_ literal 0 HcmV?d00001