From 57ef867d2b49e757ca299d9312c5c25af621dde4 Mon Sep 17 00:00:00 2001
From: Jan Loewe <jan.loewe@ptb.de>
Date: Tue, 20 Jun 2023 12:16:04 +0000
Subject: [PATCH] Migrate to vitest

---
 .gitlab-ci.yml                                |   9 +-
 auto-imports.d.ts                             |  20 ++
 jest.config.ts                                |  18 --
 package.json                                  |  28 ++-
 ...strativeData.CalibrationLaboratory.test.ts |  79 +++++++
 .../AdministrativeData.CoreDataType.test.ts   | 119 ++++++++++
 tests/DCC/AdministrativeData.Customer.test.ts |  76 +++++++
 tests/DCC/AdministrativeData.Items.test.ts    |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |  55 +++++
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../DCC/AdministrativeData.Statements.test.ts | 212 ++++++++++++++++++
 tests/DCC/AdministrativeData.test.ts          |   3 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 .../AdministrativeData.Items_variant.test.ts  |   5 +-
 ...inistrativeData.Statements_variant.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 ...ministrativeData.RefTypeDefinitons.test.ts |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../AdministrativeData.Statements.test.ts     |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Items.Item.test.ts     |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 ...surementResult.InfluenceConditions.test.ts |   5 +-
 ...surementResult.MeasuringEquipments.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 ...ults.MeasurementResult.UsedMethods.test.ts |   5 +-
 ...strativeData.CalibrationLaboratory.test.ts |   5 +-
 .../AdministrativeData.CoreDataType.test.ts   |   5 +-
 .../AdministrativeData.Customer.test.ts       |   5 +-
 .../AdministrativeData.Items.test.ts          |   5 +-
 .../AdministrativeData.RespPersons.test.ts    |   5 +-
 ...dministrativeData.SoftwareListType.test.ts |   5 +-
 .../DigitalCalibrationCertificateType.test.ts |   5 +-
 ...mentResults.MeasurementResult.Name.test.ts |   5 +-
 ...tResults.MeasurementResult.Results.test.ts |   5 +-
 .../CalibrationLaboratory.ts                  |   2 +-
 .../common/AdministrativeData/CoreDataType.ts |   2 +-
 .../common/AdministrativeData/RespPersons.ts  |   2 +-
 tests/DCC/common/Types/ContactType.ts         |   2 +-
 tests/DCC/common/Types/DataType.ts            |   3 +-
 tests/DCC/common/Types/RespPersonType.ts      |   4 +-
 tests/DCC/common/Types/StatementListType.ts   |   2 +-
 .../DCC/common/Types/StatementMetaDataType.ts |   4 +-
 tests/DCCDocument.test.ts                     |   5 +-
 tests/GP_Temperature/CharsXMLList.test.ts     |   5 +-
 tests/GP_Temperature/noQuantity.test.ts       |   5 +-
 tests/XMLEnvironment.ts                       |  44 ----
 tests/index.d.ts                              |  12 -
 tests/tsconfig.json                           |   8 +-
 tests/vitest-environment-custom/index.ts      |  48 ++++
 tests/vitest-environment-custom/package.json  |   5 +
 tsconfig.json                                 |   2 +-
 vite.config.ts                                |  23 ++
 yarn.lock                                     | Bin 181269 -> 146319 bytes
 91 files changed, 804 insertions(+), 303 deletions(-)
 create mode 100644 auto-imports.d.ts
 delete mode 100644 jest.config.ts
 create mode 100644 tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
 create mode 100644 tests/DCC/AdministrativeData.CoreDataType.test.ts
 create mode 100644 tests/DCC/AdministrativeData.Customer.test.ts
 create mode 100644 tests/DCC/AdministrativeData.RespPersons.test.ts
 create mode 100644 tests/DCC/AdministrativeData.Statements.test.ts
 delete mode 100644 tests/XMLEnvironment.ts
 delete mode 100644 tests/index.d.ts
 create mode 100644 tests/vitest-environment-custom/index.ts
 create mode 100644 tests/vitest-environment-custom/package.json
 create mode 100644 vite.config.ts

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 9f2bc57..5a71494 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -50,14 +50,21 @@ unit_tests:
   needs: ["proxy"]
   script:
     - *yarn-install
-    - yarn run test:unit --ci
+    - yarn run test:unit --coverage
+  coverage: '/Lines\s*: \d+\.\d+/'
   cache:
     - <<: *yarn-cache
   artifacts:
     when: always
+    paths:
+      - junit.xml
+      - coverage/cobertura-coverage.xml
     reports:
       junit:
         - junit.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml
 
 
 # === Job: ESLint and Prettier ===
diff --git a/auto-imports.d.ts b/auto-imports.d.ts
new file mode 100644
index 0000000..cddd3f3
--- /dev/null
+++ b/auto-imports.d.ts
@@ -0,0 +1,20 @@
+/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+// Generated by unplugin-auto-import
+export {}
+declare global {
+  const afterAll: typeof import('vitest')['afterAll']
+  const afterEach: typeof import('vitest')['afterEach']
+  const assert: typeof import('vitest')['assert']
+  const beforeAll: typeof import('vitest')['beforeAll']
+  const beforeEach: typeof import('vitest')['beforeEach']
+  const chai: typeof import('vitest')['chai']
+  const describe: typeof import('vitest')['describe']
+  const expect: typeof import('vitest')['expect']
+  const it: typeof import('vitest')['it']
+  const suite: typeof import('vitest')['suite']
+  const test: typeof import('vitest')['test']
+  const vi: typeof import('vitest')['vi']
+  const vitest: typeof import('vitest')['vitest']
+}
diff --git a/jest.config.ts b/jest.config.ts
deleted file mode 100644
index 1e5b8e4..0000000
--- a/jest.config.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import type { JestConfigWithTsJest } from "ts-jest";
-
-const config: JestConfigWithTsJest = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-  reporters: ["default", "jest-junit"],
-  coverageProvider: "v8",
-  transform: {
-    "^.+\\.m?[tj]sx?$": [
-      "ts-jest",
-      {
-        tsconfig: "tests/tsconfig.json",
-      },
-    ],
-  },
-};
-
-export default config;
diff --git a/package.json b/package.json
index b236348..cf2231e 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
     "test": "concurrently -m 1  \"npm:test:*\"",
     "test:lint": "eslint src --ext .ts",
     "test:prettier": "prettier \"src/**/*.ts\" --list-different",
-    "test:unit": "jest",
+    "test:unit": "vitest",
     "prepack": "npx rimraf lib && yarn run build",
     "prepublish": "yarn run test"
   },
@@ -25,24 +25,22 @@
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0",
-    "@types/jest": "^29.5.1",
-    "@types/node": "^18.16.2",
-    "@typescript-eslint/eslint-plugin": "^5.56.0",
-    "@typescript-eslint/parser": "^5.56.0",
+    "@types/node": "^18.16.18",
+    "@typescript-eslint/eslint-plugin": "^5.60.0",
+    "@typescript-eslint/parser": "^5.60.0",
+    "@vitest/coverage-istanbul": "^0.32.2",
     "concurrently": "^8.2.0",
-    "eslint": "^8.36.0",
+    "eslint": "^8.43.0",
     "eslint-config-prettier": "^8.8.0",
-    "fast-check": "^3.7.1",
-    "jest": "^29.5.0",
-    "jest-environment-node": "^29.5.0",
-    "jest-junit": "^16.0.0",
-    "jsdom": "^21.1.1",
+    "fast-check": "^3.10.0",
+    "jsdom": "^22.1.0",
     "lodash": "^4.17.21",
-    "prettier": "^2.8.6",
-    "ts-jest": "^29.1.0",
+    "prettier": "^2.8.8",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.5",
+    "typescript": "^5.1.3",
+    "unplugin-auto-import": "^0.16.4",
+    "vitest": "^0.32.2",
+    "vitest-environment-custom": "link:./tests/vitest-environment-custom",
     "xpath-ts": "^1.3.13"
   },
   "publishConfig": {
diff --git a/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
new file mode 100644
index 0000000..60139b1
--- /dev/null
+++ b/tests/DCC/AdministrativeData.CalibrationLaboratory.test.ts
@@ -0,0 +1,79 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { CalibrationLaboratoryType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:calibrationLaboratory/dcc:contact";
+const xpath = {
+  name: `string(${base}/dcc:name/dcc:content)`,
+  eMail: `string(${base}/dcc:eMail)`,
+  phone: `string(${base}/dcc:phone)`,
+  fax: `string(${base}/dcc:fax)`,
+  location: {
+    city: `${base}/dcc:location/dcc:city`,
+    countryCode: `${base}/dcc:location/dcc:countryCode`,
+    postCode: `${base}/dcc:location/dcc:postCode`,
+    street: `${base}/dcc:location/dcc:street`,
+    streetNo: `${base}/dcc:location/dcc:streetNo`,
+    further: `${base}/dcc:location/dcc:further/dcc:content`,
+  },
+};
+
+describe("CalibrationLaboratoryType", () => {
+  let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
+  });
+
+  test("should get correct name from XML", () => {
+    expect(calibrationLaboratory.contact.name.content[0]._text).toBe(select(xpath.name, dom));
+  });
+
+  test("should get correct eMail from XML", () => {
+    expect(calibrationLaboratory.contact.eMail._text).toBe(select(xpath.eMail, dom));
+  });
+
+  test("should get correct phone from XML", () => {
+    expect(calibrationLaboratory.contact.phone._text).toBe(select(xpath.phone, dom));
+  });
+
+  test("should get correct city from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.city, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.city)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct countryCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.countryCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.countryCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct postCode from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.postCode, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.postCode)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct street from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.street, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.street)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct streetNo from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.streetNo, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.streetNo)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct further element from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.location.further, dom);
+    expect(toTextArr(calibrationLaboratory.contact.location.further[0].content)).toEqual(toTextContentArr(expected));
+  });
+});
diff --git a/tests/DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/AdministrativeData.CoreDataType.test.ts
new file mode 100644
index 0000000..5f62a27
--- /dev/null
+++ b/tests/DCC/AdministrativeData.CoreDataType.test.ts
@@ -0,0 +1,119 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import * as fc from "fast-check";
+import { indexOf, select, toTextArr, toTextContentArr } from "../util";
+import { CoreDataType, DCCDocument, DCCXMLElement } from "../../src";
+import { string_ISO639_1 } from "../Arbitraries";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:coreData";
+const xpath = {
+  coreData: {
+    countryCodeISO3166_1: `string(${base}/dcc:countryCodeISO3166_1)`,
+    usedLangCodeISO639_1: `${base}/dcc:usedLangCodeISO639_1`,
+    mandatoryLangCodeISO639_1: `${base}/dcc:mandatoryLangCodeISO639_1`,
+    uniqueIdentifier: `string(${base}/dcc:uniqueIdentifier)`,
+    identifications: {
+      identification: {
+        issuer: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:issuer)`,
+        value: `string(${base}/dcc:identifications/dcc:identification[1]/dcc:value)`,
+        name: {
+          content: `${base}/dcc:identifications/dcc:identification[1]/dcc:name/dcc:content`,
+        },
+      },
+    },
+    receiptDate: `string(${base}/dcc:receiptDate)`,
+    beginPerformanceDate: `string(${base}/dcc:beginPerformanceDate)`,
+    endPerformanceDate: `string(${base}/dcc:endPerformanceDate)`,
+    performanceLocation: `string(${base}/dcc:performanceLocation)`,
+  },
+};
+
+describe("CoreDataType", () => {
+  let dcc: DCCDocument, coreData: CoreDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
+  });
+
+  test("should get correct countryCodeISO3166_1 from XML", () => {
+    expect(coreData.countryCodeISO3166_1._text).toBe(select(xpath.coreData.countryCodeISO3166_1, dom));
+  });
+
+  test("should get correct usedLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.usedLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct mandatoryLangCodeISO639_1 from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.coreData.mandatoryLangCodeISO639_1, dom);
+    expect(toTextArr(coreData.mandatoryLangCodeISO639_1)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct unique identifier from XML", () => {
+    expect(coreData.uniqueIdentifier._text).toBe(select(xpath.coreData.uniqueIdentifier, dom));
+  });
+
+  test("should get correct identification issuer from XML", () => {
+    expect(coreData.identifications.identification[0].issuer._text).toBe(select(xpath.coreData.identifications.identification.issuer, dom));
+  });
+
+  test("should get correct identification value from XML", () => {
+    expect(coreData.identifications.identification[0].value._text).toBe(select(xpath.coreData.identifications.identification.value, dom));
+  });
+
+  test("should get correct identification name content from XML", () => {
+    const expected = <Element[]>select(xpath.coreData.identifications.identification.name.content, dom);
+    expect(toTextArr(coreData.identifications.identification[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct receipt date from XML", () => {
+    expect(coreData.receiptDate._text).toBe(select(xpath.coreData.receiptDate, dom));
+  });
+  test("should get correct begin performance date from XML", () => {
+    expect(coreData.beginPerformanceDate._text).toBe(select(xpath.coreData.beginPerformanceDate, dom));
+  });
+  test("should get correct end performance date from XML", () => {
+    expect(coreData.endPerformanceDate._text).toBe(select(xpath.coreData.endPerformanceDate, dom));
+  });
+  test("should get correct performance location from XML", () => {
+    expect(coreData.performanceLocation._text).toBe(select(xpath.coreData.performanceLocation, dom));
+  });
+
+  /* test for setters */
+  test("should set usedLangCodeISO639_1 correctly", () => {
+    fc.assert(
+      fc.property(string_ISO639_1(), (str) => {
+        // add new element to array
+        coreData.usedLangCodeISO639_1.push(new DCCXMLElement({ _text: str }));
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).toContain(str);
+        expect(toTextContentArr(actual)).toContain(str);
+      }),
+    );
+  });
+
+  test("should delete usedLangCodeISO639_1 correctly", () => {
+    const selection = toTextContentArr(<Element[]>select(xpath.coreData.usedLangCodeISO639_1, dom));
+    fc.assert(
+      fc.property(fc.constantFrom(...selection), (str) => {
+        // get index and remove element from array
+        const index = indexOf(coreData.usedLangCodeISO639_1, str);
+        coreData.usedLangCodeISO639_1.splice(index, 1);
+
+        // get actual list from xml
+        const actual = <Element[]>select(xpath.coreData.usedLangCodeISO639_1, dcc);
+
+        expect(toTextArr(coreData.usedLangCodeISO639_1)).not.toContain(str);
+        expect(toTextContentArr(actual)).not.toContain(str);
+      }),
+    );
+  });
+});
diff --git a/tests/DCC/AdministrativeData.Customer.test.ts b/tests/DCC/AdministrativeData.Customer.test.ts
new file mode 100644
index 0000000..911936b
--- /dev/null
+++ b/tests/DCC/AdministrativeData.Customer.test.ts
@@ -0,0 +1,76 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { ContactType, DCCDocument, LocationType } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:customer";
+const xpath = {
+  customer: {
+    name: {
+      content: `${base}/dcc:name/dcc:content`,
+    },
+    email: `string(${base}/dcc:eMail)`,
+    phone: `string(${base}/dcc:phone)`,
+    fax: `string(${base}/dcc:fax)`,
+    location: {
+      city: `${base}/dcc:location/dcc:city[1]`,
+      countryCode: `${base}/dcc:location/dcc:countryCode[1]`,
+      postCode: `${base}/dcc:location/dcc:postCode[1]`,
+      postBoxOffice: `${base}/dcc:location/dcc:postBoxOffice[1]`,
+      state: `${base}/dcc:location/dcc:state[1]`,
+      street: `${base}/dcc:location/dcc:street[1]`,
+      streetNo: `${base}/dcc:location/dcc:streetNo[1]`,
+      further: `${base}/dcc:location/dcc:further[1]/dcc:content`,
+      positionCoordinates: `${base}/dcc:location/dcc:positionCoordinates[1]`,
+    },
+    descriptionData: `${base}/dcc:descriptionData`,
+    _id: `${base}/@id`,
+  },
+};
+
+describe("ContactType", () => {
+  let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
+    location = customer.location; /* TODO: check iff this variable is used anywhere */
+  });
+
+  test("should get correct customer name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.customer.name.content, dom);
+    expect(toTextArr(customer.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct customer email address from XML", () => {
+    expect(customer.eMail._text).toBe(select(xpath.customer.email, dom));
+  });
+
+  test("should get correct customer location city from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.city, dom);
+    expect(customer.location.city[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location county code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.countryCode, dom);
+    expect(customer.location.countryCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location post code from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.postCode, dom);
+    expect(customer.location.postCode[0]._text).toEqual(toTextContentArr(expected)[0]);
+  });
+
+  test("should get correct customer location further from XML", () => {
+    const expected = <Element[]>select(xpath.customer.location.further, dom);
+
+    for (let i = 0; i < expected.length; i++) {
+      expect(customer.location.further[0].content[i]._text).toBe(expected[i].textContent);
+    }
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.Items.test.ts b/tests/DCC/AdministrativeData.Items.test.ts
index 79dfe54..ce71db4 100644
--- a/tests/DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -51,7 +50,7 @@ describe("ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/AdministrativeData.RespPersons.test.ts b/tests/DCC/AdministrativeData.RespPersons.test.ts
new file mode 100644
index 0000000..101c5d2
--- /dev/null
+++ b/tests/DCC/AdministrativeData.RespPersons.test.ts
@@ -0,0 +1,55 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { RespPersonType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:respPersons";
+const xpath = {
+  respPersons: {
+    respPerson1: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[1]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+      mainSigner: `string(${base}/dcc:respPerson[1]/dcc:mainSigner)`,
+    },
+    respPerson2: {
+      person: {
+        name: {
+          content: `${base}/dcc:respPerson[2]/dcc:person/dcc:name/dcc:content`,
+        },
+      },
+    },
+  },
+};
+
+describe("ContactType", () => {
+  let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
+    respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
+  });
+
+  test("should get correct responsible person 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson1.person.name.content, dom);
+    expect(toTextArr(respPerson1.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct responsible person 1 main signer flag from XML", () => {
+    expect(respPerson1.mainSigner._text).toBe(select(xpath.respPersons.respPerson1.mainSigner, dom));
+  });
+
+  test("should get correct responsible person 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.respPersons.respPerson2.person.name.content, dom);
+    expect(toTextArr(respPerson2.person.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
index 6139807..3486290 100644
--- a/tests/DCC/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -24,7 +23,7 @@ describe("DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/AdministrativeData.Statements.test.ts b/tests/DCC/AdministrativeData.Statements.test.ts
new file mode 100644
index 0000000..f3de295
--- /dev/null
+++ b/tests/DCC/AdministrativeData.Statements.test.ts
@@ -0,0 +1,212 @@
+/**
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
+ */
+
+import { select, toTextArr, toTextContentArr } from "../util";
+import { StatementMetaDataType, DCCDocument } from "../../src";
+
+const base = "/dcc:digitalCalibrationCertificate/dcc:administrativeData/dcc:statements";
+const xpath = {
+  statements: {
+    statement1: {
+      norm: `string(${base}/dcc:statement[1]/dcc:norm)`,
+      reference: `string(${base}/dcc:statement[1]/dcc:reference)`,
+      declaration: {
+        content: `${base}/dcc:statement[1]/dcc:declaration/dcc:content`,
+      },
+      refType: `string(${base}/dcc:statement[1]/@refType)`,
+    },
+    statement2: {
+      declaration: {
+        content: `${base}/dcc:statement[2]/dcc:declaration/dcc:content`,
+      },
+      data: {
+        quantity1: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[1]/si:real/si:unit)`,
+          },
+        },
+        quantity2: {
+          name: {
+            content: `${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/dcc:name/dcc:content`,
+          },
+          si_real: {
+            si_value: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:value)`,
+            si_unit: `string(${base}/dcc:statement[2]/dcc:data/dcc:quantity[2]/si:real/si:unit)`,
+          },
+        },
+      },
+      refType: `string(${base}/dcc:statement[2]/@refType)`,
+    },
+    statement3: {
+      declaration: {
+        content: `${base}/dcc:statement[3]/dcc:declaration/dcc:content`,
+      },
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      conformity: `string(${base}/dcc:statement[3]/dcc:conformity)`,
+      refType: `string(${base}/dcc:statement[3]/@refType)`,
+    },
+    statement4: {
+      declaration: {
+        content: `${base}/dcc:statement[4]/dcc:declaration/dcc:content`,
+      },
+      date: `string(${base}/dcc:statement[4]/dcc:date)`,
+      respAuthority: {
+        name: {
+          content: `${base}/dcc:statement[3]/dcc:respAuthority/dcc:name/dcc:content`,
+        },
+        email: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:email)`,
+        location: {
+          city: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:city)`,
+          countryCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:countryCode)`,
+          postCode: `string(${base}/dcc:statement[3]/dcc:respAuthority/dcc:location/dcc:postCode)`,
+        },
+      },
+      refType: `string(${base}/dcc:statement[4]/@refType)`,
+    },
+  },
+};
+
+describe("ItemType", () => {
+  let dcc: DCCDocument, statement1, statement2, statement3, statement4: StatementMetaDataType, dom;
+
+  beforeEach(() => {
+    ({ dcc, dom } = recreateEnv());
+    statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
+    statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
+    statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
+    statement4 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[3];
+  });
+
+  test("should get correct statement 1 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement1.declaration.content, dom);
+    expect(toTextArr(statement1.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 1 norm model from XML", () => {
+    expect(statement1.norm[0]._text).toBe(select(xpath.statements.statement1.norm, dom));
+  });
+
+  test("should get correct statement 1 reference from XML", () => {
+    expect(statement1.reference[0]._text).toBe(select(xpath.statements.statement1.reference, dom));
+  });
+
+  test("should get correct statement 2 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.declaration.content, dom);
+    expect(toTextArr(statement2.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity1.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[0].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 1 si:value from XML", () => {
+    expect(statement2.data.quantity[0].real.value._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[0].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity1.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement2.data.quantity2.name.content, dom);
+    expect(toTextArr(statement2.data.quantity[1].name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:value from XML", () => {
+    expect(statement2.data.quantity[1].real.value._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_value, dom));
+  });
+
+  test("should get correct statement 2 data quantity 2 si:unit from XML", () => {
+    expect(statement2.data.quantity[1].real.unit._text).toBe(select(xpath.statements.statement2.data.quantity2.si_real.si_unit, dom));
+  });
+
+  test("should get correct statement 2 refType from XML", () => {
+    expect(statement2._attr.refType).toBe(select(xpath.statements.statement2.refType, dom));
+  });
+
+  test("should get correct statement 3 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.declaration.content, dom);
+    expect(toTextArr(statement3.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 3 responsible authority name content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement3.respAuthority.name.content, dom);
+    expect(toTextArr(statement3.respAuthority.name.content)).toEqual(toTextContentArr(expected));
+  });
+
+  /* responsible authority 3 */
+  test("should get correct statement 3 responsible authority email from XML", () => {
+    expect(statement3.respAuthority.eMail._text).toBe(select(xpath.statements.statement3.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 3 responsible authority location city from XML", () => {
+    expect(statement3.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 3 responsible authority location country code from XML", () => {
+    expect(statement3.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 3 responsible authority location post code from XML", () => {
+    expect(statement3.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement3.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 3 conformity from XML", () => {
+    expect(statement3.conformity._text).toBe(select(xpath.statements.statement3.conformity, dom));
+  });
+
+  test("should get correct statement 3 refType from XML", () => {
+    expect(statement3._attr.refType).toBe(select(xpath.statements.statement3.refType, dom));
+  });
+
+  test("should get correct statement 4 declaration content from XML", () => {
+    // get expected list from example xml
+    const expected = <Element[]>select(xpath.statements.statement4.declaration.content, dom);
+    expect(toTextArr(statement4.declaration.content)).toEqual(toTextContentArr(expected));
+  });
+
+  test("should get correct statement 4 date from XML", () => {
+    expect(statement4.date._text).toBe(select(xpath.statements.statement4.date, dom));
+  });
+
+  /* responsible authority 4 */
+  test("should get correct statement 4 responsible authority email from XML", () => {
+    expect(statement4.respAuthority.eMail._text).toBe(select(xpath.statements.statement4.respAuthority.email, dom));
+  });
+
+  test("should get correct statement 4 responsible authority location city from XML", () => {
+    expect(statement4.respAuthority.location.city[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.city, dom));
+  });
+  test("should get correct statement 4 responsible authority location country code from XML", () => {
+    expect(statement4.respAuthority.location.countryCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.countryCode, dom));
+  });
+  test("should get correct statement 4 responsible authority location post code from XML", () => {
+    expect(statement4.respAuthority.location.postCode[0]._text).toBe(select(xpath.statements.statement4.respAuthority.location.postCode, dom));
+  });
+
+  test("should get correct statement 4 refType from XML", () => {
+    expect(statement4._attr.refType).toBe(select(xpath.statements.statement4.refType, dom));
+  });
+
+  /* TODO: setters */
+});
diff --git a/tests/DCC/AdministrativeData.test.ts b/tests/DCC/AdministrativeData.test.ts
index b6f6ade..920cf98 100644
--- a/tests/DCC/AdministrativeData.test.ts
+++ b/tests/DCC/AdministrativeData.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { testCalibrationLaboratory } from "./common/AdministrativeData/CalibrationLaboratory";
diff --git a/tests/DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/DigitalCalibrationCertificateType.test.ts
index eaceec3..917b0b9 100644
--- a/tests/DCC/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select } from "../util";
@@ -11,7 +10,7 @@ describe("DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
index 0bf3cce..e56ab79 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
index 0c3aaf0..de86693 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import * as fc from "fast-check";
@@ -34,7 +33,7 @@ describe("GP_DCC_Temperature_Simplified: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
index 99bc252..4ecf28e 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Simplified: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
index 66f37cf..5b62ce3 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -51,7 +50,7 @@ describe("GP_DCC_Temperature_Simplified: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
index 8d52086..b066bcb 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_DCC_Temperature_Simplified: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
index fb27ba6..e6d4a11 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -20,7 +19,7 @@ describe("GP_DCC_Temperature_Simplified: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
index f68a629..2b135b1 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -52,7 +51,7 @@ describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
index df17932..b8a7039 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_DCC_Temperature_Simplified: DigitalCalibrationCertificateType", ()
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index f989c1d..863afe1 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -84,7 +83,7 @@ describe("GP_DCC_Temperature_Simplified: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index d130350..ef4b706 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Simplified: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
index 6fad3df..237dc63 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_DCC_Temperature_Simplified: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
index 4fd7681..eba3b9c 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -106,7 +105,7 @@ describe("GP_DCC_Temperature_Simplified: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 6becd0f..3702d11 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
index de4e310..68a193b 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Items_variant.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified_variant.xml" }
  */
 
 import { select } from "../../util";
@@ -22,7 +21,7 @@ describe("GP_DCC_Temperature_Typical: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, equipmentClass: EquipmentClassType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     equipmentClass = item.equipmentClass[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
index 26ad9a3..2ed48e7 100644
--- a/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Simplified_variant/AdministrativeData.Statements_variant.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Simplified_variant.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Simplified_variant.xml" }
  */
 
 import * as fc from "fast-check";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Simplified: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement3: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
index fdaf96a..4809389 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_DCC_Temperature_Typical: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
index da8c8ee..62dfb12 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import * as fc from "fast-check";
@@ -35,7 +34,7 @@ describe("GP_DCC_Temperature_Typical: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
index e03dd5c..2c9ad6b 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -35,7 +34,7 @@ describe("GP_DCC_Temperature_Typical: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
index dce1bac..b6f216f 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -51,7 +50,7 @@ describe("GP_DCC_Temperature_Typical: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
index 583b3f8..58c2b10 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_DCC_Temperature_Typical: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
index cb02695..e08ed62 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -22,7 +21,7 @@ describe("GP_DCC_Temperature_Typical: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
index 0c5ae36..147a798 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -86,7 +85,7 @@ describe("GP_DCC_Temperature_Typical: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2, statement3, statement4: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
     statement3 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[2];
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
index 110f096..f7b0a34 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_DCC_Temperature_Typical: DigitalCalibrationCertificateType", () =>
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index 436f8d3..9ab5918 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -103,7 +102,7 @@ describe("GP_DCC_Temperature_Typical: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 856134e..0ec9d18 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_DCC_Temperature_Typical: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
index 892a1f3..076be1a 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_DCC_Temperature_Typical: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
index 9efe9ae..6920a11 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -101,7 +100,7 @@ describe("GP_DCC_Temperature_Typical: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 4738344..1fc11df 100644
--- a/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_DCC_Temperature_Typical/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_Typical.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_Typical.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -39,7 +38,7 @@ describe("GP_DCC_Temperature_Typical: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
index 2e618ce..a62165f 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_Temperature_v3.2.0_DCC: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
index 4affcd1..773f073 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import * as fc from "fast-check";
@@ -36,7 +35,7 @@ describe("GP_Temperature_v3.2.0_DCC: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
index af5a456..4404f78 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
index f1d47d2..e5e1e48 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -62,7 +61,7 @@ describe("GP_Temperature_v3.2.0_DCC: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification1, identification2, identification3: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification1 = item.identifications.identification[0];
     identification2 = item.identifications.identification[1];
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
index 55167b5..25f3e65 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RefTypeDefinitons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: RefTypeDefinitionType", () => {
   let dcc: DCCDocument, refTypeDefinition: RefTypeDefinitionType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     refTypeDefinition = dcc.digitalCalibrationCertificate.administrativeData.refTypeDefinitions.refTypeDefinition[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
index a2ac963..73c8b82 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -31,7 +30,7 @@ describe("GP_Temperature_v3.2.0_DCC: RespPersonType", () => {
   let dcc: DCCDocument, respPerson1, respPerson2: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson1 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
     respPerson2 = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[1];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
index fd5381e..95c0088 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -27,7 +26,7 @@ describe("GP_Temperature_v3.2.0_DCC: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
index 9cf4423..b943a0a 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/AdministrativeData.Statements.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -52,7 +51,7 @@ describe("GP_Temperature_v3.2.0_DCC: StatementMetaDataType", () => {
   let dcc: DCCDocument, statement1, statement2: StatementMetaDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     statement1 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[0];
     statement2 = dcc.digitalCalibrationCertificate.administrativeData.statements.statement[1];
   });
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
index c279ef1..467d936 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("GP_Temperature_v3.2.0_DCC: DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index d40fa27..ce1bb26 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -84,7 +83,7 @@ describe("GP_Temperature_v3.2.0_DCC: InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 9a03c23..ffdb5cd 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -28,7 +27,7 @@ describe("GP_Temperature_v3.2.0_DCC: MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
index 903a524..05660a4 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_Temperature_v3.2.0_DCC: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
index 0198891..63aa159 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -206,7 +205,7 @@ describe("GP_Temperature_v3.2.0_DCC: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 1651c10..8352a94 100644
--- a/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.0_DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -26,7 +25,7 @@ describe("GP_Temperature_v3.2.0_DCC: UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
index 7d9e8e7..8df1fe8 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { select } from "../../util";
@@ -20,7 +19,7 @@ describe("GP_Temperature_v3.2.1_DCC: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
index 08474c9..12eb493 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.Item.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { DCCDocument, ItemType } from "../../../src";
@@ -9,7 +8,7 @@ describe("GP_Temperature_v3.2.1_DCC: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
   });
 
diff --git a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
index 632535f..ac03d09 100644
--- a/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
+++ b/tests/DCC/GP_Temperatur_v3.2.1_DCC/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.1_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.1_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("GP_Temperature_v3.2.1_DCC: ItemListType", () => {
   let dcc: DCCDocument, items: ItemListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     items = dcc.digitalCalibrationCertificate.administrativeData.items;
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
index 5f4974e..4607750 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.InfluenceConditions.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -103,7 +102,7 @@ describe("InfluenceConditionListType", () => {
   let dcc: DCCDocument, influenceConditions: InfluenceConditionListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     influenceConditions = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].influenceConditions;
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
index 8107d84..187b54d 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.MeasuringEquipments.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -28,7 +27,7 @@ describe("MeasuringEquipmentType", () => {
   let dcc: DCCDocument, measuringEquipment: MeasuringEquipmentType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measuringEquipment = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].measuringEquipments.measuringEquipment[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
index 1828f27..1dc5e99 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -21,7 +20,7 @@ describe("MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
index 64536b7..39e6b5e 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -101,7 +100,7 @@ describe("ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
index 54cdf56..cb502b6 100644
--- a/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
+++ b/tests/DCC/MeasurementResults.MeasurementResult.UsedMethods.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -39,7 +38,7 @@ describe("UsedMethodListType", () => {
   let dcc: DCCDocument, usedMethods: UsedMethodListType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     usedMethods = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].usedMethods;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
index 3529e3b..43fc202 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CalibrationLaboratory.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -18,7 +17,7 @@ describe("Test_DCC_Minimal: CalibrationLaboratoryType", () => {
   let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
index e9ca47c..758923e 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.CoreDataType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import * as fc from "fast-check";
@@ -34,7 +33,7 @@ describe("Test_DCC_Minimal: CoreDataType", () => {
   let dcc: DCCDocument, coreData: CoreDataType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
index 3888155..c060405 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Customer.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -22,7 +21,7 @@ describe("Test_DCC_Minimal: ContactType", () => {
   let dcc: DCCDocument, customer: ContactType, location: LocationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     customer = dcc.digitalCalibrationCertificate.administrativeData.customer;
     location = customer.location; /* TODO: check iff this variable is used anywhere */
   });
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
index 958427c..0479cb5 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.Items.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -35,7 +34,7 @@ describe("Test_DCC_Minimal: ItemType", () => {
   let dcc: DCCDocument, item: ItemType, identification: IdentificationType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     item = dcc.digitalCalibrationCertificate.administrativeData.items.item[0];
     identification = item.identifications.identification[0];
   });
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
index 7c74d61..3587b34 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.RespPersons.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -23,7 +22,7 @@ describe("Test_DCC_Minimal: RespPersonType", () => {
   let dcc: DCCDocument, respPerson: RespPersonType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     respPerson = dcc.digitalCalibrationCertificate.administrativeData.respPersons.respPerson[0];
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
index 3577e44..cacf9e4 100644
--- a/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/AdministrativeData.SoftwareListType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -24,7 +23,7 @@ describe("Test_DCC_Minimal: DccSoftwareType", () => {
   let dcc: DCCDocument, dccSoftware: SoftwareListType, software: SoftwareType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     dccSoftware = dcc.digitalCalibrationCertificate.administrativeData.dccSoftware;
     software = dccSoftware.software[0];
   });
diff --git a/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
index 1f0006a..ef82732 100644
--- a/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/DigitalCalibrationCertificateType.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select } from "../../util";
@@ -11,7 +10,7 @@ describe("Test_DCC_Minimal: DigitalCalibrationCertificateType", () => {
   let xml, dcc, dom;
 
   beforeEach(() => {
-    ({ xml, dcc, dom } = xmlEnv.recreateEnv());
+    ({ xml, dcc, dom } = recreateEnv());
   });
 
   test("should get correct schemaVersion from XML", () => {
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
index bd50cc0..ec2478b 100644
--- a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Name.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -21,7 +20,7 @@ describe("Test_DCC_Minimal: MeasurementResultType", () => {
   let dcc: DCCDocument, measurementResult: MeasurementResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     measurementResult = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0];
   });
 
diff --git a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
index 06a0973..4e6f9a0 100644
--- a/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
+++ b/tests/DCC/Test_DCC_Minimal/MeasurementResults.MeasurementResult.Results.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/Test_DCC_Minimal.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/Test_DCC_Minimal.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../../util";
@@ -48,7 +47,7 @@ describe("Test_DCC_Minimal: ResultType", () => {
   let dcc: DCCDocument, result: ResultType, dom;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
index 25a455d..a6afc21 100644
--- a/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
+++ b/tests/DCC/common/AdministrativeData/CalibrationLaboratory.ts
@@ -23,7 +23,7 @@ export const testCalibrationLaboratory = () => {
     let dcc: DCCDocument, calibrationLaboratory: CalibrationLaboratoryType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       calibrationLaboratory = dcc.digitalCalibrationCertificate.administrativeData.calibrationLaboratory;
     });
 
diff --git a/tests/DCC/common/AdministrativeData/CoreDataType.ts b/tests/DCC/common/AdministrativeData/CoreDataType.ts
index ea974a5..279e2a0 100644
--- a/tests/DCC/common/AdministrativeData/CoreDataType.ts
+++ b/tests/DCC/common/AdministrativeData/CoreDataType.ts
@@ -31,7 +31,7 @@ export const testCoreData = () => {
     let dcc: DCCDocument, coreData: CoreDataType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       coreData = dcc.digitalCalibrationCertificate.administrativeData.coreData;
     });
 
diff --git a/tests/DCC/common/AdministrativeData/RespPersons.ts b/tests/DCC/common/AdministrativeData/RespPersons.ts
index 88495a0..79ce09c 100644
--- a/tests/DCC/common/AdministrativeData/RespPersons.ts
+++ b/tests/DCC/common/AdministrativeData/RespPersons.ts
@@ -7,7 +7,7 @@ const xpath = {
 };
 export const testRespPersonListType = () => {
   describe("RespPersonListType", () => {
-    const { dom } = xmlEnv.recreateEnv();
+    const { dom } = recreateEnv();
 
     const expectedRespPersons = <Element[]>select(xpath.respPerson, dom);
     for (let i = 0; i < expectedRespPersons.length; i++) {
diff --git a/tests/DCC/common/Types/ContactType.ts b/tests/DCC/common/Types/ContactType.ts
index 07b0d21..1428d9f 100644
--- a/tests/DCC/common/Types/ContactType.ts
+++ b/tests/DCC/common/Types/ContactType.ts
@@ -30,7 +30,7 @@ export const testContactType = (base: string, contactTypeFn: (dcc: DCCDocument)
     let dcc: DCCDocument, contactType: ContactType | ContactNotStrictType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       contactType = contactTypeFn(dcc);
     });
 
diff --git a/tests/DCC/common/Types/DataType.ts b/tests/DCC/common/Types/DataType.ts
index e39bb76..86ac66b 100644
--- a/tests/DCC/common/Types/DataType.ts
+++ b/tests/DCC/common/Types/DataType.ts
@@ -12,10 +12,11 @@ export const testDataType = (base: string, dataTypeFn: (dcc: DCCDocument) => Dat
     let dcc: DCCDocument, dataType: DataType, dom;
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       dataType = dataTypeFn(dcc);
     });
 
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
     test("noop", () => {});
 
     // TODO(Statement): quantity with real
diff --git a/tests/DCC/common/Types/RespPersonType.ts b/tests/DCC/common/Types/RespPersonType.ts
index 4284f9e..13064d4 100644
--- a/tests/DCC/common/Types/RespPersonType.ts
+++ b/tests/DCC/common/Types/RespPersonType.ts
@@ -10,10 +10,10 @@ export const testRespPersonType = (base: string, respPersonTypeFn: (dcc: DCCDocu
 
   describe("RespPersonType", () => {
     let dcc: DCCDocument, respPersonType: RespPersonType, dom;
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       respPersonType = respPersonTypeFn(dcc);
     });
 
diff --git a/tests/DCC/common/Types/StatementListType.ts b/tests/DCC/common/Types/StatementListType.ts
index 254fda4..09b54e0 100644
--- a/tests/DCC/common/Types/StatementListType.ts
+++ b/tests/DCC/common/Types/StatementListType.ts
@@ -8,7 +8,7 @@ export const testStatementListType = (base, statementListTypeFn: (dcc: DCCDocume
   };
 
   describe("StatementListType", () => {
-    const { dom } = xmlEnv.recreateEnv();
+    const { dom } = recreateEnv();
 
     const expectedStatements = <Element[]>select(xpath.statement, dom);
     for (let i = 0; i < expectedStatements.length; i++) {
diff --git a/tests/DCC/common/Types/StatementMetaDataType.ts b/tests/DCC/common/Types/StatementMetaDataType.ts
index 5e09d86..3ec8b7d 100644
--- a/tests/DCC/common/Types/StatementMetaDataType.ts
+++ b/tests/DCC/common/Types/StatementMetaDataType.ts
@@ -20,10 +20,10 @@ export const testStatementMetaDataType = (name, base: string, statementMetaDataT
 
   describe(`StatementMetaDataType ${name}`, () => {
     let dcc: DCCDocument, statementMetaDataType: StatementMetaDataType, dom;
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
 
     beforeEach(() => {
-      ({ dcc, dom } = xmlEnv.recreateEnv());
+      ({ dcc, dom } = recreateEnv());
       statementMetaDataType = statementMetaDataTypeFn(dcc);
     });
 
diff --git a/tests/DCCDocument.test.ts b/tests/DCCDocument.test.ts
index 06dccbf..8ad62d1 100644
--- a/tests/DCCDocument.test.ts
+++ b/tests/DCCDocument.test.ts
@@ -1,13 +1,12 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/example.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/example.xml" }
  */
 
 describe("DCCDocument", () => {
   let xml, dcc;
 
   beforeEach(() => {
-    ({ xml, dcc } = xmlEnv.recreateEnv());
+    ({ xml, dcc } = recreateEnv());
   });
 
   test("fromXml() and toXml() should not modify XML", () => {
diff --git a/tests/GP_Temperature/CharsXMLList.test.ts b/tests/GP_Temperature/CharsXMLList.test.ts
index ac10b24..1d0f83c 100644
--- a/tests/GP_Temperature/CharsXMLList.test.ts
+++ b/tests/GP_Temperature/CharsXMLList.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select } from "../util";
@@ -15,7 +14,7 @@ describe("CharsXMLList", () => {
   let dcc: DCCDocument, dom, result;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/GP_Temperature/noQuantity.test.ts b/tests/GP_Temperature/noQuantity.test.ts
index 8b8bc09..4eec495 100644
--- a/tests/GP_Temperature/noQuantity.test.ts
+++ b/tests/GP_Temperature/noQuantity.test.ts
@@ -1,6 +1,5 @@
 /**
- * @jest-environment ./tests/XMLEnvironment.ts
- * @xml ./tests/resources/GP_Temperature_v3.2.0_DCC.xml
+ * @vitest-environment-options { "xmlPath": "./tests/resources/GP_Temperature_v3.2.0_DCC.xml" }
  */
 
 import { select, toTextArr, toTextContentArr } from "../util";
@@ -28,7 +27,7 @@ describe("noQuantity", () => {
   let dcc: DCCDocument, dom, result;
 
   beforeEach(() => {
-    ({ dcc, dom } = xmlEnv.recreateEnv());
+    ({ dcc, dom } = recreateEnv());
     result = dcc.digitalCalibrationCertificate.measurementResults.measurementResult[0].results.result[0];
   });
 
diff --git a/tests/XMLEnvironment.ts b/tests/XMLEnvironment.ts
deleted file mode 100644
index 10160de..0000000
--- a/tests/XMLEnvironment.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import * as fs from "fs/promises";
-import { DCCDocument } from "../src";
-import NodeEnvironment from "jest-environment-node";
-import { JSDOM } from "jsdom";
-
-export default class XMLEnvironment extends NodeEnvironment {
-  xmlPath: string;
-  xml: string;
-
-  constructor(config, context) {
-    super(config, context);
-    const xmlPath = context.docblockPragmas["xml"];
-    if (xmlPath && typeof xmlPath === "string") {
-      this.xmlPath = xmlPath;
-    }
-  }
-
-  async setup() {
-    await super.setup();
-    if (this.xmlPath) {
-      this.xml = await this.readFile(this.xmlPath);
-    }
-    this.global.xmlEnv = this;
-  }
-
-  recreateEnv(): { xml: string; dcc: DCCDocument; dom: JSDOM } {
-    return {
-      xml: this.xml,
-      dcc: this.xml ? DCCDocument.fromXml(this.xml) : DCCDocument.createEmpty(),
-      dom: new JSDOM(this.xml, { contentType: "application/xml" }),
-    };
-  }
-
-  async readFile(path: string) {
-    // check if file exists
-    if ((await fs.stat(path)).isFile()) {
-      return await fs.readFile(path, { encoding: "utf-8" });
-    } else {
-      throw new Error(`File ${path} does not exist.`);
-    }
-  }
-}
-
-export const TestEnvironment = XMLEnvironment;
diff --git a/tests/index.d.ts b/tests/index.d.ts
deleted file mode 100644
index facbc06..0000000
--- a/tests/index.d.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import XMLEnvironment from "./XMLEnvironment";
-
-declare let xmlEnv: XMLEnvironment;
-
-declare global {
-  let xmlEnv: XMLEnvironment;
-  namespace NodeJS {
-    interface Global {
-      xmlEnv: XMLEnvironment;
-    }
-  }
-}
diff --git a/tests/tsconfig.json b/tests/tsconfig.json
index e6db6f1..564b624 100644
--- a/tests/tsconfig.json
+++ b/tests/tsconfig.json
@@ -2,9 +2,7 @@
   "compilerOptions": {
     "target": "ES6",
     "declaration": true,
-    "module": "commonjs"
-  },
-  "files": [
-    "./index.d.ts"
-  ]
+    "module": "commonjs",
+    "types": ["vitest/globals"]
+  }
 }
diff --git a/tests/vitest-environment-custom/index.ts b/tests/vitest-environment-custom/index.ts
new file mode 100644
index 0000000..c01dccf
--- /dev/null
+++ b/tests/vitest-environment-custom/index.ts
@@ -0,0 +1,48 @@
+import * as fs from "fs/promises";
+import { DCCDocument } from "../../src";
+import type { Environment } from "vitest";
+import { JSDOM } from "jsdom";
+import { builtinEnvironments } from "vitest/environments";
+
+declare global {
+  function recreateEnv(): { xml: string; dcc: DCCDocument; dom: JSDOM };
+}
+
+type Options = {
+  custom: {
+    xmlPath: string;
+  };
+};
+
+async function readFile(path: string) {
+  // check if file exists
+  if ((await fs.stat(path)).isFile()) {
+    return await fs.readFile(path, { encoding: "utf-8" });
+  } else {
+    throw new Error(`File ${path} does not exist.`);
+  }
+}
+
+export default <Environment>{
+  name: "custom",
+  async setup(global, { custom }: Options) {
+    const env = builtinEnvironments["node"];
+    const envReturn = await env.setup(global, {});
+
+    const xml = await readFile(custom.xmlPath);
+    global.recreateEnv = (): { xml: string; dcc: DCCDocument; dom: JSDOM } => {
+      return {
+        xml,
+        dcc: xml ? DCCDocument.fromXml(xml) : DCCDocument.createEmpty(),
+        dom: new JSDOM(xml, { contentType: "application/xml" }),
+      };
+    };
+
+    return {
+      async teardown(global) {
+        delete global.recreateEnv;
+        await envReturn.teardown(global);
+      },
+    };
+  },
+};
diff --git a/tests/vitest-environment-custom/package.json b/tests/vitest-environment-custom/package.json
new file mode 100644
index 0000000..a3717c6
--- /dev/null
+++ b/tests/vitest-environment-custom/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "vitest-environment-custom",
+  "private": true,
+  "main": "index.ts"
+}
diff --git a/tsconfig.json b/tsconfig.json
index c5294d3..3b65aca 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -4,7 +4,7 @@
     "module": "commonjs",
     "declaration": true,
     "sourceMap": true,
-    "outDir": "./lib",
+    "outDir": "./lib"
   },
   "include": [
     "src"
diff --git a/vite.config.ts b/vite.config.ts
new file mode 100644
index 0000000..8473f68
--- /dev/null
+++ b/vite.config.ts
@@ -0,0 +1,23 @@
+/// <reference types="vitest" />
+
+import { defineConfig } from "vite";
+import AutoImport from "unplugin-auto-import/vite";
+
+export default defineConfig({
+  plugins: [
+    AutoImport({
+      imports: ["vitest"],
+      dts: true, // generate TypeScript declaration
+    }),
+  ],
+  test: {
+    globals: true,
+    environment: "custom",
+    reporters: ["default", "junit"],
+    outputFile: "junit.xml",
+    coverage: {
+      provider: "istanbul",
+      reporter: ["text-summary", "cobertura"],
+    },
+  },
+});
diff --git a/yarn.lock b/yarn.lock
index 57b5e4e98b2ffb46897ec2bb54de824096681d8a..73ae83801f85034343d96fab25c7da0d9b2a337a 100644
GIT binary patch
delta 41188
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

delta 66451
zcmcHC3A|kCSswUb-R_opQ%hG%YiX(bO1-#S(v@mo8oS+1yn~G$mf$$CeX8n|THV@w
zuhec2j>{$l$YOAF>=X&$4QG;&049QHATi)ch78F7F%v?<WU&(uHefn7;6TFS{NHn`
z?yahOwRqwQftIRHmFj%w{odtyp7;H}`}c2s-*?{eo}U~2!`~?F8g2W#rCrZ`?%r(Y
z^ZQ4?l$7qsPLvi)mF)3SYuInq`;}I?UvAc$?M|iEsaE=}YQ0vjHahicz1vFby>_+P
zZ6vLJtuq+3Yn`Op={M@FbkOaz`n^W0)k~6gH>nM}jozSKtu?Flw37@v{c@+-s3e14
ztzWNHs!6?(R?CfYt=dkyy-v55RI8nAaZe>XansIkDxWAHUwXWobkj2@d*}P<@?a%7
zn?8Q-!r4dP*g8?Eo~YEW^?v(A^T?yOFD*TjuB@Iuf9}yGpYdAuu04CR^EWLnRNC1W
zzGGkZo*lOipFDl)$us`<;*m#};;UWegS{uy-qWj>&OW+S>G+-9v{q?V`>kfX-W_z@
z*Pz)+(ptBbR2oUAU9Y4`r(d-sy>`9UY*zb?a<AWS^_%rpdC>3l+G(@iP22T;xmKxE
zEMihGw`=uwGhG@CtW{^=>juqkw_EMCJA>AsTIu%UjaoM=z2R8)(Yv-}KYsI$Tl~Ok
zIZL+fy19I!QqOPa$8X*>jK3V2`PI!{Cmp2LzE&-F>i)fcx$Ci3nvF&~zP*>UD($q<
zFIOsqR??^@Ew|Ecl>MO*&#RnP+l@w&G?HpsZZ~V4hTqfotNPVmtJmpNs_lNS-|lw?
z{lQ={?bK_PX17&MdV@x<*&Jja`t4)ckKVO4`_5ao-BLNxJie5@>z0SJPrP|gwzO}{
z_TKrG;#tP+oTy}#x9!h<^OgfQRZf(%`<4#foIk6dI(+D+@`+aViY+I$`mftt%3il)
zZ}#3Ti${E@5-%(r8QaK{>6r_jb@2>+XDfSr=|KMRpWb#b|L^~H;9x9TH9Nd@fBwRY
zw!UN7tftLgEv;7SoupM}u$@-b!ZilvzE{&uEA6<=)FbJYYaV02o!08jTEEe6b(2ol
zwee6Z<v}uNb-K+;qh<*z&AOFqRtME?zh14?+MYqvLvN<Fq@C1#M>VOo%B^OaJ@+le
zvwiy3oee*F&7@DI=hBtr;`x<{#apO(gN~IeOyKX`x>(pl>7U-4eR9v8`R#q~)??Y@
zw;dQZ2F)a?_S?;5P;I8ICNphzs<ouitJNzV8?l~LDxGennWmjy&x>J*jk^7vGUh>-
z6<7O7+P6~mMmuRH<z{!lhM0M!pLT8c&LB-1oo;*3Y*_~e&?&b%wO*%bzx1;wZmwk8
z@7$XGxh=bvCU+ALXp`G%G3a~a!aMQ{bK_`baZ~TVeP^kh{n+it3)A@2?e7@2do_Ed
zRqG~pQ8lf!%Z+ZW%vj5<q}wku?{?DbrsZ<l<(L|+=AhgycRYw*uh}S<TZ2liQtdX{
zowV2M)@$`nuaUHStwG!6gKE;PbUOT0pIOw(-9e>XW9zj#57)0Hwca56_^Ehw+p^~m
zuiqED?abd-yq4dW3y0(T%CDQ*uia{+Qmzb|6~3e2^Smk+y;b9Ld*yc0ulna(&1O3-
zH=E3F&}=uFo>Y6#Pd%zmyW1;QJm^8Q+NrfuJGWkM*w&qDQm)o3<#xZ`@O*0fQXY8F
zZ@P(YyVa_;8r@c{*Q?h@Z~l=|Y}mW9`;Kh8ck-AjofG8^x5G!LyX@j^ap`T78}jP&
z2eJ<y*nNw8tCVfBeZ%<p%uS~D#-P#f)~n(}qu#U$dev^b-{LJfoo>VH?Llvl`g@yk
zaXnooHsFlP1HmWlHQR2bR<qCe-gcE=V{3!NYrK{(<kzYdw&zRQi)EJ4@{l_mG{YD)
zvrm0PJhKP(`HfeL5BFvtyKDE&5eLQ*V%IRPp1F_k=(R?d)iehEq+PCx34=ka+Z<H;
zgL1RxiB&6AJELh2`BOP@b(xRvr%k)0&8_n@X|-2rG|G)$C8;FkdbieefAwA`>G3;#
zca~P0{bsqd*y^^L{;duN+iMJxYI*d!a_MOPwBEgCYj$wQ_G{lzanYUEyQx~IHt^HB
zwVEGO5!$MDP_5molsj#|yw#`=%9Vb#(@U6HFKzYeX`@|h^pioEJL|S9gIeMNwfYeW
z+Z<?zl_p8r>NXlx55fa%RH~Im*(=o@-L%teb<4ear`ByImHz0p<*^06d&^?>_Ql)o
z4j(^neS+VIzHe9d`MdARTsGw<Dx)X<eQ9q5^z1W-mu`&>7V$yAxcBz;z@DAoxhH%5
z&Rra2)t{?zT|C;Q?CbU)$Sysw<7PHn$>u^vSo3}{HbT&PUSOwHI%zi<B+ZVDrrl~Z
zd(CcA?zdZ&W~<fhmdmwPTJ9(1@S<t8>M^%^wRXSJDqHDZJF&QpdaYM(+1hEVEv;%M
zom#8oZ#6!w-YHi)t%%fvYOS@Md+OF319sjGmzDk4v&X~#3@@Cybn5iE<x3Y&pIM!3
z-0AG8h>XjdT~;ZdsIP^bYh5>!Zp~geocV_<^%IR7`bO)1L)UR3*S>CFkrB2xc&fkt
zhowDXC>s|jk1N&Ld}+|^C250G8T8pcOYTbHJlaaPQtsAeah-OfTQ8S;y;i5*?^K&%
z_?1)?_oO|hYR9H%CVfw{Ug<VF^@tbUW?HX2Sdj_#``u2s=$3FI%EsPFyRt^kyekW9
z)klkO9B=8zckjGAPxCfJ{P7)aXTf)7uiky@sPq%1{Y-v0+pNymX40?NUMUAEDA>0H
zf2_$^8$x9xZQGw!K1)*2Ez7=b%5J?^t1;%Z-l{fggJxag5<gcc<V8ExR+1()9;rO2
zwB1L!mbU7He!o$xv@4C?4#_~HoRkx3W=}SeWN&#>5gb3T=g>Xlq<VfU$JP@UU$mZ!
zZ{lfr&{{tg<ZA5}&)H2Y5*a_EmU6hV<yv!4Z+BW2lrNQkOFDXurr_D?ORwE`y}|o7
z2QqHSNrQ*3^{P_zG%2U;O44dqI(@q?EmsE~<)T!nS8m8{Y*Hz0Qk{A%4{XbR_U>Ev
zaS-(lx8gOoa$okPyWK-vF!MCJ)$psGYFU2LA0$GXsL+-uTCPr`(@r@C^;Ub(t~Pky
z@}S<b*VAUdQ?Iwn?Ez0Bh3nR;4N0lWOFqDAlD6+^x7$5dn)*mZEhSIe)o9h*bxTsI
zl+#{W{HWKm($S-NuJWe+w`Z+=+ix2`5?T4{_V0^V@`uFrZE|Oo?1}vkyJj)&tTKCN
z{)L1+H52wPb4dn`W~W={2YdBO(yU3!#I3$0OqsyPS0zr2sXkB`Ra%vblvGlk^cspv
zDYY7+E7aL<tcYLiv_x&mNxjvUpZ0gk8x$dxK~k?MjryYMxHj6By=niRYuecp`x|)}
zpZ)m*Td^sH?e%QIMkIi84Nsz6l}!$K>a;E`OFNYgJ88*U5(PoI(Qh`={F$bWq%08D
z{5Z8yzt%_wGDZof@F%%Rn)S3l=t%j~R%Ni$7pJKdDD}-E=b+k~#PMy}V+U^EvuRG8
zef(D=+{G1JwieZryOt6Ei*4Jd%bMDzF{<CJDl?dgy-=%HTOBsms}1_Lv$Rt7)l=0r
zxC73rBa<xmx@z}+lthY}YNK6M=JhM}X1Nk2ti(S}?7Bb#dJ+Yh0SoBG){2~Su%o3~
zsP^iuTD`A^?FyW)3qP>+;Yp1>2~e^5H`rR?5cVz3Ts)PD-I{&#{>36n$E7bn*cf*B
zuryV7)nzCRwTEO&G1^F5EuKt)+hbUKdaYYc`^{MVvI}}G8>=d4%be3Ht4b^NMoo3w
zYSxolIjPi@NNLaN*_cdCDO^+RDcn1qu86Owj!M1N9^c=V?D(PW3u@QL4(-hzJ(Sm(
zHGkQ+chhGo!#KQq-{OU2Wi>4dyyC%T?>*EWvLBndmsnHvTBACs^vZ()S6uF<>g_02
zdJ?Hxquh~#^(}SFHj0>{M1v@l73YKarCn*h&y*|83g6%EcB<W)l(NjDx<!el$6e<A
zI-QP>)!X6bJMD?X+xo(B!m#?ba~G3mmlOZ(Ew7cOYneuSqc`*tXSnyF8~B3OiT3EZ
zTNVyv7j|zsFq>E8X+@E_wX>viPma|DZcw}?!&#m!F5G{mR}pj>a@SS^J@Kq8q0#7B
zhiYHCn%2`A>*jw3D#C6@!B^)$)xn;Av+em?eSnC3P0$uMQh~DFZYT@=t$nZ}+LQ-1
zA-*rgkB<Pp#GrDc)|}Mx)!F;*o|c_moY;N)L~Y*ey%fuJ@Twn+MM{39l%rMuvx`(q
z6od9kyC%|e0&<*Mvn8-Mnn|-;tqO)we=7BBwOYN)NAO?O_P}-rXVtp!y-v9!sTZG^
z)gbM++6~6ZS~>ElqT2_B)+og4QeCM}Re97`qNM={)U!{0b2x-8Up0HTy)((`>hgt^
z^Dvx?r_(9x+OS*zoWdn;J$eJ*!FxpR8XoiBtJ+t7$>?=k7VgPDc=*=g)lE#~vM3e6
zhT<E%qZSp1YUP?O<{m}AX3~`hRcbwu5g*j(cX(4EX|*FI1U9v*N=C_3nhY3QtDPuh
zeTh03912)~F721*3oLM_Za>MtpziUc>b~rCKa_)N?b#bYefGlnm5a+~(~HS9%q(*K
zu(KoA{;&lruWiXgS6?#Ub|WiRu_7`NF-96K17;OvIdKCf+(|0xAK4@zsb6cix#TvG
zBacSy4hu@9Kn-YVqX!gCyFd$IWkYCDGdEh5&Oq9v?rd}p$Rg5;1gR%JxB2%}0@q8r
zjc#Ynoz1P;Q>*9CEw5f&IeqTbwTx}NH|N%D!-v0;JG47!*j;LA_!TUmQEsK6xq+0o
z90+^V)b7*&?@L1})n230hr8CGI8q7)IH*#LZ+82_Z-s42c42!JpbB)_qAG3<GTfvs
z<4pp4Nt@jsET#@v8q^x~3EW(swUeh-pPd+&U^VZ<#<~371Dk(nI)-1vrUdmHu_@MK
z|3t~vQXn_@>w%}w5!V|%$f}gTnU*0DVmi0OSyjSmySiF$cdIs`d|3`tQ^us~G9^)0
zQZA_(G+MHMYcCx<5HY?Z3d_24*su&n>T`9yHAnx-*_%Cc{?zGSaz><FJ$>rj+4S7S
z<#1;K;$F+dCi}AXWq#XNc%#B?Yc<?WU=}t0r_u;$Sm^94Z{<(HCZsiG9@wH>?s8mS
zOh6IkT0;cj|9rC7OQEYBwN|Y<D1$_V3rJ+US%De1I=usuF{`hx0?YOXm=dLCUzyf!
z2Tc6(*(Er4>CBnat4}WX&L?Nm)t;@owxAPJym~mTe0ksXmE6JYRw5L3D(JJOY_nex
zB?Ip4fiY{<ev0|&OYQ17pzw=82Ru!?R*{#-oBd9++-_TKiAn^5U{zvU2TlO%OqK2Z
zg98x-^&|mTJawB5uw%gTGWK$RTzqeNY<>yOrYom=%d4rxbDCP%WDzGu`S6W=#aGx8
z%c^5mqm(EsV+XA!iz?R!gL=OStw0qD8DeNuB!G-2Afp+zKI2Rp!7nDzfTY&95COF{
zB{pb__CTnx(E+h7Fhc7915|NWK>`iTT$F0QEd@qSu#5TSJKudO?Oj}6Nmnl}uU=S5
zlm7LMaBlgo@)ci6+hal)ILL<EY_-z1TC~|!y+Rdi-FmQ!f&gm->%jgSh*-fQ!4t$j
z9bje4fFO7YJXbNSx(IGlDaa!P8qFyjRCkw^QvGf@0#T~=Qm!Zl5kK8YMZ5K@XD#Ra
zg^Ord-m#Zl>^-^MJ$<fkKVN?ZkKgdud?i=0Q?U!d)ZhmHNh<PTg<`t{3a{FMeaT7#
ztlzgenO0hpopmbsBtfMj?G<-Wu5h%-vn&0aH3VYyDs@$NI7U>#!G1GQZ*)W;I8&|K
z?6ulp0{JwWYEo9d=xTTWWODl44Xxh`ZsZ%jl1nG|f{!-T87gXdaYMFJQA2c_s)3g5
zOfW!p1RREx!9ZH#3b>@LT2P@iJMg-WwGbNQEakq+ya#J-HQErb0j8jq9Bf)ylumP?
za;vquy#ZPedr=46jglY9an!Ak&ffXO^B0!Sq|c<{^IMbC*Q&>Gs!#0LKUckO_Hll%
zp8f2erE6p~(C{0{Xu93L9m~C8*%1NNvSg!c9fC%vSk7+1U)TXgmMYhAe^E<-W8@}P
zybDo*j2A0qpEr>bY6l{Pt_0d609&-NW$gnE>VpB=k7sP+{%fk0R!`jSx5m8KmipY9
zz3qayyK?%%+H!4@`r*@`+#RI;(ltNqlcVQ8UAiYK{d=xnR&;Kt)c5n%64-h<np9XB
z4|)!wJwSVvfua=PBVV?R(q$P2@*Y=@O(AI^(nts5L&b&zMoJL@s!i^!gF7bD7^KZX
z<=_CdD*uxoN*o&kHwew{ulIS!NvVJN?f1U6^rt1im35NhVtV$%ndIV{R3)hHH3nn;
z&DusdAlEL0Oyv*n+mQo&0rnkV!b}C`H4!yzN=T($TPt#U1y;F*-<8>?UE882agayU
zn{s_fe>KPsf5BcTDeOa47c4qJEvglW`k<~@1vObOdl#i4j)YhwB4wSJL8MH2+tsy}
zPC|%(B^$`z^4VkA$;11$;O#8O<d4<$KT_;?b?=_dtf)Mx>a$CScZ8UsKsncLd?E(<
zwZqG?5}oXhBQLlOARQPG`tC>WnxpxuYwJ~f*+le_{H49wZyY%^td&7*K`&PTfikZ|
z^h@w^6}}wc*&nDMB9!8zlUj>Vpr($B7s2pd9;plVmdkQ!DzA<_gMtYo*zH(8WGz_%
zkOUUcpiEHkTQ69!l>{)=iAf3zx_?(^nyI@O`)v{v<8iOs&CEMFCzk!_{d;b~`&d(d
zdgY9jO<!G`BG6|3fos{`9S>|<v%R<PycMr;=UrnK6}u5jK1-PX<p+)rp^K1F&^)0L
zO9}up5J;e8r&1?PfHuk8q+oU)&bwWKZ&<;O)WU*vIKV0%JXlXadbQkZ^*x+U5NE12
z>kH>p%?_HN0x<2MBI`p@VM={7=&s0m@86aE`}=p(5#^X#<~~Z5HSjFE;aed{u+>RO
zh<w6XD0nzgzX3N;1_9%FQTPLL8F>-!ta_5G+I&^nd#_v<vsh23+#3*X^hA9-L~T_^
z?+A@*_zD!hg(n7i^g=&?DDSp`Y|Vym9)0M~mW~b|@Al58C!cAnf2i1!Q)7?fk<UAg
z{3Q=XZhHO<+%)uVbWxjqy!iACJ4N(0Pz(#y0e+G!Rgi0G`N?)XA$cN^h4<}oafC9h
z3rH1N=-;H=&}1G|E||&@-4%Wdp<N*!!17xjG-yL{m$VTn0NF?b_!<@g(=OA}sN1Wt
z6)wN&!GB$<JSDe2dFsshZgM6Ua#cGg8siOq<ni2gPsSx-i1}NU(dYLp?7sDl;eeY6
z{db<(pY>m`YoXE1KAGN={mH2<IrZN-(P+Zvf8hm>+*b34!eM;!vv+5E9zNI;#Pb*8
ziznY(ToSJ=r{|tIy>h;&=FgEKZgR;}m(HDzkNOEVbMa-X{qvNAZ>&~M_@C?*4?l8u
zt}<A<xVpUl4~5um<>43HQa|B7vxASkKKppPnf<^QcV+K+(bnw$Xdle}*<ZUSdqt-|
zggSHPc+8IM5#EuiitrY~R)8SVf^a~Rdg&uQjU+&>8IH{}Md=c2%H+GeI6SQm`B6uT
zWeHNU?$2n+D5KhCSqFV1@85;m${c8<)Kw^<BB%Q4_Rj1_9=$VLee~|^_uCKp^IgL_
z)_um9Lbuc+2<dss-G~|}R)7oi335e_(+ReTvIlQNAj+Q(I>FwEL=_2RswS4$keBx5
z*n!GaF&wfWavPhB+K|d3k(~=(>fY8O%BNcELHi{#6sSovN3VXSy(Rk#U$txWH$PH(
zz*^p#{o}7%%wF{m_GX{{sxlSXo)`X&p=8UdRbl!q<zcxW+fvB`fW)O(W1J(XvReyL
zmRy4kOHmV&7+hBmjj0f=tC@lhuj3F^0^mqF7$UIU;RYBxuYqK-6Zn6hkdz_MS|lLC
zL-tSp@M!ka?XB4xUv&H3VU)9gnu@#`Dyw0-dIouL@~I*!#LM#w-bJPI99>b2dzE0@
zoHd##g<Xe0k0^!sMiw~$ZFO2)a<F6Up&P82ve+hfaYC&?w_<gP{S<(}W*WHq5v(p>
zfN`pTDlp8%O)cqqF6C(ilqgES;n=oQ$;wIK{n^v2rw4D#zUn7V3?H9)DUWHf7izQC
z!aMLNp*5AD_%cpWtSk>W%sw8nQm>P+iWLKq8W4=x3IVDD79Z{c9=8r}XIM0f1bZZ_
zxIl`q=0jx#MUOBu6bbR9aQ_1ym+SSAD@@FDY4!4$@#i0Va8G-7{X=<lqMd!+6Zd6L
zKeiYNP5ia=Pxob?eeCr^PqqnbCaa+Hsbdrgmn971LPu&9g-PtGpi>8l?MEpK(V!o#
z59I7J%?>poyjlTBZh%`+L53EnL+*p7YeFK^iXBd<+YF6kFf$77a)W4~XKR;gmp}gE
zcP#9?n4IfgI`h=($usAZ{_?rE^#qD@gVU$7H-E1z`>zuvo?gA$HTeS>J$GN}o?(xy
z`b;lb4cFE<Q5(C%fdYN`(gm;8J+{KDok}k*Ur2gS3q{M}jlF4Q)?D85+mf?qyyhz=
z-;xKUXF|K3yF<=Azj|Fm)o%=2uxJ8nP=&Iw*Qw##Y{=jS%A!N9$GZhCV}By6X=({U
zx^@wy3nF1#F&rYaN||zsV8V*ih9p9-;#%U%SUF0XLmy=>J}oV2_*Y;<%Bc43*?<1#
zM=l?E$?nn%BKTNAA#@yRi|{jR85HVY=<V4PPJHI#xHc4!yYqMQShW_W$`Pgx{;A%R
z$(g6~1zigh5n;}ztE;i1!FPIhD(2+@Xy)b7j-}Fl!%igVk(Ub9RAq{6swG-wftl?y
z^mZ={yvhrJyw!_HDbB$~&@dh$)Ico@%GV>O1P9q#4V(j;<RggM0xRReRpFvWpYR`_
zR}UdA31vOWvy+D&A1}dJ$36btn=RJP*()b2H5|X3FZlXe<?-`K@$D;V5L;ta_te6S
z-@X{j$HXq3Sx*THOPyS>lAK!|oL@P++1D>#Jh|Cp8v4lTWo2(77tfy-{xJVh8=qhA
z^z!L*gY&t~SI7GxeKt=9Vq=6PYia4!N+>=qomn1CzAhIgF6B?xcb+?y_Lm2zA>8@X
zAFic5#Rd76-o!4ROja+Z%V(3=qEkzgf9N_UwUVAnpPjO|`iWZpOY_fSKka~LHcNCS
zySblUNYC}tb3H`uCja`%rE|3Fo4;}K^x4h6dG%a!VfD%Lkwv|B{$^%2!20ieCOLDu
zugu=$-+605jBCH(efO3Q?ps=d*j~K&w&k#fWIfS~4Yg-<`BzH2vh0}y4@HKzeD3_k
z(}UCb=ZOkWRF>ZU_N6x}xlWYxKhZY7=b62u@7lR=`yEr)k3P8{ef*vaw+}lI1R_n`
zcsme6ahBLOcsHe?gt^>+{?mcN{ppD`1kmE4L6CHSX~DZf`YiuYcgW*ZmohW?4RsMc
zShH+X!ad~RLbyDgFQbF1SF4e-ht9uOMx-1&9*^?mRPI_7mBrF-wnz7G`hmDUoLVD)
zcaS{I?|Xnnm&Md`nrycyJJ+{b?)CCrzI^t4FFfDcN7e&Cv=^n=B0N)_$A&o&xi><|
zgKkp`l28)F3f*!rLccEd9p5C(ORAKA&}tAFeq2{Vn>eSbzOej!y@InryLGQG7g4?2
zmpMd(lJ)=`RSR9kCw|Wxjvp#+{n-nF?uW6BD{w!yuBIsc;;!s>|Muek!Xu^gmx%}4
z|IUHpE+amU<6`k)*1CSD^4=PNA*m1AimD!zhSWOg)ksW%afFI$zYtz%&1fkIDNcYn
z<YU<J4w6TKOmq&?=eXT3gHp1=q9_I${rh=mq!A3F3Z&@3OM5+Q2Et0n%R?MlO+$H+
z7au1#+{87U_kqn<C!S>Xq2JoK`HhD=S-){bGu)OKo{q*3BZg2Fhpe<AE3GN)slV}9
zB(g~epd*#5uzsYp%)Sm!&?<%UYNBQ3u>dJx0g5cj%;bJ;W5D5*qyS1UK#|}v4-FeV
z(oiNr$rT&o1yi?iy}eL`@M4kjYsWXcf0#e~X**sjy!e#+ifiX`98p?=+sTy-YLq76
zpaM~%`qn!~I@zrQ?9f#7t8i`2Lf|;t9aRmP>{CiK;oY7lR=Xa8Hpw|Dq7+AA)xnaf
z2hlhRn8+Iy=~1MJ+pszE3UtM~LzvpZ*IR_bA<TauUkMJOoiFEH_{@Ftk;hk0pF4j}
zRyy_B@Cg`2*u%6>xOUz%?=r?qJs%C$&CD)=>DfMj+KSo*1}g2Az5t8L76O{78BPvV
z`^K_lT*i**r(dQ|B|C*$M27=mw<Zm%95Q^RkqsF#$2z4d;w-e=Tu#4Q?fE8!9jRlY
z$Wji~?XPb*_He!~V+7-ROI#$8(-%*cw@8hq-1oXu9WU~fIdA^nX3r)*bPZQboZJCI
z=?xqz4r!x%O_7OLVP~pJB{_|pR*rgKjavyNT~&P<wHjQ4%2>$=e1`Kxu36>B73@gx
zHlaC4!b@UV3n))+PD(G~L}K&_3{bk<U%ww|(HZH`rDSyQFP4^$&E<gCTh6`tnyjUa
z>pPdd4(GA3ShNXh7CnUdXUEC^RTlJrCfVE}8qYitt+tOWR2unqXl{~No<DOY!qF7?
z7h7mtJ}oUpk~#Y6PnY)XFEY1Ha?H{Bmy}+RJ@(ADZ0j@IVW4k$dFjFIh0h#@f4uRT
zgRh;+_^y*J&hNPKMttk}m8aKotP|xtk=nboR7k2YZRbv1e9~_Q5S^%uKKd)AyAKwr
zxm&t;etA-vx*{^GN>=)f{a=~vOBO+uDG?HBwXzZ?ci;esZ6ruD!Ur5jmZ58ba}E8g
zfD>&wRgM?VOwKJRL)Rj?03QfIB(r#O#i-(5Va}WM;k$}?N=ZdmGzw~+h^_%BXs$OK
zCkv~b)7fOxbYgd5ano0fGl|@Rl0%+e$t|XP{@JmuHej4HaTRpe;h4B6g)GQfeHQ3(
znNC^6rF?}XM{!8gNrIwP5bBx-M#@E{BTj>Q%9fU6iV_3@D)01|&r}rIYHG6gx-=xV
zw0H%I*X{zg&YPDkR}=Je^ynS=&MEFA`@LVN+`ZY2kqU->b$H|V<`Fb3JV6%*0QM&<
zPW95lHMJ6yL!Yltj<7=qGGQbi4*#O^O5-8c`DI?L-q57n0jq;LUBKTQB@L4og%p@#
z26BUGz<%jv^ED015!isvx8O~)(vKhAF}{`amsWatrImg07s``IyY}M5&lI<qef~Au
zvhvIJ3@eS?Q`3W;Sv{>#W$1{QagDgicAa^$RpJ&wrV#=*=1i1V4h3_$B@NL10e{kI
zM7knO=^unf32%*lyXTpE6JgnW5o7>F4;E?Cap{!dd%>@XE`|<R7ps|iv{BGE^grt<
zsrZLfA|%xC%j~)CxP+K0v9ITUi;Q9Z1Cx;U*bR8t+43P@zX|L=I{!pz&*9uNudQNl
zqm#@Y|A9S2(TWn6s=o?}R&<qn!6rq=PqaeS37B~W@?^UJmL!dANR>b;R&hX}fppg(
z0PL+pf|0}MCi-z@8?AxWPBiQ^u*lZ5=lf%%0WnwfJR&#b-XQ&7Jz6eICtr-!^evav
z%44DbHB#+^`4VmNnaLWyX8nRqQIE~dYV5B!;sphmq=AQ|*?nqgA#tY~rQ`-LQAhQH
z+ifM9jV%k^W0|}FyP3LItJcwSp*~exp-C(FE)+6WkMo60g>=KRwF$X;L_(-$Nj&o1
zza@d_>ZkU%K0Q)aeeBrL;=U$e&Gihe2=o_cE}tw>=(k7z;;T!y9W--bY(d4hPa9W6
zU%xkhKc6r$X^xx<OHBaICb&=bqOAvRf%TwnmcH|W(-ZXb%Ut^WUyk1ezPbh$GZlIR
z#aM)5oTl6x<5Ho(4)|iYwDi^$J|+i|mI?dLp6-n!?`%_`WD9~2$uOI5;kJ2t+T!S%
ziN0)14Q5rkE8*36GU$R&>)N|C|5mjRnjsOK0u8^I+6p-~*^aEO@i13|5jFV3OM)dv
zREx3=5)NE$t<R3*QJRKR-8<eH@i^8V^i-X_bN>AzEIv3+(Z&IDoTB;MMlW%4)=Nx0
z$mG#l@c<QboFezgk%QfPU!I+vd|R?|Du1Wa@`&5{m*?5p=<rqxtw1%}MAvpGNT?|^
zuto2=7B3wn_6qbSW*-o^%MJt?@fKPW{1I@QazY1S!%hhwP6@AFjwV3iiu0f-kb<CL
zC{Q#fip$Dh`cIwGD6u4|`)ngB_=nc5d2RU=oSR`fyXG#P?2-HP*XLKVNC+pZmHXTO
zA6F9lPgoMI6!3tA*aU}SnS|;Ff=Pppm5W}clvtvwrUQ~xRrU}8IT;0j9%$YJmrNO;
z!oafeOf+KD#GVZx9C;FI47h_DLv_sA>+g$MEb2SGa@x|q?p1eWkH2)+PJ4KE`N~-`
z+?_rC@;i;ixg$IO(pyU9(R-dR9f;t*V-?7gtgIw&3p4XkzGV04*OKVYdG%dGk4?Wn
zseKy`MW2S#;s85RC+)IYIFUGAL|wpDwUmsZqhHdP15(Sb2!!EaH87n}JrGIg(9#P4
zHfl#}p&d)-kAFvesqN81DzqwWrB0k!rL}HQm2@ZfwI_SqOLvv3S^4D$C$~Y-QOg$p
z&b~ZJ`P55SG(^h$D1!vU=piE)%N1f0En;|bC#)y}P3V*-2fe1kZqvz{mO?N~d{4-d
zG`$D407F2UXp9==dUP07YP?0Lob^cw7BQ27>j?gt!d7n<IbhqYpW@g4@oVnLPQK!n
zt!SeVt7Knz&0c>$l%0I}7qcf`sagN{(&ff0UtG$*|7#vDl`mg>)wWXhzr1GW<xhX@
zca+@Xnb$n1mhzuYsg>Wa_i%Q;treVIG2!TsU-POVU07MB$Pl<ZIiGItP?WG1M50{T
z8g@;mfFcr*g`IgQZ9S|2h46IhU)2DjoxmNfCkKYuDqcNO?W2-ZJ}#6kfz9^&Ayo;R
zgmcNbsH?*2TG{rm-*Wk;*Z$5;qaXi`(%#V@{iD)icIX?nkACoNsJJ7utZ89kNYmU8
zt)^$mKp0)ioki?ghd$7#{sox`#cE$#OBK+@;}o#5aUjIHl6_q^Oe~s4(CS2Sm>}Lq
zo2_C&Y7=ThXetIA=i}RKQBnbK*_K*c@!x=~V1iNd=8ynGgo2RZ{PlO0jxUBY>YX`#
z@+_@N9*DAc{qUjD4}T=Ty<2ZvfBA`juyohir~9W@g1GRw1+mxOT3Q-5f_#$mMjnL_
z1S~|h4kn;Bj<G~IY|YKA$KH^}`ZYFwLK{H&NzGQ3!jyqvu=Sv_qwBo~BJG)Z6g_Sn
zZYn;-xED$;S{)BdKMi*cNbWQ1T;ebc@M@;^Dts)YAgZr9FA*<RBSpx05wW_E-E8_5
z`8QPOny2ZRbb(cX|G<>6qq7)f(lbG!LEAxJL`8)pfCdW60;<r!y6mThmt#9pJNg^{
zN%_a$VYY=^-5Jp@t|>9H{Z33T61Ys3N%fLaG^qhY=#h+)M;DImSi|dj=g*$SetK>v
zHoQ3c#ifO%?B1W>7J`pFF0LD&X9LGZv)b+UR*F|u8QV==X|?7o{>xC1W~hS_0x=B{
zL`Lq73-g|?5TywU1NKWT!X3eZqq$2qUeONWt5t#w+OPJscG3>nf@W12o}!+?frNbM
zo=rf<;?ZGiUiasA0X-`3-+j;8y-s11`DJm{`w#5Q>(d;(952R^>_b1fXBd$>8iiY-
z1mlZC$*udqL=W`^RNEjdl0QWUmnaR2feE3-g%|dDNp0$|UCu>1MZl65=tx(?V5kMO
z7ITKF65dVGl~FB(OjT&Wa;Q%zrmER5KX>%<m;TI?H;>-=e%tAluirjw7QfoFm=jb8
z6;ayqKDwbOfMxF%O!dya6D6R)&6X*n))|w@I-UVgU2_lKSS=jmyohfMTQJ^CSm94N
zh3KiWtH25bA~tBbx8HYge?h>*Lt@I183mj|rBlfNe`$5gBPa93`b}?IoAebU2VzRu
z+*G!Z5AWZ-;p%C*aQ5n@LXEgCdJW93NZH2!%vxhIr+MUPs7y9oGSS{%<BF9e=EX&a
zaq%7NR$fO$l@T&SE{EF>_DK)9`BPdMHL9Rqs79@72ywcwqK-Y;!tI!Wqm{O6%nQC<
ztk&&`qblc;ISCAA#_}-%+64WcrX~RWp-N><SCVsL<Tm>O;0)YRfTN>dTUa=fS>P8;
zmTc|LbDKCizrLg7mW5r}FTHW=-uacvuWy|gz2_Fh<%QjghKK}2w|>tdppF?EKnOe~
z%!SKQ{DRG}PW&o8kvOgvrp*yayEV}w@*Y21oH44(a5T_MC|BfNQa88O1H(y`?d6cS
zFd5zYdPI5Q@(y9uDn_8OwpOE%olP6l<PmOutCT9)Tb{c6?#ar`T-_Rd@SCJ?F(2sF
zOLyjj=3+$E{5?12G^wE#5Ps<yHrBS$Afx7mUkm4+H|`Y#MU3MqHGA3_Y#PL_c`4C$
z2+szAW1y77CjP)4Xn&;qcC*GhXrWdkB!g5|{?y)~1t~Iy5UT6AGY~E&RQ=1<TRLku
zF}BI#mI;Dq%w83oTWtQW9ah#sdGSqDZyxx*@dKZ^#wJ{ACf_ww0L?scE&{z6I(j-o
zrf9gEyrAY5+!^^G6wnMfs%ELJq`;<Ns_rFkN>Epd%zEQFy_g6h=vXUol1FXgny1Yn
znSNK1Ue+0Q(p}VHsga9HU4AQWNzA|S`eP@eHat01Q5QECI;7gHb;nE1c;ve`TpqSy
zz~ksYEH3OA=Kf&au0?*<i`&t$j%nA3NGU`qFTGKEU_RJ1F^#7U2-ZWz1kfKkPh{ue
z9?d9|H;Ht9vNVK~4Edl6Ci=P~8b}rGakD;RY+}E>UH3d@4x0y#mA;r9S1z5566?V2
zN7tTc{`c)~%&~>p7f0{=NNL~b>l&QD$C_U^jLYVx%vf&PT5adDY{FZWH?=a!RP+x5
zQKfSP?wV-ivEWpNg*ZT=VB#DH4~}tF#5Mj%a>Oo8`htst4`Bq_NU&%8zl<!p42)Kb
z8JA?)fgj^}%Gq~+%W@d58++m<rG2HNqfdNC>Hho&`+F@O#I1Q%Io!m%Vn0!#U0-S2
z$+!)IQ`m&&5(Wpb&-<Gt<~nu(n(mIe-bfjnOh(5>;chWd4$L6_61>9px=q9~{65HI
z$SHXyKy-i~-KFFTQV(IS=}H_1ss=?m{_$UUnNseRAK#Nb@;$|JdtuM$Cr*{_DQ>~d
z?Aq)Wu=NT}bv&G1SrDUsOp4;_^e5Tx{;vdp<^X03VAD+yQhB%wB$g#1bQP!#cjfoS
z93SYkp3#_$)})H$jsl?(PxJyMjoqpz_s5Z7Iw>IgK;3-nJd$snsPBtC6D9xrOrPSl
z*fn?MYU=#TcyaXHD`4~m?=3g?(gd&GL_0I@H**bSDD^l*4g?i%+=$K@U_0=mqcWnw
zBs43VC@TEXJt$gr*=b?I(^Koo-)kn~5FkUF%+@dfE%cMR>Y%Ywq(}~HV90@#-m(U=
zuOpPN)&nZfo%qe{hu(ZN`@!$aA6@pjHv{5l6{n$v1=tX@<>pkSQ715F!@vloQ>y|P
z52<w}dY0j3ZBCoIK)(T{9SMVfA0&z-5CUl$OeR8V;zo(F<xh%2jy=Xon%~zCgnhe7
zpDYg+Z}fq04Gb*8clI;M{^(Gtj6U@(#7Fk^FvLXp!-$u8=Gh-EV~}6i5#*7kc0rzK
zM1tZsbdxdoDT<(;fU9W-)<75-Go+xn_PMCVV@XKKELG)AQr<w8l0Z-luC)y)aPF-D
zn!-omlr(Gb<5V<iM32!_LPMa6E#imYerTe&pLNF*89vkcp5Bh(+<-L+jtW$*5M7cm
zbvu$`Cwli}3i5q6Y?OwqfXFBB-wiJi#drq~N8zEoDXTUkiIomD{7CLty(_Ok1ZmZ`
zr)U**v7)Bn@!Nf4v{-Xk3fykLm;{k$PPsi(c#SuSDAJg{lj;fiXKaxnSu@?(<l6l8
z+2`WNG9bMx;j&~(enP*GC?pOSM^pwX7{namF*Odtk;hTi!d5&mWvo0S2Fhw4@gHS7
zO^>2YOD&g$Q$LKBECXESUW5lKDo9opdI4#nM6X-Fypf3C&3>tOf2o#z+_Wghl-=3i
zCc0PV$^-v=nItr(H8X*#Y!#~CjS<YsF=_|?#dg!Lk3y2El1vjF+l{=vcJ+p>faPQ)
z5*-Mzt}x<lyA_bxs8>6%5>%^*sLvXBx6@0cy5<lmI!!499;{__cb+6o?mb=Tt=6Fe
zzx<BrH{SW)eM6WjAWA!et^g?$%ugRE<U)jF5JAIA$K)GiGKEY`OxBkJXfm<NNKGqg
z+fY`=kkIJ1(Fjo{iiP<wNLp7d1f+PWtR%E`N>YOiG(YH=uysso0u@@{BLz520KGP}
zX)f2UW{dyVo>=^yIgC7gWp(tH?-w>?RY(=o9A|ET0`a&GSS31Qr3&4%ePM;sfe?J1
z_@FM1piTlNYD25QZ1i8&JEoFp@Kh-d)L!Za)83$qd_t59`M4-?9eZe#NL0;Hu_2Ni
zZ*wa<i(4tIzd*W2JN{m2Hz<wCFHXIizgdmx%%e{(E^HZ2-`FN$oZeXHRy5P`qY6&R
zuL7Oix@8n5Jv<OIFN5q1^KJmUdOl1zk%vhHZElIPIhcwHNiu}oSWOBZIR__iPF1~s
zUtm;$CMcU@5T1D*vQVP|C0Y3C0#N*yt2?t_@9()gdVXeib@T!0s^~<2(BkvQG_Y*V
zE<C>@`>ynXNz2eLrQ3@?J{bS`{F8ex-#d7qgi>T4U`ue9#|3mjrO+%geMpCf3Zs9N
zJz7)*w3wr9ss%_VW-g;012lu>w-wc>0ELeq%O#P9g0%U8aAA7FqB7u}!MNZ&<6|{d
z5pdh^pv{k;`kJfX&x0DB?zp+QIU{&4Jh^r^FFtq6R*xxvD;lEwJ-he(oolas{>i^F
z4DeFRT@*9A@v7uc>K5v{KshL#V!9eVzS{++1sW<ah@g~;dLE?CF$~+p<mfu#b)_qy
zDpScisA!=*R6+*+gfEk<Xk6wa03*B$N)_y7P-N*1$Ftu)wU~V{-F7Iq$f8?o(<k>}
zTvbdQUc227o<BHwc;$<CMrKxg!AxC4(h-<v1K<}j0b$aZE89Y62Gt;sVht)C%3LXn
zL=HE>IUDN)gB)mMH{}n2S_4GcZw)#;6&sbE^q3f=7vQN*K^^Z&`);6#Cn^t!z1jzh
z@Hvy=p1-upH>bDXz-_u}!)@-Jd32vlCl;Fh<1_CZf;`D1Ro!BxsH*#<3>joVJb)ns
z5-t@9T%yVu)3Er94n8Pc{7@Q1$UP?n+i$Tw+ey6SVsZ_lR#r_#WECv77LyCPR|p;1
zE-^9$Ko!_-PGajWCU)nwEY;guujX?bQP7&RF<^rUkfNJ;ososbgb8Cj!fv39Dl08&
z+L?qyog6VjQJUq$${bz+<!pqJU&epxBn|2e+^cZIYDlaRae_vty;G48A+Mt;M6uz1
zqKBz4!eWE$y7nE!9?E+R3Cprs^PAdPd$XG^jD{RKbq+Q(Dq?#)=D?zDsB2Wo2JWb;
zmCrq0eEIP8ff_*?DKcxbj;YTvYfdYdTQ=`0!hw!G{h7Q*h{$<&31L9-+PPIZ!Mmz>
zqHo4CHuGr|jil1eUD*%3<(kjM+p&ulpMQDwJ8$VuHq`a}$46J58LEWg%ML{#T9zqC
zg|9W#06w$MD0G75qsugINs3_@wCxhl4YeYm#RO1FO3<`IR6<B_7!%Mj$Up@>PhM6>
zn=H@svR+;hixSiJNC!w?6&JmU<vnz*XI8#A|GfUf#gpt%Wv|>qRheO8@)+0(E=%F4
zG?Cbti4XG#9|%G9FB&fu(=T<}(Ab!cq7HzG1@09CFeQBvc_kxe_C#wYA&tCW_{QwQ
zO{3Yj?^)(S!^4DozV7JdSH0s8N?XSg(9wT<Vd>E5`)(;M?n<Dh=a#3Xp{>y;K2ka`
z+Hvc`?L({y@3yp5T=mwXt0-C(X6b&F2Xl|PSo+Mwoap6MR7$gv*eZKrNsqSL%YwTR
zv?Y<IvPYvJG*^rz)6lSK5N?d$0mZAYMdSJl0?hPegG?f%@g49X%KC0h4cDSZ5yDCK
zKv~~>^zsYe`RdYkzwG$buO0p6PnrYq?LW0E`?+`h8;3&#<@emTzNBQ#<2(0ezx}OS
zZ)(fFfB##L4x=~F$g@PFp-8ITPIUv3!6<~nO*f?uC255T@0Qvc(=C`<h%07QY(~QX
zwXUBem5Z72vRlSuYDi@19%L6RN$!H81;hhvlnUfR4V9IwR~;Twp3DFIFP^z&>$o2%
zyZtX6%DV5|xofINC=Xg%Xo6WCeaF3}?Ve9CcI$YPG)9<#2FB0|Qx<`Vo&!?D071HN
zK^5ET*GHt)=?eRlU(53~IjB}WMtTD=mXqd+6;LE^krY8)@ykR=CcNpkR$O~V^ljVy
zFMv^AtH9$sM?d!84OXxJl^vu1_gLxS?80BYB|G<*|Hb7O{?%u1%6{^@@5t(}*mwEg
zefPziv%|07yMPIK^1X-Rp#ab-oxMY&j&z_7mY*VFdq=!HYh*E~6kTNwJOZDBT3enx
zNLcBU2-7TxNdZgAo=jL9n2L+di-gA*9KDRXivi0LzIKw&jS+l#M9sp{2CR1>t=^|E
zuocw=SW0nZh!%v13u!S232;64aF@UOy;~NtZybH;0jI^}Jr3i_E*Im^rV@Dr-|k&G
zHoAUk;2+WHQYfz>rdR13n*m?fhmi)ck#EW3YsZ67CXy3i%DS3pd<D*skRXtn0%{re
zxj)2g=DP%^kWkmsyqxIdx}R+H%-w-!57&POCop4q`NSO4^5U2d2s<PunrvYRkS7B`
z2tPT#7zhr5RdEEWt57hIfjp(t?(u@kBMGmO#z-mvU?^II7KOUx9E0xZ)(*rNe`$u=
zFa8-+0l!W;juC{)94&zCd4*N+fbwOTeLl?)U);0lI_95g7E%oN{j#f0k(uCDN3PKU
zD^V;2)uX@l>C!`^1AnTNE2U{9>e;tEb8xu6ee-Ia8)UdzBMpK<@bM4!v?Q{v)Rfof
zV`5CS=9u`u26j-Ohf3=0q82p8lf2TVRI3IxsO|<82l54sH8e}+q9!Nc)Dsc|Y<%c8
zB`Ev0VMe7_myQ7u!nDVR6=t*i<azdWJv(2z*5@WhAE$QQWEx0*W{3agmORI=t=rg|
zt<POCp&4Rfb0T8K5>?#boPaf8nnph9000J|DfO>~hNYbvRcQ|3p9%C9;-T@|Hdjdi
z5{-{={70a+)QMVpRJ+YMR|0mA?3618ET9^(e356MCHMv?Dk+w_jjofCN3@+RMzQyL
zmsVC{Mq}Q?R}4AUIelpK+OIDyUiZq;$G)eulyAP-p-1yml8ePK5P7_&`Qtb_`<Y@u
z@Z`$L>Th=C{FGdu8Cq*&0j}}&Q`2E@<lmT{ZF&RO50|es_VNb4VEGzT9&g~|L!X};
zYj^{nTHZK`?}k3Lafsc}6t*w#qvO$SH}avmp<~k@xsawSFVTlP`g2<rc7*CRd-)yv
zhB2Z=LSQ;O@2y&Oc92vYY8^ZQ*|&6*<8e-sp{d{nV=9pUn(Ih2qzV8urMj7H$|$09
z@?CXtv`U5OQSl`r>lg2c6+jNs=ooLo=>v<Mcfs}bBI8>gdz|$EcRe3<VDnGp-bst$
zE5~mar<|<2zL~gr-3=SwUf=Ga*t6M7?{F%X>1Po0!2bOqy56;s#-J=xFI-HSGgeT`
z7^6B1I5D6*ZI{R~x(A0Z<jQ#=)JzP+@&!AhPvD|FCM4qO@fe`W<HwX6v$jJZExbY$
zM25gUe*Ea=KmEOTmM*{b`@VN!^u>3Vc8s>)RoZp=rSIQgDmAh<ec++&6SwTmzW)RJ
zZX*87u6$tW2;@KC=efsPNzbIoYSDl#D=W0BqjR?{+@0<C;H|et9$?7gquHl!-<8!q
zxNGPHEa8L&c;<K{={p`uQA2p(7a`qr5eNK<y8(_+@o0$vU6EJ;sY8Gn;80}DpvO4#
zMy3z(2I0xZA>cLA71cK2nEO=;0SA<Osw#(ZP!~p5^3j)cSHoMJ8Uyd;6IxsR%pkCH
z?UdXy7j4hzspdbEef~S{&5nNOUJU57KD-{LRcRDrygfL8B16@nCQ*L-DKSSmEZt}X
z6o*=z1kC@4J&-C?w3^ICG1$l$N41W#0ssW@fHBz-fJjLN?FuW;kuF$CcSoJZo!AkN
zA9#8*zr)+QlY#!DkNs%r;oH~#TFtYToZ>Mu;9|4R9%UMH>6(I*?!icGxFXaHl@^>O
za1c0eYbpiE7md7vzAIXySzHaI%(OkD0|r`x9IWAfT;+!nD(i4@ZWLJ=jcBWLFWNg~
zOrUKRTo*l|#!?udEefSR`a-jG?2hgw^C4F9ksadUJ)?jBC#798FTVSgWD{r>RW6V(
z@IG7@`xkW$Af(%h!J^nZqhd^_hL))S5PmUBkK`^-`N{hN)yc^{18Q{PcnT68U_x|a
zdTwf05Vy+IueWue1AznCP@xa*7FGXeK6KZf$ROun-b!<H_#LI)*}Wg$c9XaB)}!oY
zAKw0;K@Q`}`AGPr8M$Kk)|`4D?flQBhmTJ#j1t^C`5b_J@0s^tan8TBm~asFP<`|t
z($Yh>gm$%={pg3^@S<6DWB#cN<3SCfo-1niVp>ib^CR-JC&NE^vl3#+yM1PLb>+0z
zI@yCics%>aPwpIA+B!iEahBc2b*s1Z|0uu_W{&C8yJ}j1G73V=;Yfaz%ov)OGG^E-
z3ks$%v<$Qx5;4yUD9@%+A~qQkP|zc_(d}-1<CHl1!PML8G*e-9x7xp#@BGM3rQvv5
zOySk@fibhYcrrs~W*4swnaMv^d}?O*x-pg>lb=9+T1$Cf_>VA#xx|Fj0;r9{bJA}D
zWxy~R2wI|JbH&6fyIre^ACF9Nb<DSnaysB9hmx4uM!*~1H*_fuI}9=oj1+1t)Ka+c
zYH|G1&e@--YO9WJ{n^rk>oaolpWh_FonvQt7>h{BF383q2=ZI{Eeb}X>sxji+#82U
zB^l@*eE>{GixDI>COs>x$fA(>G18d;FB}x9H3v;(=f=8+c^XKIp;Vw1Ku8=M0I{&A
z4HcsEs|BrmEW7J(9XKRb%s!5=D!#;8Hp<yc|JKo=|IRX)erfc|gA)9Dt`G7Uz0^Qe
zlLTV6j#qm=#gT|+#LOaR-ONP%v)C^I2en3K?^sw3{-KPf<%tPAPBDvfUmXV&6K2f!
zSN!xBwWw*O)|U_V(9Ty4*5+t-;_u#Z`QQER4=>!BtQ0*lqcgu)I&r&dc=Gqk@r8XF
zlifbQ1-`|L=u5;PMT0!1AvojcTqF@O2GkduY6nY!Q+pZ|8H9B(2nro`gpG$S2H^}u
z)I|@Bp?h+s4N%yuGC)f-B^Z1hC;KSn1i9$2t7JRhc{KZ$AO52)#o(9G6HicW7Zc=W
z&AoU(x0V_%c}|1?G#5}}v{<l1EIEuNcrOCX(AGI*6C$UyBx3;$iLvl4jqAFm^Ksv}
zF4U6@11$^Ba)ybO7HNY~_Zce<$5H~Bor^DaE{>3h=!{!8YdyR0tH*cro?6uk-oJDv
z)vNn#x{|y4_x=|o<@`JOO&Dfl=>N=)jbUOng)7)e+eT2W00Z%cUWnq2#fYUK90yZs
z9w1qE+)6a!0w7TM6s4Y=qelgX2*{Er;E{~0^ROXmTo|N0Xe4O|?ICtQJQxf}R-&ke
z<@M46`FZ9?zG>lL{u3c18yG(?Wgq{?yNgpdi}z>lfd%=&CI$os+LbCh$ry`Z!kpqB
zA4>ryF>;=kjSc6P5|MJs9O4Xt5Tu|tA>NQ_GxOw4b~1dInl|4$B)5TP>pa~TQ7wdK
z(Tl16RqO^^(GZ&qE8e-Wk#Y2{?<t+!?DemEacTcB6vGIqkgf=%N?>~l4kI7H*;_ao
zBC=jNTZ5~QF{E@NLVX)#>Usumo))MSuSHre9SAuMJEC^eyvKfI_n~YAOGy3+Z_Ge&
z-_m5_9$vK|6;AxbmdpS0qd&Lxa_^_QH{ERIk7rM8-F5k6A6qD8fB$29v+wxfN3zd-
z?C#Oe-M6r7Na!BTBXQIng3!~ZD(r)y35cV;+H|=-_J9M4Bd6#OVzvN38SP`H)kZ6@
z-zzJKqN4%t3|UJIcF-c@xPth>DN|%=Tp|o#AE)mR^c^59p({+~r+<1Wx<&ru&+IML
zF8}_|eE#Okcm3RtFDw~kG=@=(P@T^uyp-+uh26uoi;8Pzj3^c{M6gs_o;>}!EXz<H
z5eNDl*bWT^ULll}alg9Btu7uRdVjcoCrTr6f>w(u?2vP(3{s7m78fV-(!cRw_r&Zt
z(?Y03u`5<9rl-asUgB7`Ll@1@{-3vGpZoc3+mE}Q^n&*Kd`r9|`@Nt4ot^0g1@dHi
zXuyZn?A>3y-z`nQ0l=P*Y2<5?U$C==XkCNyJPDcY!O<vc(3%162AFOARY*<}YnhTt
zRU|9Ltxz7ALjn`FN!%UTbes@}3>Pi1;D-%q)5;*mwMYQuj+`?0A>3;#5hfk;6Dh~1
z|M|@~ZA&l4FobjITMa`@v*g=P+|{3b>1#i-Z)h>h5OO-HjykJv5O%cs;;U_B=3-Qb
znP;>{fXblYG*8Hy>6`c(gDPplV3-~bRzM#Qw@e=bswWx|9<jR82mUrDv&6(i>?(1a
z-Hc48frWU};T+9A^9%b~*mz`6_TVp4ugp5lmi}Q*MYFl=!!SEs2748m(BcB4)0fE@
z1W21%iA{PN3Kc8Lcg6r*Qcks}iX@JwhQ=xv^l~8H<B&iS{g|2PR1MjmT^5}(cM;e6
zrm)30sWrRsrel{s^9$d0OZLpaI<!wcIiD*q4}DpG?_Vts{de}KV_EPKG-$FFQ>0Bu
zK{;C_tD>iob}5E1g(y~#m6cj2&K{{0hb#j3G`Gd<1$n%Lg_HvMrcVwshlr;F)3bz*
zB6Q&(-9T+oJ`^lkTpVd_uadVG4AZlxFPaGVw!-C0nC0EGH&MK1ht5Rgna_<sHnWSB
zw${_MDeX`pWGAPIp70p?9W!CLzJNkr&(l-4Xpr`v2gI5}+b6OS$;NSpW&uNpsqk!i
zrx}|}ZoH`H>=xBO@>c0LDGSCYhFitxc8Q+stQXdvjsEpw_JhCj#mhhNt6x(xV|7>d
zhyP~##u=;Tbyq{P6>Zv77Ip1S9l=SxRSb)l3=urVS!aF?fvfWc2&5dMOlIv2!x+Zw
z2W#|_Xtc<*QIzIK#qp)|sZt9ZJm=%K-AQ7`s(nDgL)9-Qr!MG4!gl$e{@c>R)|Hj>
zE6eG#qo3NkaOiLlL$hl>etVoj<P6#H^lH&Q>0lT2O_co6LbYDT>&$1nf|~42xh;t!
zYL0UN7`FsQ3dFb}Hlc`Z2xPcE6r@|x-DYF+R8%x^evQarZ$@MhO9TwsBPMkpE+Zl#
zT|kVZp%kNXRDW7WlzURn-tw!*FTeiNCl>^;hqI6V`u-w-$*hcaCO7gKS}TPVbS$dV
zm?Oj{B)<%w{|HjF#&Zfv{-4(8Xaq!72A>a5uuDu97y6?51%soC$pIy^a$^%KId)YZ
zoKC~1^AF78l?}?fivV`+*AJAo5Q*yeh%T+$kdnpU^7gFlX;5`%6RVmJUCI9WZym_C
zfBx=A#z${BhA3Zf;!+E)!dx3+f!NbGp!WRaD@yxsUw=J&?vwjRZ{D?Vn=!QGf9cTx
zl}@hx^~6)F`FEwO<1Q5A_=*cAe=n|Bf4pik7?h?M({fd*G4eM$pWJO6tt-A;<lz5+
zMieS~q|_aqS4y|U74iZ!u-qXa4u}H=o8{`nFe#7vQ%6Ct1vYX>RbW$9IS^#iRHqn6
zfTV8rM)@Jr+kbOw_L<M_zI^4gA6?M?JLf=JdHe4tKf5)1?Qh;*Y88CbPyUv(CKb?5
z0VTbpp8@~a+cAv}yd+}lK-O650lP0Ok(4Ex@giv0t@058M=Wu}vMGdzsEMtWpTwX$
zJ-DiESPFHA3>}jeG(1b!3mN?g(PuNL1(}w`Pk;aC_Ks@Lly;6jR@M>_KlDqV%X>Ly
z9ky(fmlf*x97ZpOsje|1%oo5EU+H^En-S;ge?U?6s8My%Iaz#8OUR3nVm1~-B<P|e
z)-@YFV{$>0a@cTMBe8FH6xNF|uvx`n!jo?fZD^pue(#p?Y4YRY#WRRsyq10H_jhlL
zDaW~+$X{7}{@eEzMtbD&wF$@&n*7Zlef~J5z^5MDll`|BZ_i5q<>PvJD%tSj{X5J>
zvIWu@37HeW*&qCuk7f@K9?5?G^SwJ)`>QctHCjgMmml~-qcl{Tc4DX;0Y{WbF$F<t
z5Jtn!0EM)74cUPQNVP}8qH99sO~a?*OZKeDRn%*80>qi}P6QaTclDwH#ZW=s-6|+L
z$tgfu&Vhl1>7Wt>OzBZ^5cM4$|KK8+Z9-PZu-V;N^LMvrAO5YqA^x~Cd-8Yd*_%6C
zruaz`qEH7%Pc`4+K}KV;ZAP{hMM;7&i=tANKs!W$O=aV}kR*oJ$1I~D+x&b*FML08
zPHsO^@esq1-pWn#Q$u9bp>~hHM(t4T+bF^4Z`n}xiElf0&)D}AH<F`V$MbvRk4E49
z($WbYBzI2v1-W|)TMdAE>_2i@?W0R4P8RMX|LeMUSs(T}xnT0jyno?H@f{InNf4xO
zvSyP1_LGW!Q7oikc9z={6=G_p+$umOa}}fePPre4x`$ZbDXEfK@J0+TkIiZWNa2yU
z1-^+!w|FYVe&qeM_d0XI>eVp%%is8WPv4yV{D0e#{hMEVAY1(JKYx=UE2FP@s}_<+
z|2!~Nz1=HLYHZ}rW%O;gmv#;d4lia%nxT~@F+N^ZHHHhHymU5kUZHd4jK=rQI+Q7%
zu3eu4nE8U{8UJQ)z&)1@XeCZwAJ3J4;>G9BrQ_+WT1Li$HHv>wgwJQ%st_i<=nhW2
zpv^lDbeg2)AJQr7s9aLgz^vLvjHs6p<Yt8kaqtt{ECxO3_EpfuDCUTt007TNQw+4x
z+Tw=Evq}9pdxi^U76_teIM<OydFT1SonhNO2^)^eq3v`fbV(uu{reOD_tBwWTNt7|
zZ~myl{3SO$o2X1aQGCGL>j6uLuU(}&_H$yC12D!mPzUKliN?-2ELkednK)Wdkw0j^
zMgu+s9={EE?L;>TVu&(2dVmZYj0VS=8<RJ1oxWaa&hIp1aue0F{5W!AACn41|99Nd
zwtVtraZ}aK=o5Ep8QJlRH^*SoZ8L)^^I@dpSt-+FK67|GA849C?3_j0Y+UJhSdbC9
zR$!%&=ZCq?eRSi<xXCCM-#jeFs7`-ueL49iJyFp<8CkDH(@3S@Ehu|JX{MVi+Ij>&
z^T>!xWqi<oh*Ew+NSqtsb1_VV4iNi+y^7OnX)`cUgo1i0oD@tm$$v%q9y7urGv-dn
ze!1d7w)oY@j!doC)yFaI-ad8NL@6;I%s4d!cD%4-`Oea&3tQ~${H;wEcIKlS7k1|D
z;nYN+IqoRLuwoR!9;ymUKqXHKA(bbgAg7F}JaH0joYu>YnXRg~C+0zD)YRkWL@q-w
z;SrDw3mPLZh=PI1cA^wk9RpeF_76ySFvXgL>^y^t#X4nD%p~bY{X5#RP`c&*{9zZi
zT40|uAwPd9+xtg{WmeH}mi_5Jx^F0bQ=h^+rO?zHwBj6wM1`afO6=rV@*?HBlPh5P
zQ6$Qy%zT&d6P6LD>!ff@mU=-Wh13N23HvcvMR^Hc$8Sous52o%F*PM@g||@+0Zr}H
zPIlyVkL17o^1XljNGW^8m+rcJ_Ddfqne+7Q@um0ucIm-|{69xV|L`|Td$QB-TO2h?
zrT^;1_|TrxJFYymP};w6dv`gXJk3)_M@#nEKUiEGtiP78h$DR8ZyF_*@X@94;j^_5
zNSn@Fvna3!SRz5DVKz>P=tXoAw$yRT9m8Lt!O~9{u$o(aC!P=vYOss5TY%aAM>hp?
zkc;R!4d7d(7u&T<G}C?5NZc9rC>||1O66xjLr)XkHy^$7*v+N4EZjAY;p1Zfve#yZ
zMt6K|X>t4bh5Tls#}+|9`jaiCyGo7GwymW{hIpeu5rLzevO_00a@>a}#%G6o9N4Z$
zP@e9I(bICRa7PJ<ziadnbv<@=3xH7vf|kKHpbg{OV1lqe(|wpIv<CR^6couUbcaTb
zkkaIXc0H1+D<9rcdh1PBp1h-UwzTc|(g4uyu)GV7WgY#<Z<G$@&+iZJEdB14J=;q=
zN?XLz8lLB`EtZa7`7=8_&e9vNoLwxHO4|mP&h=udM}Au2sPi{VC+1!{^EWk28k^5?
z8y(5P^J@Cl2m*8%=a{c5F;vCEMBpHj=>WrE8gXc9fR|GAZp@sGiOxy^S-Rp}Lz26e
zyP&QGH|KqpNvU<aSPDQ31cCw-US#JrE2D*1myTXJx3lyoH{CIHIK$|<&ceyz{D}?u
zV~Zd+M*)d5s?Pwu6`=e82-8F4S}9H0ohT&Lm1UZ#=*h_nLtMg72j3stsivbN0y>yq
zUj+4_7BI>1!=OT0v<7*T-@wy!yt-ne>o3j?15t-&LPV{Per$i~*lla6&*-(EriA{k
ze_LA2@1V$U^4}gA(Hxl~4Tn%iRh4J%j!)KXhD6jNSO;fo4~mhsJ$VIMA<oN_2E(Db
z8%GV&d+2jlsaarmK=m8PR0H%KJ}m>T95HiUK?+MYKqq#b6d4&8Y6z93YP6RtIYw{U
zTe|zo2lkd;ws7UW_mr~I=s)f+ZOOj<NB4~W+0lhvqwNPuw-GfL+vN-QlwLXH*2i`D
zd9wk<N}}O8kIpP4up%4FQE<o$0GV>3m^xxVs}6x4vT&wG&H+aSV8T4&sBvm<R1%5_
zfa4Jujss)10ijUDxI}dKE986-Bv;Wq1vnKB5Uo1G5yzpjqX!6&e&zl{rJuQZ^#3fC
zcJ7%Y76VCkRQSSS{OFuHsn6l>uuk?)#TcD6(q=de3@OfmkKRZf*$RrFbU8SKPW)H!
z)`{xOEOR09_#dYgDU~JQ(8y?jY*2Trww=!gYB6lUEd)NW-4RC`rDT$UFt_{qIgXA#
zf24HlmCqb5-BucX{(;h6SH5&Vm%Wgzj{f9g>BLROA&wrsWbV++CeNS42CuAe4<U<$
zBSu2%U<g1#E1~YRpiz{}La7!Hz6&3O(^V;R-ND`&gTb{T)T4DX_7jL&5~<yWmD$R*
zBdmyM5qmEcB)8QHrXHt{lu#<X<i?$V+phfHL#3w{vOk;c8eMw6w0PxPA1OU|)2)+&
zV9l>>o2e5<Usu8wsr1EfrY)@w1m0KL$50oDU)2BcZ$yiUG33xNIhn{p2L-#pDM_^5
zoM@q$Px=7D;+Sz)wGeuXra%JWnx{}$*<E03Z6^_#rSM#sd&&OOH$QUauI17%-+X(1
zO8uGhW}=RM^WCKrqhBnSw%$_w{l4!iExqo-)2EgVhVl@?whEm@o~Iir)q88->rsJB
zludaeI~F(QU!op)_Tr@#n`!)q)zJsPp|pF5*oN0gF~cRrOxftPjq1bMNYn##6Xvgp
zM(irYLG<=|1~ha41-TaN4U|#$7*-=5HkU1`#RN-;HMSle5OQGRDbJg9O3EbBv?5ei
zN^8>|D7~)yhe}ERWT6}xJ%6}VzHLoNGFm=TI$#tVV=|2m5{u)K@|spfho^-Jy`)>7
zhqa9bQ{pN*Abt%lXcK_Xw8nrS%_I^hr3?C0w1Mh?GJ7LBC#2Can@Ia8zpg=9ltLuw
zi3Lb<i?|m0+K|Uy`CP43yJ?sYw}Z~+{<Z*U=K=Ntvz;lSreNK1ka5v09tBlFsRwMQ
z@Y8J(!*gVI;8Ds4=t{t2jpX$ph)^3q{^%21TDC+S-2qY{nLKD---CX8IA7ID2>giH
z=y!6SkD>`b$+)9uQJF73IYmL{Yqj{lAP|my{i;)vR*dt_x$oj03F_y0KR;fOoUaqz
z<ot)@!u%iv4kh;<MTxv#@Q81~175?kY|G8G;<#(DgAASVs2Kg#3sQ4=o(2!i&4gw+
zMYa~ln?WBWvT||#@TLL>1BB{fB_{a7O#?zjG4DmVc)SQ<xg&Z&3zO8i-OWDnvSU}i
zv0Zv#;f|DMDUSVK9z=e6Pj>2kySBTdwfR9_508OKa|lB&9)-PIMZXMZtydYV0m&i>
z5*{smoJ|n50(wU8xWRBrT*5f2IVq3H`pSHry$D|ub%K8G#?j@fGLHw?Nh9FAZalyA
zfzA|F6#4}iXl3*d{=4ZRmmV!WdgY%yT6*m*TgN!YTATQ7YnVs&P7UH*E5fVC+MBUa
zL=&-H8ZF?E)vFKCbgW4_3Sj`NriL}d;deHJ3>&w^d136S$tgcrN-$TEnuxhMNe!9>
zPYVFPAZ9=XGj8UH3L?(5YzA?2W%2RS*DpAYv#uuiD_>nYc(bFlD%r>1y?gYzpDHcJ
z+>>orMqgc8xG8(pFYmhY_g`9iQ>j$Da_7rSkCm1~%unaCeh$#sDmTFci{_Pk@=|i+
zN5+a-=TxW%7-QrZW3}1xnbU}~+=CW&y>6iTw_wDOLdz543N=Jm(nsd%m}<p{zsKOV
zu&fy2WU=gEG8+HaMTC+8v&F=1o(W{kB2K6&w5f-rPtNLz3iD(v9s@bPycMHYw96^f
zSb;I(kL2fbEcZ^Y^e(NBh4uSqJx_7_`S~2v*UnYv>nAqO73VX!$mZ`&jjz7S1=Dkc
z$E!POgc$wto`vmz+4%;ZUYrn>t55QnrL&skz)QK7pa^5L+t7RKP+tD9fsjF$#hs4-
z(W}7;ky+;7SzK`KLpC6R*FTYI{vVykAeNS#ti5Jl_ZIf$#Z3=f%3l3P`$xN^lcp9=
zO?nvLaUdn@mZ><9uEMTW@HU!Smm(HEEm7o81TZr}00$wqvG<k6h6m6tbDd^CM79<0
z_O<4lSrOgX+<>X0oTAF9dqk#&Qw-xZlgTmcaC3>LYC7g8kim50VA7)x6npK=>FaIE
z#hD9dO>)vaGqsXqTm1iIZyPP_s)vpZ=T9A*PM9ouBvi!=<>KdG?X<Ct&pf|=g2K<5
zW@uY4T+CtWy=!GoK03m6MoOUUzar;76x?L|kb-rLKh5(2#!AV5x>RU5WV*UYwSib>
zonyOX3wdWl;D+Qd4!sq_%%eaQNa8|&hkYf*ixY{-%3}&8uP7cXsSN+q#aV9OOYp2e
zIj2e-8Y*wr5sB-G@lRU7q7)fBw|s4{XGUY^wtnrzlGY}hYcHLhY##ArZOHtMd#$3a
zqFB9Y$FkA7W{<fW7Vc$DKIEB3x?Wh(ST7x;9>;vf%C%0v%l-YV@#J<jb@WZ%pEZ36
z$B|z%4_{BAtk)c>KCURHzjFMIS3S6H#`^cKd)GPhj~VSJIlh<>qhB`0!HU6?N@jC^
zSafoJ+Y6UQ->_w2UrbrKYxMoUQ@VA>>iEWwJoch|5LfnvGxv_Zcjv;xTb&^s9U#HZ
z=jYAQ6G!PHm=Zh%I}HIQpwrd^0W>iMje-x9(U6#d<7A<#l@Jzz-V{QiG1Hf*xN($r
z1E%Y(s3Up-7^{y67?nUOBLW_?eK4Gny+htXUNI=z%;}@~QATRF!C=k4*~CN$wIhFC
zYws2l-M7uyS@t!5;hy1?BbtA>#ao*!p?_v3W+-s-W9<Ql6gSv!x()zSob>`G(Jf7+
zjVm%hii9g9V>FO)=9vG!1o9RNG@Y&n%%WdN5JQWuT=oXsRjY@Jkw5_=+X7gt#q@#(
z6J)5TNerOtMilE0&ff1eIEMUa%=LB4_c}y%!`d9a`Z;S?3$!z<0{@O91>;CP*oAsO
z+RQ^agc*+M1lp>jwHIgsrpYx2zzmoww797nu2vrl0W~cqdc{yM<0@s=rX(U@P~&P4
z`Z8i{Y%sVghC-3ehW-@KM|P9XTR*z3Se5g=u4?`1I7{X3nOAblu>!?GDsu|I(R~-p
z-w)-RqkOcUkdqUmqy7LwWIh1x5WgywK`T&EB?dy5x|;HV=9xq1-{ase*elBo9S49=
zUT<Emd3_<8HH6M=D@Wic(&VyeDRZSI8GsqXE#w`Q{^*w%7RC=Z^075jze=83JlwS_
zCyspFV!lZpIkO|yz0CYxm~wP8jw%1dCR?OP2-ni8;ZmH%B@E`{()a^1D((WUi82Z<
zC{BI#H#M3EY!(nmA_i~KCQ9=Iw=)J8heY`A;bLJ)(Pdx|BDJg<pS#f4z>t6$q?CeZ
zh&t(IY(y1Tt5h5yn;-VR;du4yt?9kF$;^j`iRsvV&mZ`vxMce5%gsaL)ClO!FUVW{
z*WVgBCgNbR4ZrN8=@6S{BV#mrI^)cNh&fSa_~SSDTs;RQ2l5Ai4rD3xsXPlf+o3X=
z3S*K+^weWfV)#DorRnuFh0%sien5^++YxAqc@_v2+fb1jIJIInr>g0C9CLj%Kb}Xi
zUmQ`nw$4*-de+BG*3<>FFb<d{egZsDON*I=(JN?rBZv$Tqp-96xZ0R;MPaAU$c=WZ
zF=Zc*1Ng^XSq7}GY|7X_f&kT~;ceCCLxFU~I3GG!`#3&pU>d02N>JEh(AA{9{ALPY
zGP#-XC0G0La|7_y5;i#;mSj~!qr?x6t`*$?M5E>jeKc3`TwpPskJ0}L8215Oh}jib
zEp==Rki*skL5Nd<F7&#jWe<^;Xi<-b{?H-Q3b}h*!M+kbZ79Sflp-`-`EfVPYv=K-
zJ&LQik^H!uxyvWMq?X(IoTcV|U{aG#4UY(0M%j&?cixFpj^CDZ(Oz4Zbxg69kshtV
z2ZPo086|5WJVBP_|H9Na=U)s(TlZPl%)of9!<!v-J#(a7BvTY!G2JFV^*~v9qMa)g
zM}L0j!r?sgF_8hXX$TC$A&w-_5NUrzULQ@7W@OU%@ZlD|PbY%rbmRlk8!jr&F$;Tg
zl7-5V%D{gdK42@ELK<BPG0#`Vqt()<KweS@P$_l-XTlr<w}{b;NAvSomY=$GZlXD<
z<f5Hf+@jLV4nMcMNQ2fdt&BeO?WKF>4@3CquRw#BmM&d79e_8*+jzO3&CgbkRhZ?B
zV`8`=mqCRZ*=4F!jFttn<}zg%w_yob)Q(<3G=vRBh6t6jn*fKHbrgl$jUEu{NELF7
zE-fFUXwqL|`V_|ncBbB!E<yLA1Dt9=50)M({oqKR;EYe?URgi#)60c0|NLaM=5;Wv
zjUSn$K(qTftT7}gMd-VJj9YSFrq)qv$IZ&ntV;M=&47`|K>KCN(MO5zFk&pFKmpMj
zM-#)%d9FtL#S&dj3`_-739~k{H>3%1R90}?c~_X3msM0$$bxZi76{@9wAbn2R05z@
z5v*n;A8VU^%I_AQdE;e8p1cX3l&^NA)01WSN+iw{%_!Yy;1iA{#&}u>h?uv_t62&O
zlI99b9#yg<qY%arJ$bK5OY#N9ZcORY;X`z4ab?JmY+Ye-%n_wdK2!$zg|eV5iH46J
z394yy=nAr5n{)K8|5`d$*wMz7xJCwDV4)j7vSvqDNvhVDZw4=$gp|q3-mt+L(Ihwl
z%cFZq`=Fq$v%Hp^(&(nW9ElHn)?q+8DgBaiD%6~<!(Z9DFj40(2A|`2HFFtEhzY3%
zbuj%c0Si5W5JW@}GoNT;>~d+ij&zCuEU*TWUJy9>N!H8L5~9t_ZC`Fa8?Gv>Egz3?
zd}+ti6~sny^An_MDq$^(uJr>JrhvRWVOk3u8yA0*sPVp~(t*tnX!q|-PB@$TC*s-o
z7vk5gCACX^#wc0PC#w%b2PmB1B6=t>Cq^7s%j$=*`SHwT_Yi*crv5hE1jROiiC)`S
zZp^nwgK0uts*(f_Tm1+N#?8|DW3+uBKhlip=WH-_1coQ7;C!6Z=Ieiz*q)!Rz3~&1
z@DB62``S-pV!V@ZKebF>(I?^Gx#1_Fm?Fm@<W!UyGif9!Y=YuLe(LWUh1FE3KoT`<
zIF+tCkxI+-KV2}&I#8Qfr5K^F45f=QT#sK&7Z8q*=mr(2@i*~(I^&cwxhjRvMH7Pf
zx_O^aQG!RJzP1If@(7A5ZSBg*(iew-&t+CqHNbr3wQh+qMxR_X7)*K{XNv0aQ&Q`G
z)+`&H4HQ_)=Z;|@ksL;bD9h08E5T&Ngv4leq?jHNbG76dau!w`)5u9lJLN+$>XyJ!
zNSCfUXhP~ku7Q3td2x_^clUS!MPE2~K_~U<`7`EgjQ-^BmQEC|a{A?bZKAceHmWQy
z9Jn+04CBv?-m_)l$jmEifK$vbp;q9!Vo-y*;?ZqqKhe|E{hHU!l@Z(#NJL|&HZPL|
zbqvT#T&H@ca|#8Tb`3ST@=%awB+P>1&uq^49*HzmrV<kcgT7TZ^_dfBhcGlCmhI!8
zIypRXy#!d#JoCFN(uUaz1|zEqFh?%PzToM}cmTfIBlMs4;$%6k7fz`FFR(8|H8l?!
z6l#Q^fM&9&=SQ1okiEf{NQhu>$w7KAuoh-~($zQ;2_zE3bvSH~RL_10K!ROR^L@`7
zjy0xNTF!JKJ%<zOot`=q@hawe<l3KH3wv|xGaJwHH?MtYJ(#3#3JNGib;soyN6jHB
z<&BW{FhnifsV06e$s9;SHON6`qEXE7k>tgUH5gZ6%EOHQ2~3V-LZVSRPMJi~%2^2{
z7;s21fefhMkXDfnQEH7ov9M5_rarOZ>+RzLf*c#~<k2^BYW{|z(0c8%R+$xxHgU1}
zqD}7}Z|80C>z|x=3I(qGr<Uh%;xR$D4n+H!2~#_M@dWX4oKiWCb-DAsZ)j&3$Yc&P
z6}8fYP{6K{bn%&9#>k3N0-8QV?Izkml+~&n1XmJ0mcSfDhQs*+;DnMHia|dTx-avf
z>^M6%2ChYe1LXvG4?ZllqYnXsB0F*c#hA<}pz`ZIlY-2cx_07S^X&fQHP2h0!g$s}
zn0%=x2}$rCmg~})i&wees#6@F+7%Gdrp|q%txP&cJqooK?kfKgo8&R;cF-S#oP_~R
z%9h-KrfzEkv%y^S$(ZbytX|9yoGv~;V}LUi(<bjv=XIOBy>4^yD5ja>f(jmn6mkBo
z&CR+HJ5L<}zkdHSh5Yy*ndXQm6!Chi;qvOG3t{lXN0-WRWXWuDrzI`AD~U<WPX-oM
zNeLZ97C<FDhpW<)9tubt2V0HC3DaI8xW)nQ(H2FoPN^nscBrNi(_ky!j9=?Vd?g>&
zS7=)qr@vbb?R3^SiAe)2MLl(^ev2O}O`K6dm|xHE$IfW#;#td|vVzTR_qyohcsB6n
zpI%?r@%s}KJo5NAgcY8=KJ9$<z4K*ko%vBBY%2haf<W9j^`el$PTv3WsKh6e;ng?I
zbvDIS@Z9xGqSzCYMa=i{#*I|gQ=7lFSzsN%HM5iQg!+z<K}0iE_x#!7kYTPl&ZwcT
zB5a5;1abVkKein+0<<Kob(~-fGY{;7XQzA3)nw7zR-x{7u86oDibdGI<|V>^BTBXZ
z(RV6eoV-Fi?htvx`9PJOrU}cX-0`M^xjWe}f7{VVX71y9#$M1kle=CIz4>_b@p0UG
zG@IE^9X@DSP61XNc|7Nz=SE>ZwQ3|>j1Rr`Wx40>S+(5rZ@l{AN^vUM#_!6GZr$!&
zl$pwQlRl}5XPktZFKai9gH-+_=TC8qUt|rmThCmTBU%ob$+s)+eCB9!rUtd&WL)X&
zcG@62D(<VW-N_9_*czsTOK0YFA^8*kvOtmi6Ence>_1h!zlr{6-;_RSW<z8@^o7I2
ztAcwr%GFQ6HQ5HGE9Z8O3x1j=*0?5OT&Ykrgd%3i{Xn^<=d}%FiP=%n{v4SrDX_6Z
z`UDU#&?<SVdO&rh-T-aIwu|XiWYQ)(;9C?nHWB)mLeS?TJ)$AW2httSZ#iyhZOd?G
z#|y78^YRq>SD?ac?-nr3-4nx`1zqy`v$HWpnH6Xh%ezT}GWwYxMxxG!R{jOvsg8re
zMSpu}zhlkfuxtd4(R@*}MW>JxAVPkNEy0{ReoE=1T?bu7t&DeyBYHz<36odqP=3bH
z7<1d8f#k;caTKFjlhwOS8>0Lt>C!LWYe&OQQLL{m!8OpnqF7(MauQUpUaWs*7mMSB
z$+=Y>-l`*0esr2hK8(2nRHz4)#W-(Odz@Tg)M|{@=n<3|tf&9Q$pNa$nBk|?ZOh%Y
z9z#q?Y)N<FPZ~zmLoxV5gT0=CN^83*H5&JnOfke2j}BEXob#llShF-ce3o=zNt(wC
z=R9-uWYvl!d@c*l-O}0^JUiM9yh*^`;9+um-yAYM6O56M$5_O|AUAC6;UoiH$4<zL
zV^%iG!nD#*;>X}fL*yWP#s)cJMor^{w!l-6o9alG8XH$@pEQm}MQ?)*Sus8yHy5Bi
zdA@On${CwmF{4P0Govcti26>g!=}GFJ=&Baok&24AW9$3?<())TRS1_sx(HC=uKZd
zS>3$Ezkx(+YKMD-1;S+d{ORTKkptF{w-{F)8@K-E)ybM8nsv#MX`DM{;M=)VGu_|o
z4*)q*t_>yCCg{;p!g(A7W1yM;jkzh&X&1biUQA9=?_rGBK)RWJp#>f~6|*Z8qP#>5
zG1YQHsNq4Hdf_lDN;(H#Ynwsn>WCr0@s{ohy_#etaiB&k!s40iWj8-qXy%GS;(9h-
zl$lf4PM$$7r>c%m1HQ_dY}P5Cz4#w(JQ<c3)MlW4N%N@ei)LCMCd@+@qC+Sx1MVI8
zVZ$0bDRkuVMXxt8KRzF;h9*)+)0?<u+7cG4pTX2h&Hx6cQ_3I$2oX{$4!GH&MmI{5
ze}F>=ix&ug9!jpa9633jUo=^VH^jXww^!n1<LUBllQ1*M6s{u_JrmPO^Y7Pi{ZKxU
z_}ux6rw5W4Z{+h*m)`#N7{nn2=6|Y`v-do+cl2F57jC~}>iW?q_b=RYBT7zd&4CI&
zXsFO4u_B$VfRH%dELdNgpVPF_O$Q3hEzXsVj$e&ix>AKCfsCIeBGL{Jl$MGy&agHY
zg<L7E->Y*;r-S)&p$=oVku*2xiy^fleLjO{hp~w<Nu+oN(Exkl=XPfw_~PPl`VE!B
ze1~NmyX}k{O)MbX;GOLReekw}y4EJ5O>;UGv=NYvnXNkq)8w}p&1xtN{{|U_v6<#b
zM*}zmuuIy3>oF3{9Ler|Y=$gL7nWIDWUJ8%;)o+Hi~5Mo*$Lsnm0y3AM%@Ekvj0CD
zEW8lXfIGjobkIovnCWjS?SCLyIW->3k(X_)JT}Zu87hyy{%cF+Av~W*&YBr)N_J?L
zBZ4@lO<Hw&5UG^TGwt}W#5g=ABw?83n0^Gzr_ff;5N2BsZ7qhmN*O#~u(@U)lz^cK
zdS&8t3D3_2DC000K-ZifV!b%lE6A5CpZS{7>q?{FZY(@<=Tocw^Jj}4P$|au{Otd}
z_=5bnoZL7aFO%QP%rQIOiNw4-%3fVcwyljg3Ns)5)~ieZuvESB;n$Q#=EeYmds3l@
zBzk)2e^VH};!6A>EG`E&YFj%T8DT`39{ov@9<muTMTkm>475M6FOHH5Gmh5HPbj2n
zH!8+c^=aI*rblEo3M3LQJ)n`y@*n+(QCI%cYfA@8`wFFLMB3%9Q!2HWr7?1Ab@aLa
zRsZbp2lUV8<NU97U9m)=$DReqvHp}to}AKC8<~kO^jtAv%g)ozX@;AoG8`^xXpMT1
z$Uw}7^PAWh2a4%Z^3wlk?%sp!F3UTB&wF;0%>_cTxp4`S5V2sAWpCL{5D;b@tR3Yt
zQbbxWn`DES3zsAUGO{ohb?OazD!<Bj;bz5p>A)X7Gp)B+tG2ZTrLDC^i{quXRtL1>
z4A<%B`<`7kyG8qN2Zij(IcI;r_xHZf<@<b}?}L9txskMKe6><LGO6K1RO=K#X$g_9
z4N+A*1?Nvs|5nyiPAettO1(A9UR@S;p1G)8*6J5SqtkBfo;qCPfsxK@E-nkpf<1dD
z4_(tf{Wnjz{p_-``%|;wY&}d03_7RC8f&XY?33I=kCcumk|3_>e$BKy5!`56>y1j|
zg7n%m=Gs#{BE-K4_h`aIkJU_IA7(zIi60`6L<=xdRX-F+dSx1y+(+cqP~K<+GAS|E
z3u+A1JbJsH^V46xqWfbzQiY5a>ZJp!7s?S(XBWR%oL$Hn88%(#+TtpLyQqjzU{o(*
z@2E3HGlUdTT9Xsf(1v0PbaGNE&jqP^Dp6|8sUxzYvX?U@GV<l@rc#F`sREvxI+K@_
zt>whYx9qR0N&zf3YmQXIVDsn=Wz`b5(S47f2Wi;+#U*9w)Q!4ir%zELNDWMrJNHx}
zu`Xd{Hl(01l!`dvOS}TA1PX&_C%6F0FPi2<GgT^M78SEG+|<Z&{X5l*Y$hF6{*WC=
z*%#~7G%HScXynCVJS&r@Z4ymYc}7KSLWU6y2s2>aIei|nBStREw=Tkwgy;6}(!jU(
z(7yfCO-8wivF690EgM(-uXi-dK4%|M9!M0agCx~>d7*!&e-?p^o&tdvJyDVY4WAnH
zgsNr=jCrmJ)*WBOI1#Pm<1QR)AJX=(!wM4bsr#?vlaT;Y23=M=GPPGSg_bHQHS=zw
zQYAMxAG)+0(_D0IIkkD{HKn%?I2`$&=DQ2a`sUe7Jq@<IM%lBgt}aFB19xR?JpaYo
zVQ%QB$Y6Fj1W21Y97Jg}BEoo<v{0)W<1f?WV5QY)6>l&XaGn#JNce<!LTSoKM6yCU
z3=x_j&+yKXenKN4*zg;01N}2OQk88xcU)RV%F+9-yyC6h$;P7t*R?PF#Kz{?*OtXo
zN4{(?%{4*Fql6=9JP?54)P(E=<B)YNtLh<{JuSLv;*jM#6GYi+3aVd-{be>8Tnj1i
zOy8n+rm+KdY*l3in7-o86Ls5a0aR|z3<GRm{kI;dTBBy}ZbR&sUu%$g^Y~@u@#f6e
zYau`7b>-}y&L?)1p<+T7ZII62?kp#iwY<js(ey+5YMQ(DmzB-($+D&lwr_s-@y)q}
z;;SV6n<vZ3Ww3egWV!Y^;rPu*O%mOSyUDk;zkc`G&5qsW5?PY3=dNa-t^FYol5CR7
zaOPFw7%2{eZb;;WNTF~kA@WkEixI>Evqg!(;5%Ze4~KZV&BG+!i76_j)mI#4H*mOy
z&h+}}Sy!$Oin3#c&*1<`U~Lx5yJNh4*H1UC+&8hu1QO1sT92T*L+#uCWM%u|H}*g8
z-yJ@*cIx21tI+=P-r!ra_v2WZq!;NEoTHj2<bKGS!D#Y~%-(ZJBpk&II_E(#3WbTU
zcO*SD;DF~OAfS{hl^`4-J_2i!V-g?e<dJYVki%P#g>-n;<CXVGWgw_wcn*%$y?WG<
ziGWtqfjKWUhfktD&Kl{n)(DRd9@Rb!2A7i=(@N9YM-?s=y6L>R?r4iSb|4V6!c^Mm
zZDuyK;D+h2{MaRUib6HiDUuHKLFiB>hRSH>2t^4Tlq&p-%%?t$(cM+t<c>F$L%j?4
zU9mImx-)tvi}vZitFP1sUgtx=KwAqJNggJ;P}CkpK;}^Jg6#v%3`P+eewPl-L4Hri
ztAnk8iw0vvTa*WM5c4IdG+OH9$>0rsN1@;CqADdAw{eIFWOR2GLGV4&#c^WvkzY7i
zdYhZ}m!+L``^uFiv*%Wqq2}?Oj>J0&v-G4v_VITf+x+Q1N`^n%uOl$s6$+YEV#EuB
zJgK7^1({v!p(T?wi3l;NX^x{FME#-qx3G6@42y_q4A=&X^T3i)%`OhQe*>;~7@I{a
zvpyCPb}Us=TcY~`{3N%Sj8QOh*^4_5Tv=Wk^&jW3Iq7ZXh0T^jWzmA&IiJl(u4i;#
zes$T<J-E%jtINSD1`}~XH$*}-u^wJgq;hQ!@*09#?#Z~cI$Twf=NGa^T8{M*vs;o4
z&?Ff_JsR>4=#gzOi7G<=RDUu_GzJPtDa^Mj!oggzqr#45q@z3`Az}B*+t-vkdrsZF
zen#=88!-v+28N#J#innnoYHJ|bIt4DQhw1s@0+XJw=G&(UzyQNA2u6(&S|CCqOPw<
zfiZz9r3XZ}8xxd!h6SoQWDbRvfJhC%W2&YgIb7-%3{QL#Aw995Jp<F?BfUSeFifyF
z*}9B?s@t*le}vVzT|Uu<kco+*N4r(%y1hCVTwg9Li`>{AvJqD`k8L0-@%6WsA9Yr}
zt^BAo12>!L_Qu@{I;Y)K#(Fkd1vgR)HxR^hXPsR0(95sCsxH%ZPdkcK%^hzqYnq4N
zt~YzIIp+7u-8#%Y5TIqE5l{w+Hr+Djk&#e$!ew8Yn{^gO<q@sc))FJ9PaJnY+S3Uy
z5zy$K)DR+!(r7^2gWcJvGC1m2Xir%4%Jj?_3ngmc|CRVBC$ce@)Jv_SW7@yd3>^96
zZH;g@eq3Ty<t6PoY+eo-5|LBxZ{V>^k8)6imk1k*wt;FD!T?ChMVTTEv50Zb$#z_f
zjB4~zM?0GAslSRN@Hox-#3RTQS5oJmDo!k5BQaKU*)3%)WzH23tZXK-f*-oYnVzQ%
zBT%B&Lla!g49c^CwCb{v^pa?c@L*hZCcz=uaA-J^%D4hV5*{^6rm!9%0rb=;-;fuF
z^O=jHV_l+2D9{&^ua}=lM0I}d+;xnegUoC7WT3UXQMP4@yWdeREbUhw-q`&2JIgm0
zKc|OSl`8v>R7kA*VziE4U6hb(%bv;WyRAqW`y*Nkjm2<Vk*I6Jj@D`_D2;Gvtd@uB
zLIi*rnk2H&Mc^C<$H>$PHjM8^esjALe-~_O29A)A<H>Q_<m|0+1Xj~-V9F=|YjiQ)
zrQw3Hbqn36FTbn2qcoRX%&30sl-7!7|L>bWIxmz`J-2v@A3{Id0AF5AnAumcDUo%P
zG^9A<SfZX;+z9V``YgF%JDh1M6wbWVXaZ^?jgYhm;Wd^J>Y>8tPEns64!ZTS!DV!E
z%*~*bkeGA0x%0BJsk8OnqM)O?5|dq{)ZDSQoZ2_7I@$c)+OmGui=DHywR$S*@sZT!
z4&(!AQlbh+i94Vn<_mvMYZZZ$0EOs8w(LGt_gP2_YbU|ZgAa+7l=p32fO^g#tu6gY
z00v+siDtJGabeU%-(=1=CRYL>Si8zZ^IPvJ{o4pP%}b1?NAAtBC9^Wi_5RYWF!7J9
z$*0~U)|Fn(bj0q)?f}6`+7G<x;3Ngq^*6@TbPIyXwWhPE=TP&#hjtm#feQ40<y^WY
zuDoW~mTRw>xT?Ncnmlc}r}i8;L{QX5Vg^LPSlXs=csQPD7<dS66q=HSW(*wlEVJsj
zk)Y%p9aB;{8saAz=h$h3>}?PFaf}wWq8Jn~qeaR8St}j^fmz(4c}`Z4u@MHaEc7uI
zq#D3j(myWEF9%zzo4${iRn6J&FH6gCO)Y!39K7cG_FaTTVf2z&F;QSWEsEyFaEAgm
zp_>gF<+Ca(;mV=<QKbMLyJ+#3u1(;OfXW~VTwd&tBx8ekdvX|5N*z2rYI=@T^LScX
zOWWNwum*2f+#~JUSsm)4_m`ua$KG2OEZ#h$aPV9*-<<XSa#Zue_mzKd25&7(+n2Q0
zR(-tXXf6bf4$h=IUB$0=-&&S5!=Gmk9XNU#B1ZEBc=2dl1Gpk1#I>h;S0V);M61)V
z=uVLg0|V(Ha=<8@!~r6;5Xiy4qvIpFp-ODDIITFr4T>ZkVrn|Vp=^FKY}9nXF;w)u
zINr_5w%l4?(dw@C&7T?Qy~?ULTRuT5ipY6%r<e=8Kb1TXS5{k24%DE}LswYD!X2w`
zQD!uyM&lZQUl1dLC-vqKxfHvGqlqi?$oM{HLEDHhhl5XR3Y%?umBkj4%1lIPf+Yqi
zUZivA56Wm+R@<k$c0va=A(d15yC7C@p!#}V?lKJ4Om!0^^3T(P^OC5@sdbrJzZL<j
z=@#I_IZ=3+4-(Yx>9*U?W-B~YlH+mG;{;yC<%9cnM>=j81(#`dzyi)FgOG|cm&B$`
zrp#1<a|lu-iq>T|q)e@;IGQPf^NeT6#IEd2*pilrI6ewcHA@qBP^vVAPQ7t_GW6HZ
zz3uX{9(psX%bkC|z4Vp^b$Qw+y!OO0e)}IO^VXm1N+sbMpBKZq5LO_Pe~Gz0>WJ+^
zu;h5K3e;Vx66he~!Az}2NoF>=Bz>K*FOUc%N&>EgK~D>~OK6{5w#XIaZVZThxX!&w
zC!#I~<w{{4{HNC=4Z4#Uu$>JbEUnVn^r5ne5>9jOhk39!f4Drp@Cq75lLwjyt{@tH
zRriN_7ZIeK7m2F9>ahT%1VnSG8Ih4@37#{pUxEc!q#25o=~lR6q-8}^;r}D`hSsX6
zDB+g`s%5i&Q7$A8DD8kC$&yc!&nX4?Q>LRyHi(WALDD;5w1cMT#ASWcqGjzzww=)Y
z{BO$2qo-f!UUd7TKRLc{S~Igt?@{9kz!KLR3Ic%9wene!iuY^u5aD<-qeOy%qRQ{0
zMu1l&tJ9q>%dm`5m6!iSaLtu~0HiRa$Ti-$@JN;EOwgby(aC`o)Tw=P%D$tj6+Lw)
z?6i6I&T>?_vH9AwaHWyED9QifD^^TJdLEQUBa!)3cHlonGycpa(pklbcCKw*@wkTJ
zG}evFS*4H}(!k3`E+F6pF;_MS!ynS1(H>M0&MI;{93lPo0vh%tlmfkVv|TZZ-P2@s
zy3gKK`d5w3b-BY_?pSldJ!N&X{chJi)|_{D8JRMXUIr%$WTui0Qq*H9lWaf%$xT^P
zd&Bl-b#=_Z*VR}=yv9GE5V`^P#{p;zNr)U-O})4}5)c>0m_SC(-r){YABqrqR#mVG
zoEwDukLN5lC*M<6t*<BzKXIh!P2B=1k{v<!Xx?y7Sy{G6r}^0F>e~UfW#7bs>C#+!
zUOsvcCDqi>=Hfn*Kv1Wy>S&wU`JVbHl!Tf0FY<_}>zVHb8ntIwd>FUT-Con)mL+0_
z9f-t3Vm<#jpXqtcoCIl_5+n|XX?bRyurvKQ`xF(SD~v*L?%~Pm6?3<%e`P(q-d>Nt
zj%}{ogVX2V-pH@IJuxS(P7lI%gL*3}Q}0TzIRRCV1EM9R;*gwQN)&D%`~s|JnJkIf
z+zzXpo=?>5M{(A9mS;x*z;<x1L9@usX;1*K@9GD)c&<DBlN8p0sgU3D`EwbY@4iG*
z`T2XxqD3>K8k-AW3K&+y_6!)xlsiB;=`@A3MgSZN1P_V9)6u{wNR0UbO&V$1vi*a<
z@dyGe@Q-sd61^-UT)W`;M&q%$2Js10T(a&jHAx{`Mz{&h)gukOmfAEu9~M>r-o54A
zval<+)7*M*Iidad$5-}E>+iG|-?x6M7D)K9*(Tou#)cDuLoulCZ9W*MO<NnNgXx62
z5@iQv9-axh>rseJB&Md;n1iB4UD~S@2RMaTVehj=au#JHg)iRD^8vOI+<?&&zm4Rp
z*%7*6^t%}M0cMq!$Sj~U>Ga67vBBn{JL&NL)yK-qTFt&6kWM@PzS7@*^`$GO6lcLw
z_N%ofuSg3t9UG%~2wu{EZmr?yJ5*yhB=n_NF1uc}NxX!Bl;W;z){YL<UCqf3f@k{u
z@^n=RBU*%499W1-lMWSmsOWdvZ$jB6&6h{YshuC(SAL_lsvga`_Gzen|IMqX==K{_
zH9dW6NSSed85ko%sxEdG2iQTf8_i}S-6-Oz3qVEi19Y0Au_fzq8ieTL^lTvI!U&pV
z0=<?so+GXIf^>UIs4Z6?*+ADKM!}8|r9}QwXzags83Zx~ry62C`^oa=(s}P^%1e5B
z=xVmlJv^{<n$H@Y&GrS~Snp11=TIF3YoA~R%ri!oj4O;Fp0yR|;Cw;of*2bF6_KUH
z70M;tWgY*=)haQdmw>0uSB~s~%$-oTnVzcQ1e4(Q5{P_sa&!Y$tE!>bu*k$5oHr}Q
z8WYu2%@a!0GUylYC-1ss_DVBkVW4^Pe*5Mf*OLBB(gKxAH@?Sj>BS%NJQJ>UW`Pl<
z4J5GPN}%$L9#Dh^z6sJ~LpwAMXEd!~PJkYXF~^YDoyZq`0FxYNP_8rSu7`OX8NDs%
z70v<iPzbzhck^(obz0*h`xebKbOc#mHodshuQgvhsde0xU#Mu#J}ZIhZlfpTc$wUh
zxm^g0AkIvDm60(VneNCeCIrXDn{XPP3C5iLm%TCI`kSQXKwWhz6RRn53&b)4BYN2o
z25E)k8F^YNDuMmG*>0|Mao1}p$TZ*kKv}tQxXV47lj=@ie|=}(c&oWV8SHd~IHo;Q
zWi@MHU7?d2kWQPNE|p-K^M7CquSpS|%Iksa_X)!H9N4mZ@5JTP?~M<9ZcxbdZ|>@S
zP5;o%ai?~6b6lCJQyq4gyHq&{86?bp^n|2)0u=Vh#H<l+l1C>q!2>wuf>;V*#=Yp+
zi@Y-f27_Y?WLn{0Pz6v$niMwZ_!4O_Zji66UW!fQBYhYhOiCqM)JHybj@wqynOQ6;
zNxFPC-niq?6?+d}vH#4SRMI96o<9BeXV0@I1HW$J=YBK9>XealeZ5CD`}LdVeg7F}
zOb^;VtNYFuX)}4#SsWn6|Mt+uYyQ7HKtZNfK~~cCmBW*G6=?+pQ_}Yk)UX*HFnM%N
z<eG?+NpzEm;g})=8DIov)2_q?DDsQtRVV>-v`i&h#5x42daffx58zTTj`pX(p$}aK
zvuj(W@^-%ZKpE`m9PE_0_8nbm$91!h4_w!rdKj2I5_IQqIkEoX=ELQ;jWEENr82H)
z1-6n1i_B#{0ubI5Jfg-esnYufn!qV036qjn=D-piFh4=Nc+@m~ff|c<q1QqB7(pB)
zX`tRY7b|T^eHenH!$pNaU_(kJ<&kO*fAobiQaU$(sl2MUdFX3pSzq<~QpB%)we*!m
zGk(9l=Z6DJX2XE?r+-NERTr}`*T6Aa=PK2^Bddtc!VHCSfc3!ui&fN94M2_Hssu|7
z3s6QROCF+(OiI;blHkKyMD@CDNV)Kch$LujJD7JEAup?rBe4(+NhcM_43?Z|9{-MT
z=Hb6CP4C8Ovrrej+YB`KXn3uC_**NRJ0C1dR?ajI9r5mL=3|bSVjervtUr&e#@uik
z^G06Cy(l1Q^2AI*OlHejV)Rg*7P4F%5WFn^W9ju>fInGW4ue{c;71G+o`TpewR;>5
z@JEH7Y%NciPZUSM9L<_bnzzi{>g3J%UjPuoY3faH`1`VCv|haKvP@AuVlLb4%ZfL%
zJw5g18#~uMSe`D&n5wk@;BIh9_to}=zq_`%=_80g2j>1wK!AB#IL<vKhRNiY(e0%<
z#6v_O3>StVuUG<54|+1g)W+KhHsi1*(;DfKHI+4((@fuiR6(!g2Y?_)jeLPnY@^B#
zkpc;=x}iNHh>?h=VvnaH0~D2vH1~hDym*;G=iM8vDO7Xo{<5+6fESz3?pJC1{PpE%
ziid%6W+51=M_9ekCTs&`C_n{lD-c!sWz294MqOuZGa_vJD565xai|(@24cp~E2|=7
z30(k&NHPjlMsA4A=sPA_0(J=9-JD!-c)83;bem5DKRvzXuCJ6$3l2`~+_R<qohMFi
z&T5qvD~@QrulF<D433uLKQP)_Tj#g)6$-f$GAA4cPs+irbIFk_RiSX=eYpv%!jh=A
zun|&YHj0Ce`h%Q+9TOvjT8AL0<eH&EOqjGm8mAJ)+CaMTo-MOllF-HemhOnN^o7^r
z<|Czd@pA;=lsisruX%7q^Uyz)zN5OV;Ckt!nNre^Y&<=Cd)gBZH^gbyH2-y4YnjLj
z$5(_cVxwV=uPx73UI5P<4_c+z(hDsUGx3mFmPE5=N(v-a_4l$b+M5U{z%*Gh8C@zl
zO8r*BcLjrCW0IljO#n74^={<{jH1YlAV^{*V>XYupU&t0p?sxup7~Z8FP+Q2UCt^!
zTB+LSd~+bT)w`hESvB!NDVzE_H!eIN`2rY`O2Scif)pGDqRwzgnXFXAZj=~e#h5F#
zG0`lcSWM**4Pa&=rO3@#0cQxAfMqw9Jos7awJaKIV82lwgmVfP<b5N%%ScncT~0rG
z?$|8xV7<^|=FQWZW*ms?B#VH0feRWTI2>FkhlyMta*mu?a0n0}g<x`I#%akQRsYl0
zl1I;LP)Jbw$W(|RU559vR>*M^OqIg`L}RH9`@!_FJRA&sO6nQH+*o^fKw<fjvamV%
zk<#CJ_+QHlN@v}7%b{pp2YbBXQCyhDD~r}Ve-LM`_=(LiUnu=A=r(x%s$j2q=nMo4
zR9##gPJ^0LdQTLFsUk2<k^57$@stQ!n&#x_inmn5<wKMR0Nfshbc*Dv4o)N{%@#^=
zz>Fjxkw1#OJ{UD)#@Tr~f6@R|3W;Z?vS3(?x@&gy$?w@o?Z5oiie(2Uy6hICF;Qll
z^8ND4GTNN~{qicflPZ|Qh#6&@6FVoK69seX6zE|ps-`HoZoVPWWFAu<2lkB)Z92u;
zUkEj!zIsG(SO42?pmL-agNj#@iK?h)DZ0`2=V~c5nZBy`26Jl%s*N({%YIOHwie;k
z)HB<@`iH0XhGA3Pxje_WTQ(kQ5Zg|6z%nZ6*y@R1gULIA3}9kfK6@*e4rSVf@@P^^
zP_!@#V^vAP_6xUVSjjRZYXr~jl4kZ(DI!yrLp3w}M#q%y4Nqg+c&VK#oqPYY>}#p*
z^c$hn?!RwsbN)}u>!y&M<-MK@O@DPf0XHp46*#Gn%}q!k6TaawnXns;c!K$?uwn-z
z59H&q^?{(@(^re4vt-y%W(+{cq`qLuFYMAqWDKW{9MKp0W+p^|PZ936hn>>7_-Ey;
zR#ms?`W{WbL*oJFnhm9_T25j$l=-e5-;St4lyljR18O^$Umk+{ARgQLcWsz5AgU%f
z^Lh)qxw4+mkX9Mb%2=&$+<WCNQTM>U$x41ZV?9D#eLZxlE_pWusqSkt?QVk3`kw3Y
zu^peN%Z6h=JT!oxaKXaXiDY6HN!S61#9}LlIdtF&y!$ij4Ce^-)DD0ndwpiEalQ=j
z%<K6;e#;E~Z2kKB>DqN!e-V=V`ZLE;SGWojto_8^HGR`foz0^QTPL+|`nTRCv%j^u
z=(yIpC9}Vbn8*ozlLwLu(axEkGrOR!d;9b|*RlklWv(~_x&-y&2yGCUif}xvCZu98
zLTDB{vFa1OL~uhGBN&l6M9<V&M<zqbR5z1Pupx**W+pgYVp|0lQ5o73gQ6!uO&nIF
zfsOt18-}_fGM)E5R>l?|G0&`$WQXTRqX@6JKUr22ZAF2tTPFOy755$6{P`v2s9C1$
zZ2V%1m3n^$hdNClKO?Q6w%m(4pV}WVDC2O=H4}E>5I}>V5<wQplBRGpW~5z3)Xf^U
zBJiK+o25|^beE<PMI07fS~|9?A6r>Y0kQT@u&70Af8(}I&7)7@XRUgYRsY!&<(H*-
z^vSYpt*Y7lyR*$ka(m73Pq~@A!4sdo6-QCK0k`P!K=x=+h@liBxGJTT*gQv-VThom
zQlYx0*|HYcOlG}UKy_tM90=%N?4n#7JR|ys4MKr6$@sF&m&1oiFV_kV0<$jEZrM2!
z(qye@=4O^3J8F!_*14BoUvl-UnsrZ?r3>nh&E}`exl<rWa>yo0EB%r&F?&SO7&$kP
zIfKkgx+_yvSRp3IvRO)!P{K{qAyC;dGxR(WAfOgtr{Tu%(^?UB16Ck3)lv(Rfe*6Q
zXbPCC<umjLe8u>#nq=m(m#*#R^0SBQ9Q|Hyr1{7*W!=hObvrjaQ(iEAJKp!A74;+C
zj2=FrM$o;>nvI3%0Y#E?A(#*@Ot}^bNJ4|CHKrJ2in~-#RGy+HWXL&kJm}USE^(M*
zbt^<36SRt%hk57wO>9bGfYu#W5r9|{AUl*JIaK<e;7!yR+Iq>GuNIa58`hMy&8P2$
z%k{QetJ>#1aKciOiB}&2`RqM(d6!ZH1;>=Znn@=+;Kj^x#d`%N1u@TBk~<i#kW>=5
ziO;Cq9dmEGPYP4wO5vhTKL8y9b`)yhS|SN9*n{u~5rY;6IS;lV_u@IKRY}Hi4k2q>
zt8P^DbgQ+Z{qn=7Hd}jI%i9-!Lu*n`YyDKBK-5i5@}bsCb&<Y!Sfm<-AufMAJyx6=
zWv_J5q9!<wfdK_6smv&jDo_B8WRNaRurB`41Bwr4{;nbwa<k<_ypl%YGG`i-Mha$$
zg0W1i`uo#*TZ>9_+Tzyw=B_hZD_cW@&FdGp2HQj1k83`@xV3Znj%%*GmTx$)7s78M
z!~XW*oolAT!T@-1rcim0PBg931`7w<12{Rz%x~iMLA8>jz$2m>Arf9YeS3JiI8fRu
zgB5`SH4qh)gi$l_mjo+nA0vFei&iZXI$Bg#HaZ>dc4(sgz;&h{EomL-nTn)k*V|TA
z%eh;7M(DDlVKel+=RVQ>0K@Yf5ZKkn+~rQ|#Nhlm$1X*GC}??_RCL<PXZJ?8JOv<+
z4wNyOmJ~r5#5YAX^B*)lGFA#74iH<6Y^;KbnyG|s?S$a^#f%70-WF|I4WI{$myjqi
zxp)Lm3O*g}!);Z+sB_V>*0JU2ZCegrsU~o6V*idqdz)MKmw{z(nfqEY-S%VWAKe~2
zZ}l;14Iv}UD7s~K%<9EmVStdV&+1z@1t*wuvlCz};4dgx0+UuTIphS)M(&E!g95FP
zi3l6&i9TZO3!0N7D(K<LusmGmNpFmxkE@WwOVONdpO(0Ax(c02&IBQ4|B(P+ZsP;<
z!^3uvG^|zd>F39{&Mgb7Tx<LCKO0!yRc@^hJmAB&rd(ClPR-E9yFBoEud~iXT{sxG
z3a-W|>Qmz?xSWZK2=k*>Yr+^WDGhhdfDk5et1wAg$d($Fm}-r10f)za*M9DRa`0&_
zVZ%c`F$C;HIS^DP!%;DXk%_?i5Kz@E8NygSX2a`Rt4inX>s!C*?fm3Lt@F!@&9l6!
zdOJ5Zqo=l>>b&~2*2U%a&8=UYaLpB3GIn3FcXEsQN{HCqT^`25aJ%=xjcc!c-Z#`N
zJLY9gW}(#4&PPsK4n{t^G=L{}hy$0320?zbE9<0<P98d}_QKa2ZlQWj4kwlSkaC=2
zaE2BS-CSaOd;`+UN&prp9UPe>Do=vVY_KQrr!$ln^sTb5y)M&N(~?5OON(8V=j{A^
zbL)woS`qCbN87D~dXMs%)s+DVwZnRs@H;HhY|j(6hE_;qRYRGcx1m~tP?`gqnJo@5
zQ&o|F61$8vqhK#-ot}lT1~B*;RiR9h81C8aLSOXUGr201=1}1b#lHM_u+_IfMhYhD
z{L5BnuK7}5tG{O)W1w%mby9QDr^<27OUGNEo>EK7NHkZ1H6Su{ka;dBv8>HVdyY)0
zEhDV;B~>>mZ}2OnHBJzEt+GyhU4#tmB!wkJf(+?O?J|RrQm0Xq2fzqOT_R_TdOwbo
V73VVw0=R!`YoPNVW39V-{s$U$pP2vv

-- 
GitLab