> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.invoice-api.xhub.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.invoice-api.xhub.io/_mcp/server.

# Convert an e-invoice between formats

POST https://service.invoice-api.xhub.io/api/v1/invoice/convert
Content-Type: application/json

Auto-detects and parses the source e-invoice, then regenerates it in the requested target format (`zugferd`, `facturx`, `xrechnung`). A PDF source is opened first: format and country come from its embedded XML; a PDF without embedded XML answers 400 `NO_EMBEDDED_XML`. XRechnung → ZUGFeRD is loss-free (CIUS → EN 16931); the reverse only succeeds when the XRechnung obligations (BT-10, BR-DE-*) are met — otherwise a 422 with the offending rule codes is returned. `zugferd` and `facturx` are the same hybrid PDF/A-3 standard — the seller country picks the flavour (FR/BE → Factur-X, otherwise ZUGFeRD), so both requests yield a PDF with the embedded CII XML. Any fields not carried across are listed in `conversionWarnings`. `warnings` carries every warning of the target generator and of its conformance self-check, in the same shape as `/generate` — among them `SELF_CHECK_INCOMPLETE` when a rulebook could not be applied: the document was then not fully checked against it. The target is written in ZUGFeRD `2.4` / Factur-X `1.08` — the same default as `/generate` — and `appliedFormatOptions` names the version and profile actually written. A profile the target generator cannot write, or one that conflicts with the source's `countrySpecific.facturxProfile`, returns a 400 with a `code`. The profile is sent as `options.zugferdProfile` — `/convert` does not read `formatOptions`. A finding of a newly enforced rule that is still in its warning phase returns 200 with a `SPEC_RULE_PENDING` warning (`rule` or `pendingKey`, `enforceFrom`, `specId`) — as at `/generate`; `options.enforcePending: true` (boolean) rejects it with 422 right away. Findings of reading the source (e.g. a mandate reference outside the CII schema, read anyway) are listed in `sourceErrors`, in the shape of `errors` at `/parse`, only when there are any. Requires BOTH the source `:parse` and the target `:create` entitlement; usage is billed once against the target `:create` key (like generate).

Reference: https://docs.invoice-api.xhub.io/api-reference/invoices/convert

## Authentication

- `Authorization` header (bearer token, required) — API Key authentication. Use `sk_live_*` for production or `sk_test_*` for testing.

## Servers

- `https://service.invoice-api.xhub.io` (Invoice API v1 (production), default)
- `/` (Diese Instanz (lokale Entwicklung))

## Request

### Body (application/json)

This endpoint expects an object.

- `source` (string, required) — The source e-invoice: raw XML (starts with `<`) or base64 of an XML or a hybrid PDF (ZUGFeRD / Factur-X). Format and country are detected from the document.
- `targetFormat` (enum, required) — Target format. `zugferd` and `facturx` both yield the hybrid PDF/A-3 with embedded CII XML; the seller country picks the flavour (FR/BE → Factur-X, otherwise ZUGFeRD). Case-insensitive.
  - Allowed values: `zugferd`, `facturx`, `xrechnung`
- `options` (ApiV1InvoiceConvertPostRequestBodyContentApplicationJsonSchemaOptions, optional) — Conversion options.

## Response

### 200

Converted document (base64) + conversionWarnings + warnings

- `success` (boolean, required) — Whether generation was successful
- `mimeType` (string, required) — MIME type of the document
- `filename` (string, required) — Suggested filename
- `hash` (string, required) — Hex-encoded SHA-256 of the returned document bytes (the base64-decoded `data`). Empty string when no document was produced (422). NOT stable across calls for PDF outputs — the PDF carries a creation timestamp and document ID, so two calls with an identical payload yield two different values. Use it to verify the file you received; use `payloadHash` for idempotent filenames and duplicate detection.
- `data` (string, required) — Base64 encoded document
- `sourceFormat` (string, required) — Detected format of the source document.
- `targetFormat` (string, required) — The target format written (lower case).
- `conversionWarnings` (list of ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaConversionWarningsItems, required) — Fields of the source that the target does not carry — lost when reading the source or when writing the target. Empty when nothing was lost.
- `payloadHash` (string, optional) — Hex-encoded SHA-256 of the canonical JSON of the `invoice` you sent (object keys sorted recursively, undefined members dropped). Identical invoice data → identical value, on every call. Present on 200 and 422 responses. Use it as the key for idempotent file names and to recognise a document you already generated.
- `appliedFormatOptions` (AppliedFormatOptions, optional) — The ZUGFeRD / Factur-X version and profile the document was actually written in — the requested ones, or the defaults (`2.4` / `1.08`, `EN16931`) when none was sent. Absent for formats without a version selector (XRechnung, UBL, …).
- `warnings` (list of ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaWarningsItems, optional) — Warnings of the target generator and of its conformance self-check, in the same shape as `/generate` — for example `SELF_CHECK_INCOMPLETE` (a rulebook could not be applied) or `SPEC_RULE_PENDING` (a finding still in its warning phase). The warnings of reading the source come first, in the same shape as `/parse` — for example `PARTY_COUNTRY_ASSUMED`: a party address had no country, the country of the source format was assumed and written into the target.
- `sourceErrors` (list of ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaSourceErrorsItems, optional) — Findings of reading the source document, in the same shape and order as `errors` at `/parse` — for example `DE_DIRECT_DEBIT_MANDATE_OUTSIDE_SCHEMA`: the mandate reference (BT-89) or the creditor reference (BT-90) stood at a place the CII schema does not allow; the value was read anyway and written into the target. Present only when reading the source found something, on the 200 and on the 422 `CONVERSION_FAILED`.

## Errors

### 400 Bad Request Error

Bad request / source format not detectable / PDF without embedded XML (`NO_EMBEDDED_XML`) / retired profile (`MINIMUM` / `BASIC WL`) / a profile the target generator cannot write (`UNSUPPORTED_FORMAT_PROFILE`, `CONFLICTING_FORMAT_OPTIONS`) / a target the generator of the detected source country does not write (for example an AE PINT source to `xrechnung`; `field: targetFormat`, the message names the formats of that country). This check runs before the entitlement check and costs nothing. A date in the source document that is not a calendar date (e.g. `2026-13-01` in `cbc:IssueDate`) gives `code` `INVALID_DATE` with `field`, as at `/generate`. `TOO_MANY_LINE_ITEMS` — the invoice carries more line items than your plan allows per invoice (the body names the sent `count` and the plan `limit`). Free 25, Starter 100, Premium 1000; Enterprise has no limit. Requests above the absolute ceiling of 5000 items (25000 where large-invoice validation is enabled) are rejected by schema validation with `too_big`. Routes that render a PDF layout (`/generate` for `pdf` or a hybrid format, `/convert` into a hybrid format) stay at 5000 and answer with the same `too_big` body (`maximum: 5000`). The count is read from the PARSED source document, so a large incoming invoice is rejected here even though `/parse` reads it.

- `PostApiV1InvoiceConvertRequestBadRequestError`
  - ErrorResponse: ErrorResponse
  - PostApiV1InvoiceConvertRequestBadRequestError1

### 403 Forbidden Error

Missing parse or create entitlement

- `any`

### 422 Unprocessable Entity Error

Source could not be converted to a conformant target document (`CONVERSION_FAILED`, `complianceErrors` and `errors` name the rules). `sourceErrors` carries the findings of reading the source, as on the 200, when there are any.

- `any`

### 429 Too Many Requests Error

Quota exceeded

- `any`

### 503 Service Unavailable Error

`EMBED_UNAVAILABLE` — the embedding service is not available and the hybrid PDF is larger than 15 MiB. `Retry-After: 60`; nothing is billed. Try again later. Or: `SERVER_BUSY` — too many calls run at the same time on this server or for your organization (large requests count more). `Retry-After: 5`; nothing is billed. Send the call again after that time.

- `error` (string, required) — Error code
- `message` (string, required) — Human-readable error message
- `code` (string, optional) — Machine-readable reason, where one exists — e.g. `UNSUPPORTED_FORMAT_VERSION`, `UNSUPPORTED_FORMAT_PROFILE`, `CONFLICTING_FORMAT_OPTIONS`
- `field` (string, optional) — The request field the error refers to, where one exists

## Types

### ApiV1InvoiceConvertPostRequestBodyContentApplicationJsonSchemaOptions

Conversion options.

- `zugferdProfile` (string, optional) — Profile of the hybrid target (`EN16931`, `BASIC`, `EXTENDED`, `XRECHNUNG`). This is the only field `/convert` reads for the profile — `formatOptions` is not read here. The retired `MINIMUM` and `BASIC WL` return a 400.
- `enforcePending` (boolean, optional) — Reject a finding of a newly enforced rule that is still in its warning phase with 422 right away, instead of 200 with a `SPEC_RULE_PENDING` warning. A non-boolean value returns a 400.

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaConversionWarningsItems

- `field` (string, required) — The field that was not carried across (e.g. `BG-10 (payee)`).
- `reason` (string, required) — Why it was not carried across.

### AppliedFormatOptions

The ZUGFeRD / Factur-X version and profile the document was actually written in — the requested ones, or the defaults (`2.4` / `1.08`, `EN16931`) when none was sent. Absent for formats without a version selector (XRechnung, UBL, …).

- `version` (enum, required) — Version written (the selectable value — patch releases are included)
  - Allowed values: `1.0`, `1.07`, `1.08`, `1.09`, `2.3`, `2.4`, `2.5`
- `profile` (enum, required) — Profile written
  - Allowed values: `MINIMUM`, `BASIC WL`, `BASIC`, `EN16931`, `EXTENDED`, `XRECHNUNG`

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaWarningsItems

- `code` (ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaWarningsItemsCode, required) — Stable house code identifying the check (e.g. `DE_SELLER_CITY_001`, `NL_PAYMENT_MEANS_REQUIRED`, or `SPEC_RULE_FAILED` when a conformance gate objected). Never a standard rule identifier — look those up in `rule`. Safe to match on: it does not change when a rule is re-identified.
- `message` (string, required) — Error message
- `rule` (string, optional) — Identifier of the standard rule this finding violates (e.g. `BR-06`, `BR-DE-5`, `PEPPOL-EN16931-R008`), as published in EN 16931, Peppol BIS or the national CIUS. Present only when a pinned rulebook actually carries that rule and it governs this very check — so you can look it up and read the same statement. Absent means no standard rule covers this finding; the check is then ours alone and `code` names it.
- `field` (string, optional) — Field path (if applicable)
- `maximum` (double, optional) — Only on a `FIELD_TOO_LONG` warning: the limit of `field` — characters for a text field, base64 characters for `attachments[i].content` and `attachments[*].content`, the number of entries for `attachments`.
- `enforceFrom` (string, optional) — Only on a `SPEC_RULE_PENDING` warning: the date (`YYYY-MM-DD`, UTC) from which this finding is rejected with 422. Until then the document is still returned with 200.
- `specId` (string, optional) — Only on a `SPEC_RULE_PENDING` warning: the rulebook the newly enforced rule belongs to (e.g. `en16931-3.0.2-ubl`, `factur-x-1.08-extended`).
- `pendingKey` (string, optional) — Only on a `SPEC_RULE_PENDING` warning whose finding carries no standard rule identifier: a technical key of the finding (not a rule identifier — do not look it up in a rulebook). Stable, so you can recognise the same finding again. Absent when `rule` is present.
- `params` (map from string to string, optional) — The values to phrase this warning in your own language (scalars only) — e.g. `{ format }` on `INVOICE_SERVICE_PERIOD_NOT_REPRESENTABLE`. The keys depend on `code`.
- `lossy` (boolean, optional) — `true`: this warning reports a loss — your document carried something the target format has no element for. Amounts survive (they are spread onto the lines), their representation does not. Absent means the warning is not a loss.
- `substituted` (boolean, optional) — `true`: this warning reports a substitution — the target format requires a field your document did not carry, and it was filled from another value (e.g. the delivery date from the issue date, the delivery party name from the buyer name). The document then states something you did not state. Absent means nothing was substituted.
- `severity` (enum, optional) — `info` is a hint, not a defect of the document — e.g. the reporting duty to NAV (`HU_24H_001`) or SDI (`IT_SDI_001`), or a rule the pinned Schematron flags as information. Absent means `warning`.
  - Allowed values: `warning`, `info`
- `count` (integer, optional) — Only on an `INVOICE_LINES_ABOVE_MODE_LIMIT` warning: the number of lines of your invoice, sub-items at any depth included.
- `limit` (integer, optional) — Only on an `INVOICE_LINES_ABOVE_MODE_LIMIT` warning: the number of lines this server accepts without large-invoice validation. A later release rejects an invoice above it with 400.

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaSourceErrorsItems

- `code` (ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaSourceErrorsItemsCode, required) — Stable house code identifying the check (e.g. `DE_SELLER_CITY_001`, `NL_PAYMENT_MEANS_REQUIRED`, or `SPEC_RULE_FAILED` when a conformance gate objected). Never a standard rule identifier — look those up in `rule`. Safe to match on: it does not change when a rule is re-identified.
- `message` (string, required) — Error message
- `rule` (string, optional) — Identifier of the standard rule this finding violates (e.g. `BR-06`, `BR-DE-5`, `PEPPOL-EN16931-R008`), as published in EN 16931, Peppol BIS or the national CIUS. Present only when a pinned rulebook actually carries that rule and it governs this very check — so you can look it up and read the same statement. Absent means no standard rule covers this finding; the check is then ours alone and `code` names it.
- `field` (string, optional) — Field path (if applicable)
- `maximum` (double, optional) — Only on a `FIELD_TOO_LONG` warning: the limit of `field` — characters for a text field, base64 characters for `attachments[i].content` and `attachments[*].content`, the number of entries for `attachments`.
- `enforceFrom` (string, optional) — Only on a `SPEC_RULE_PENDING` warning: the date (`YYYY-MM-DD`, UTC) from which this finding is rejected with 422. Until then the document is still returned with 200.
- `specId` (string, optional) — Only on a `SPEC_RULE_PENDING` warning: the rulebook the newly enforced rule belongs to (e.g. `en16931-3.0.2-ubl`, `factur-x-1.08-extended`).
- `pendingKey` (string, optional) — Only on a `SPEC_RULE_PENDING` warning whose finding carries no standard rule identifier: a technical key of the finding (not a rule identifier — do not look it up in a rulebook). Stable, so you can recognise the same finding again. Absent when `rule` is present.

### ErrorResponse

- `error` (string, required) — Error code
- `message` (string, required) — Human-readable error message
- `code` (string, optional) — Machine-readable reason, where one exists — e.g. `UNSUPPORTED_FORMAT_VERSION`, `UNSUPPORTED_FORMAT_PROFILE`, `CONFLICTING_FORMAT_OPTIONS`
- `field` (string, optional) — The request field the error refers to, where one exists

### PostApiV1InvoiceConvertRequestBadRequestError1

- `error` ("TOO_MANY_LINE_ITEMS", required) — Error code
- `message` (string, required) — Human-readable message naming the sent count and the plan limit
- `lineItems` (ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaOneOf1LineItems, required)

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaWarningsItemsCode

Stable house code identifying the check (e.g. `DE_SELLER_CITY_001`, `NL_PAYMENT_MEANS_REQUIRED`, or `SPEC_RULE_FAILED` when a conformance gate objected). Never a standard rule identifier — look those up in `rule`. Safe to match on: it does not change when a rule is re-identified.

- enum
  - Allowed values: `DE_AC_001`, `DE_AC_002`, `DE_BIC_INVALID`, `DE_BR_AE_02`, `DE_BR_AE_03`, `DE_BR_DE_16`, `DE_BR_DEX_04`, `DE_BR_DEX_05`, `DE_BR_DEX_06`, `DE_BR_DEX_07`, `DE_BR_DEX_08`, `DE_BR_K_02`, `DE_BR_K_04`, `DE_BR_K_05`, `DE_BR_O_01`, `DE_BR_O_02`, `DE_BR_O_05`, `DE_BUYER_IBAN_001`, `DE_BUYER_IBAN_REQUIRED`, `DE_CREDITOR_ID_INVALID`, `DE_CREDITOR_ID_REQUIRED`, `DE_DLV_001`, `DE_INV_NUM_NOT_SEQUENTIAL`, `DE_INV_NUM_REQUIRED`, `DE_INV_NUM_SPECIAL_CHARS`, `DE_INV_NUM_TOO_LONG`, `DE_KU_001`, `DE_KU_002`, `DE_LW_002`, `DE_MANDATE_ID_REQUIRED`, `DE_MANDATE_ID_TOO_LONG`, `DE_REF_001`, `DE_REF_002`, `DE_SELLER_CONTACT_001`, `DE_SELLER_IBAN_FORMAT`, `DE_SELLER_IBAN_INVALID`, `DE_SEPA_003`, `DE_VAT_001`, `GR_AFM_001`, `GR_AFM_002`, `GR_CREDIT_NOTE_MISSING_MARK`, `GR_GEN_001`, `GR_INV_001`, `GR_INV_002`, `GR_INV_NUM_REQUIRED`, `GR_PDF_001`, `GR_PDF_002`
- string

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaSourceErrorsItemsCode

Stable house code identifying the check (e.g. `DE_SELLER_CITY_001`, `NL_PAYMENT_MEANS_REQUIRED`, or `SPEC_RULE_FAILED` when a conformance gate objected). Never a standard rule identifier — look those up in `rule`. Safe to match on: it does not change when a rule is re-identified.

- enum
  - Allowed values: `DE_AC_001`, `DE_AC_002`, `DE_BIC_INVALID`, `DE_BR_AE_02`, `DE_BR_AE_03`, `DE_BR_DE_16`, `DE_BR_DEX_04`, `DE_BR_DEX_05`, `DE_BR_DEX_06`, `DE_BR_DEX_07`, `DE_BR_DEX_08`, `DE_BR_K_02`, `DE_BR_K_04`, `DE_BR_K_05`, `DE_BR_O_01`, `DE_BR_O_02`, `DE_BR_O_05`, `DE_BUYER_IBAN_001`, `DE_BUYER_IBAN_REQUIRED`, `DE_CREDITOR_ID_INVALID`, `DE_CREDITOR_ID_REQUIRED`, `DE_DLV_001`, `DE_INV_NUM_NOT_SEQUENTIAL`, `DE_INV_NUM_REQUIRED`, `DE_INV_NUM_SPECIAL_CHARS`, `DE_INV_NUM_TOO_LONG`, `DE_KU_001`, `DE_KU_002`, `DE_LW_002`, `DE_MANDATE_ID_REQUIRED`, `DE_MANDATE_ID_TOO_LONG`, `DE_REF_001`, `DE_REF_002`, `DE_SELLER_CONTACT_001`, `DE_SELLER_IBAN_FORMAT`, `DE_SELLER_IBAN_INVALID`, `DE_SEPA_003`, `DE_VAT_001`, `GR_AFM_001`, `GR_AFM_002`, `GR_CREDIT_NOTE_MISSING_MARK`, `GR_GEN_001`, `GR_INV_001`, `GR_INV_002`, `GR_INV_NUM_REQUIRED`, `GR_PDF_001`, `GR_PDF_002`
- string

### ApiV1InvoiceConvertPostResponsesContentApplicationJsonSchemaOneOf1LineItems

- `count` (double, required) — Number of top-level line items in the request (subItems not counted)
- `limit` (double, required) — Line items per invoice allowed by your plan

## Examples

### XRechnung (UBL XML) → ZUGFeRD

**Request**

```json
{
  "source": "PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHVibDpJbnZvaWNlIHhtbG5zOnVibD0idXJuOm9hc2lzOm5hbWVzOnNwZWNpZmljYXRpb246dWJsOnNjaGVtYTp4c2Q6SW52b2ljZS0yIiB4bWxuczpjYWM9InVybjpvYXNpczpuYW1lczpzcGVjaWZpY2F0aW9uOnVibDpzY2hlbWE6eHNkOkNvbW1vbkFnZ3JlZ2F0ZUNvbXBvbmVudHMtMiIgeG1sbnM6Y2JjPSJ1cm46b2FzaXM6bmFtZXM6c3BlY2lmaWNhdGlvbjp1Ymw6c2NoZW1hOnhzZDpDb21tb25CYXNpY0NvbXBvbmVudHMtMiI+CiAgPGNiYzpDdXN0b21pemF0aW9uSUQ+dXJuOmNlbi5ldTplbjE2OTMxOjIwMTcjY29tcGxpYW50I3Vybjp4ZWlua2F1Zi5kZTprb3NpdDp4cmVjaG51bmdfMy4wPC9jYmM6Q3VzdG9taXphdGlvbklEPgogIDxjYmM6UHJvZmlsZUlEPnVybjpmZGM6cGVwcG9sLmV1OjIwMTc6cG9hY2M6YmlsbGluZzowMToxLjA8L2NiYzpQcm9maWxlSUQ+CiAgPGNiYzpJRD5JTlYtMjAyNi0wMDQyPC9jYmM6SUQ+CiAgPGNiYzpJc3N1ZURhdGU+MjAyNi0wMy0yMDwvY2JjOklzc3VlRGF0ZT4KICA8Y2JjOkR1ZURhdGU+MjAyNi0wNC0xOTwvY2JjOkR1ZURhdGU+CiAgPGNiYzpJbnZvaWNlVHlwZUNvZGU+MzgwPC9jYmM6SW52b2ljZVR5cGVDb2RlPgogIDxjYmM6Tm90ZT5WaWVsZW4gRGFuayBmw7xyIElocmVuIEF1ZnRyYWchPC9jYmM6Tm90ZT4KICA8Y2JjOkRvY3VtZW50Q3VycmVuY3lDb2RlPkVVUjwvY2JjOkRvY3VtZW50Q3VycmVuY3lDb2RlPgogIDxjYmM6QnV5ZXJSZWZlcmVuY2U+MDQwMTEwMDAtMTIzNDUtMzQ8L2NiYzpCdXllclJlZmVyZW5jZT4KICA8Y2FjOkFjY291bnRpbmdTdXBwbGllclBhcnR5PgogICAgPGNhYzpQYXJ0eT4KICAgICAgPGNiYzpFbmRwb2ludElEIHNjaGVtZUlEPSJFTSI+YmlsbGluZ0B0ZWNoY29ycC5kZTwvY2JjOkVuZHBvaW50SUQ+CiAgICAgIDxjYWM6UGFydHlOYW1lPgogICAgICAgIDxjYmM6TmFtZT5UZWNoQ29ycCBHbWJIPC9jYmM6TmFtZT4KICAgICAgPC9jYWM6UGFydHlOYW1lPgogICAgICA8Y2FjOlBvc3RhbEFkZHJlc3M+CiAgICAgICAgPGNiYzpTdHJlZXROYW1lPkthbnRzdHJhw59lIDEyPC9jYmM6U3RyZWV0TmFtZT4KICAgICAgICA8Y2JjOkNpdHlOYW1lPkJlcmxpbjwvY2JjOkNpdHlOYW1lPgogICAgICAgIDxjYmM6UG9zdGFsWm9uZT4xMDYyMzwvY2JjOlBvc3RhbFpvbmU+CiAgICAgICAgPGNhYzpDb3VudHJ5PgogICAgICAgICAgPGNiYzpJZGVudGlmaWNhdGlvbkNvZGU+REU8L2NiYzpJZGVudGlmaWNhdGlvbkNvZGU+CiAgICAgICAgPC9jYWM6Q291bnRyeT4KICAgICAgPC9jYWM6UG9zdGFsQWRkcmVzcz4KICAgICAgPGNhYzpQYXJ0eVRheFNjaGVtZT4KICAgICAgICA8Y2JjOkNvbXBhbnlJRD5ERTEzNjY5NTk3NjwvY2JjOkNvbXBhbnlJRD4KICAgICAgICA8Y2FjOlRheFNjaGVtZT4KICAgICAgICAgIDxjYmM6SUQ+VkFUPC9jYmM6SUQ+CiAgICAgICAgPC9jYWM6VGF4U2NoZW1lPgogICAgICA8L2NhYzpQYXJ0eVRheFNjaGVtZT4KICAgICAgPGNhYzpQYXJ0eVRheFNjaGVtZT4KICAgICAgICA8Y2JjOkNvbXBhbnlJRD4yNy8xMjMvNDU2Nzg8L2NiYzpDb21wYW55SUQ+CiAgICAgICAgPGNhYzpUYXhTY2hlbWU+CiAgICAgICAgICA8Y2JjOklEPkZDPC9jYmM6SUQ+CiAgICAgICAgPC9jYWM6VGF4U2NoZW1lPgogICAgICA8L2NhYzpQYXJ0eVRheFNjaGVtZT4KICAgICAgPGNhYzpQYXJ0eUxlZ2FsRW50aXR5PgogICAgICAgIDxjYmM6UmVnaXN0cmF0aW9uTmFtZT5UZWNoQ29ycCBHbWJIPC9jYmM6UmVnaXN0cmF0aW9uTmFtZT4KICAgICAgPC9jYWM6UGFydHlMZWdhbEVudGl0eT4KICAgICAgPGNhYzpDb250YWN0PgogICAgICAgIDxjYmM6TmFtZT5UZWNoQ29ycCBHbWJIPC9jYmM6TmFtZT4KICAgICAgICA8Y2JjOlRlbGVwaG9uZT4rNDkgMzAgMTIzNDU2NzwvY2JjOlRlbGVwaG9uZT4KICAgICAgICA8Y2JjOkVsZWN0cm9uaWNNYWlsPmJpbGxpbmdAdGVjaGNvcnAuZGU8L2NiYzpFbGVjdHJvbmljTWFpbD4KICAgICAgPC9jYWM6Q29udGFjdD4KICAgIDwvY2FjOlBhcnR5PgogIDwvY2FjOkFjY291bnRpbmdTdXBwbGllclBhcnR5PgogIDxjYWM6QWNjb3VudGluZ0N1c3RvbWVyUGFydHk+CiAgICA8Y2FjOlBhcnR5PgogICAgICA8Y2JjOkVuZHBvaW50SUQgc2NoZW1lSUQ9IkVNIj5pbnZvaWNlQG11c3Rlci5kZTwvY2JjOkVuZHBvaW50SUQ+CiAgICAgIDxjYWM6UGFydHlOYW1lPgogICAgICAgIDxjYmM6TmFtZT5NdXN0ZXIgR21iSDwvY2JjOk5hbWU+CiAgICAgIDwvY2FjOlBhcnR5TmFtZT4KICAgICAgPGNhYzpQb3N0YWxBZGRyZXNzPgogICAgICAgIDxjYmM6U3RyZWV0TmFtZT5IYXVwdHN0cmHDn2UgNDI8L2NiYzpTdHJlZXROYW1lPgogICAgICAgIDxjYmM6Q2l0eU5hbWU+TcO8bmNoZW48L2NiYzpDaXR5TmFtZT4KICAgICAgICA8Y2JjOlBvc3RhbFpvbmU+ODAzMzE8L2NiYzpQb3N0YWxab25lPgogICAgICAgIDxjYWM6Q291bnRyeT4KICAgICAgICAgIDxjYmM6SWRlbnRpZmljYXRpb25Db2RlPkRFPC9jYmM6SWRlbnRpZmljYXRpb25Db2RlPgogICAgICAgIDwvY2FjOkNvdW50cnk+CiAgICAgIDwvY2FjOlBvc3RhbEFkZHJlc3M+CiAgICAgIDxjYWM6UGFydHlUYXhTY2hlbWU+CiAgICAgICAgPGNiYzpDb21wYW55SUQ+REU4MTE1Njk4Njk8L2NiYzpDb21wYW55SUQ+CiAgICAgICAgPGNhYzpUYXhTY2hlbWU+CiAgICAgICAgICA8Y2JjOklEPlZBVDwvY2JjOklEPgogICAgICAgIDwvY2FjOlRheFNjaGVtZT4KICAgICAgPC9jYWM6UGFydHlUYXhTY2hlbWU+CiAgICAgIDxjYWM6UGFydHlMZWdhbEVudGl0eT4KICAgICAgICA8Y2JjOlJlZ2lzdHJhdGlvbk5hbWU+TXVzdGVyIEdtYkg8L2NiYzpSZWdpc3RyYXRpb25OYW1lPgogICAgICA8L2NhYzpQYXJ0eUxlZ2FsRW50aXR5PgogICAgPC9jYWM6UGFydHk+CiAgPC9jYWM6QWNjb3VudGluZ0N1c3RvbWVyUGFydHk+CiAgPGNhYzpEZWxpdmVyeT4KICAgIDxjYmM6QWN0dWFsRGVsaXZlcnlEYXRlPjIwMjYtMDMtMjA8L2NiYzpBY3R1YWxEZWxpdmVyeURhdGU+CiAgPC9jYWM6RGVsaXZlcnk+CiAgPGNhYzpQYXltZW50TWVhbnM+CiAgICA8Y2JjOlBheW1lbnRNZWFuc0NvZGU+NTg8L2NiYzpQYXltZW50TWVhbnNDb2RlPgogICAgPGNhYzpQYXllZUZpbmFuY2lhbEFjY291bnQ+CiAgICAgIDxjYmM6SUQ+REU4OTM3MDQwMDQ0MDUzMjAxMzAwMDwvY2JjOklEPgogICAgICA8Y2JjOk5hbWU+VGVjaENvcnAgR21iSDwvY2JjOk5hbWU+CiAgICAgIDxjYWM6RmluYW5jaWFsSW5zdGl0dXRpb25CcmFuY2g+CiAgICAgICAgPGNiYzpJRD5DT0JBREVGRlhYWDwvY2JjOklEPgogICAgICA8L2NhYzpGaW5hbmNpYWxJbnN0aXR1dGlvbkJyYW5jaD4KICAgIDwvY2FjOlBheWVlRmluYW5jaWFsQWNjb3VudD4KICA8L2NhYzpQYXltZW50TWVhbnM+CiAgPGNhYzpQYXltZW50VGVybXM+CiAgICA8Y2JjOk5vdGU+WmFobGJhciBpbm5lcmhhbGIgdm9uIDMwIFRhZ2VuIG9obmUgQWJ6dWc8L2NiYzpOb3RlPgogIDwvY2FjOlBheW1lbnRUZXJtcz4KICA8Y2FjOlRheFRvdGFsPgogICAgPGNiYzpUYXhBbW91bnQgY3VycmVuY3lJRD0iRVVSIj45MTIuMDA8L2NiYzpUYXhBbW91bnQ+CiAgICA8Y2FjOlRheFN1YnRvdGFsPgogICAgICA8Y2JjOlRheGFibGVBbW91bnQgY3VycmVuY3lJRD0iRVVSIj40ODAwLjAwPC9jYmM6VGF4YWJsZUFtb3VudD4KICAgICAgPGNiYzpUYXhBbW91bnQgY3VycmVuY3lJRD0iRVVSIj45MTIuMDA8L2NiYzpUYXhBbW91bnQ+CiAgICAgIDxjYWM6VGF4Q2F0ZWdvcnk+CiAgICAgICAgPGNiYzpJRD5TPC9jYmM6SUQ+CiAgICAgICAgPGNiYzpQZXJjZW50PjE5LjAwPC9jYmM6UGVyY2VudD4KICAgICAgICA8Y2FjOlRheFNjaGVtZT4KICAgICAgICAgIDxjYmM6SUQ+VkFUPC9jYmM6SUQ+CiAgICAgICAgPC9jYWM6VGF4U2NoZW1lPgogICAgICA8L2NhYzpUYXhDYXRlZ29yeT4KICAgIDwvY2FjOlRheFN1YnRvdGFsPgogIDwvY2FjOlRheFRvdGFsPgogIDxjYWM6TGVnYWxNb25ldGFyeVRvdGFsPgogICAgPGNiYzpMaW5lRXh0ZW5zaW9uQW1vdW50IGN1cnJlbmN5SUQ9IkVVUiI+NDgwMC4wMDwvY2JjOkxpbmVFeHRlbnNpb25BbW91bnQ+CiAgICA8Y2JjOlRheEV4Y2x1c2l2ZUFtb3VudCBjdXJyZW5jeUlEPSJFVVIiPjQ4MDAuMDA8L2NiYzpUYXhFeGNsdXNpdmVBbW91bnQ+CiAgICA8Y2JjOlRheEluY2x1c2l2ZUFtb3VudCBjdXJyZW5jeUlEPSJFVVIiPjU3MTIuMDA8L2NiYzpUYXhJbmNsdXNpdmVBbW91bnQ+CiAgICA8Y2JjOlBheWFibGVBbW91bnQgY3VycmVuY3lJRD0iRVVSIj41NzEyLjAwPC9jYmM6UGF5YWJsZUFtb3VudD4KICA8L2NhYzpMZWdhbE1vbmV0YXJ5VG90YWw+CiAgPGNhYzpJbnZvaWNlTGluZT4KICAgIDxjYmM6SUQ+MTwvY2JjOklEPgogICAgPGNiYzpJbnZvaWNlZFF1YW50aXR5IHVuaXRDb2RlPSJIVVIiPjQwPC9jYmM6SW52b2ljZWRRdWFudGl0eT4KICAgIDxjYmM6TGluZUV4dGVuc2lvbkFtb3VudCBjdXJyZW5jeUlEPSJFVVIiPjQ4MDAuMDA8L2NiYzpMaW5lRXh0ZW5zaW9uQW1vdW50PgogICAgPGNhYzpJdGVtPgogICAgICA8Y2JjOkRlc2NyaXB0aW9uPlNvZnR3YXJlIERldmVsb3BtZW50IFNlcnZpY2VzIOKAlCBNYXJjaCAyMDI2PC9jYmM6RGVzY3JpcHRpb24+CiAgICAgIDxjYmM6TmFtZT5Tb2Z0d2FyZSBEZXZlbG9wbWVudCBTZXJ2aWNlcyDigJQgTWFyY2ggMjAyNjwvY2JjOk5hbWU+CiAgICAgIDxjYWM6U2VsbGVyc0l0ZW1JZGVudGlmaWNhdGlvbj4KICAgICAgICA8Y2JjOklEPlNWQy1ERVYtMDAxPC9jYmM6SUQ+CiAgICAgIDwvY2FjOlNlbGxlcnNJdGVtSWRlbnRpZmljYXRpb24+CiAgICAgIDxjYWM6Q2xhc3NpZmllZFRheENhdGVnb3J5PgogICAgICAgIDxjYmM6SUQ+UzwvY2JjOklEPgogICAgICAgIDxjYmM6UGVyY2VudD4xOS4wMDwvY2JjOlBlcmNlbnQ+CiAgICAgICAgPGNhYzpUYXhTY2hlbWU+CiAgICAgICAgICA8Y2JjOklEPlZBVDwvY2JjOklEPgogICAgICAgIDwvY2FjOlRheFNjaGVtZT4KICAgICAgPC9jYWM6Q2xhc3NpZmllZFRheENhdGVnb3J5PgogICAgPC9jYWM6SXRlbT4KICAgIDxjYWM6UHJpY2U+CiAgICAgIDxjYmM6UHJpY2VBbW91bnQgY3VycmVuY3lJRD0iRVVSIj4xMjAuMDA8L2NiYzpQcmljZUFtb3VudD4KICAgIDwvY2FjOlByaWNlPgogIDwvY2FjOkludm9pY2VMaW5lPgo8L3VibDpJbnZvaWNlPg==",
  "targetFormat": "zugferd",
  "options": {
    "zugferdProfile": "EN16931"
  }
}
```

**Response**

```json
{
  "success": true,
  "mimeType": "application/pdf",
  "filename": "INV-2026-0042.pdf",
  "hash": "a1b2c3d4e5f6...",
  "data": "JVBERi0xLjcKJeLjz9MK...",
  "sourceFormat": "XRECHNUNG_CII",
  "targetFormat": "zugferd",
  "conversionWarnings": [
    {
      "field": "string",
      "reason": "string"
    }
  ],
  "payloadHash": "3d80b2995c1f...",
  "appliedFormatOptions": {
    "version": "2.4",
    "profile": "EN16931"
  },
  "warnings": [
    {
      "code": "DE_AC_001",
      "message": "string",
      "rule": "string",
      "field": "string",
      "maximum": 200,
      "enforceFrom": "2026-11-07",
      "specId": "string",
      "pendingKey": "string",
      "params": {},
      "lossy": true,
      "substituted": true,
      "severity": "warning",
      "count": 5200,
      "limit": 5000
    }
  ],
  "sourceErrors": [
    {
      "code": "DE_AC_001",
      "message": "string",
      "rule": "string",
      "field": "string",
      "maximum": 200,
      "enforceFrom": "2026-11-07",
      "specId": "string",
      "pendingKey": "string"
    }
  ]
}
```

**SDK Code**

```python XRechnung (UBL XML) → ZUGFeRD
import requests

url = "https://service.invoice-api.xhub.io/api/v1/invoice/convert"

payload = {
    "source": "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",
    "targetFormat": "zugferd",
    "options": { "zugferdProfile": "EN16931" }
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript XRechnung (UBL XML) → ZUGFeRD
const url = 'https://service.invoice-api.xhub.io/api/v1/invoice/convert';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"source":"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","targetFormat":"zugferd","options":{"zugferdProfile":"EN16931"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go XRechnung (UBL XML) → ZUGFeRD
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://service.invoice-api.xhub.io/api/v1/invoice/convert"

	payload := strings.NewReader("{\n  \"source\": \"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\",\n  \"targetFormat\": \"zugferd\",\n  \"options\": {\n    \"zugferdProfile\": \"EN16931\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby XRechnung (UBL XML) → ZUGFeRD
require 'uri'
require 'net/http'

url = URI("https://service.invoice-api.xhub.io/api/v1/invoice/convert")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"source\": \"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\",\n  \"targetFormat\": \"zugferd\",\n  \"options\": {\n    \"zugferdProfile\": \"EN16931\"\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java XRechnung (UBL XML) → ZUGFeRD
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://service.invoice-api.xhub.io/api/v1/invoice/convert")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"source\": \"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\",\n  \"targetFormat\": \"zugferd\",\n  \"options\": {\n    \"zugferdProfile\": \"EN16931\"\n  }\n}")
  .asString();
```

```php XRechnung (UBL XML) → ZUGFeRD
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://service.invoice-api.xhub.io/api/v1/invoice/convert', [
  'body' => '{
  "source": "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",
  "targetFormat": "zugferd",
  "options": {
    "zugferdProfile": "EN16931"
  }
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp XRechnung (UBL XML) → ZUGFeRD
using RestSharp;

var client = new RestClient("https://service.invoice-api.xhub.io/api/v1/invoice/convert");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"source\": \"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\",\n  \"targetFormat\": \"zugferd\",\n  \"options\": {\n    \"zugferdProfile\": \"EN16931\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift XRechnung (UBL XML) → ZUGFeRD
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "source": "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",
  "targetFormat": "zugferd",
  "options": ["zugferdProfile": "EN16931"]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://service.invoice-api.xhub.io/api/v1/invoice/convert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

### ZUGFeRD (PDF) → XRechnung

**Request**

```json
{
  "source": "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",
  "targetFormat": "xrechnung"
}
```

**Response**

```json
{
  "success": true,
  "mimeType": "application/pdf",
  "filename": "INV-2026-0042.pdf",
  "hash": "a1b2c3d4e5f6...",
  "data": "JVBERi0xLjcKJeLjz9MK...",
  "sourceFormat": "XRECHNUNG_CII",
  "targetFormat": "zugferd",
  "conversionWarnings": [
    {
      "field": "string",
      "reason": "string"
    }
  ],
  "payloadHash": "3d80b2995c1f...",
  "appliedFormatOptions": {
    "version": "2.4",
    "profile": "EN16931"
  },
  "warnings": [
    {
      "code": "DE_AC_001",
      "message": "string",
      "rule": "string",
      "field": "string",
      "maximum": 200,
      "enforceFrom": "2026-11-07",
      "specId": "string",
      "pendingKey": "string",
      "params": {},
      "lossy": true,
      "substituted": true,
      "severity": "warning",
      "count": 5200,
      "limit": 5000
    }
  ],
  "sourceErrors": [
    {
      "code": "DE_AC_001",
      "message": "string",
      "rule": "string",
      "field": "string",
      "maximum": 200,
      "enforceFrom": "2026-11-07",
      "specId": "string",
      "pendingKey": "string"
    }
  ]
}
```

**SDK Code**

```python ZUGFeRD (PDF) → XRechnung
import requests

url = "https://service.invoice-api.xhub.io/api/v1/invoice/convert"

payload = {
    "source": "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",
    "targetFormat": "xrechnung"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript ZUGFeRD (PDF) → XRechnung
const url = 'https://service.invoice-api.xhub.io/api/v1/invoice/convert';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"source":"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","targetFormat":"xrechnung"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go ZUGFeRD (PDF) → XRechnung
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://service.invoice-api.xhub.io/api/v1/invoice/convert"

	payload := strings.NewReader("{\n  \"source\": \"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\",\n  \"targetFormat\": \"xrechnung\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby ZUGFeRD (PDF) → XRechnung
require 'uri'
require 'net/http'

url = URI("https://service.invoice-api.xhub.io/api/v1/invoice/convert")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"source\": \"JVBERi0xLjcKJYGBgYEKCjUgMCBvYmoKPDwKL0xlbmd0aCAyMDg3Ci9GaWx0ZXIgL0ZsYXRlRGVjb2RlCj4+CnN0cmVhbQp4nNVb224byRF951f0D2y5rt3VwEIPu0kM7EOAxH5b7ANNSUEWqwCJgeT3g2rOkCNp1KRstikLGJAcEezTdTldt6GECdMPlDC5EnhNu4cNpf9tfv0tYbrdYPp9g+mXDTuIZktSBYqzJGFwxuo5kUMhL5b+c7d596e7//5zd/f39z+l3ecNAhdXISlsWpFqTgjFncW4KlHJWhICzu/R2v8kfd79a/Pu/WdK//i8uV+DkwkoF/V8BMRWINZRvwoiIQevXEWPkLKCZfOi10HkAmru6EdE5kBY2ctVEKkSWHasj2WEXJztKogMDaxa5QUgApFi38CK3r3/zPHuyY83j4xvnvONf29ozYN/+jjdpzR7bi4O5Mxs6ePD5t1fKHn6eL/59UdEJERkRBREVEQ0RMyIWG4S/pY+/rL588fN3y6CxgyUNXMfjyNiRcQtIn4agsMRsAhm7uLYjVlbgbNL6csg9n076eVu0susn3yTqIIJsaUfp+/dT3q7PF4SBHVhqj3AYUNEYwAogVotTlfQFqlBNgvS6u2eEUkQSadrkCoKAlGt4qf8mTIiFURyRApfsvj8SkCdQIBKHMFY08PGcoYqsrj3x/I3f/6wQfA0Xx9+/musLLHyh8synCqwCGKeJUJ4BYrLDFSVLPcBPeK4i4M4yEQYjJRtDcLboRjPQGRofcB7ihknK0Yo1WxNXd/Iv82hcjHrg7mYf7/wja8Jb14jcMsGgmi57vfIifSkw36J4PllHmPPgFh0yWOHe8957AslcxbpgTz5S+fderXYOYN7PpgWn8OTTewTbc336nTxMBojziCZSP0Z6kfeuUWkT4i0u4mwHXNWzI22dvugpLluvN5O92S6zmaU0coRLJD163UTQdDtxOezji6vF6kZPIyc+3p5SfS6VM1bEj+1wkKxNfHH8RfHAE6ivnsT4n+C+LsWv1YD1XoImJbiDzelDBnJsqTlkTz5ceiA9E3sRhSoCKN0d9QMZbiBPEVwloHg9D6CirsLBRXDhb4/3VQMXFDWXJjsJmUQLdna8RBBVLjteYHT6B3kPBc1u3vw6RTwxUmwvUkVuBRRbcfeRFMtMHxV0DRcS1qg5Fal7W5yO21y5lZ+E+Dd54pqF/yn6QDgSfotPnoLG1Aj8IyWT2xgN1FAuP/tTSrgcxo4c+7dy0aH/ha2alyAvEQc2N3q/cKbZj5+zHidIogSQ2za0sOiJXG8+zx/yE/+0nm3HucP3YbIEtOiKXENUKvLPywbE1dBtbb8w7I5cQ1Uq8s/LBoU1wC1tvoiTx4O6SKh0BwXUAEiyqtxkF2+Cng8zHsL3+/Zh4M4FZF5oqH8hFsHlZPRwbxKpi5KjjDjSejE+vhzIOS44gSI0+FQk5pClAHocwUr6HhaxvtU+Sb94FC8RtunbQGRo4w21zRkCEzGCkWpYN8GuYxZnRGQa6l9FbeTe8XwDuXFAcgMo8HKufTV9yhHuXymlAswuRXpo8BzU+XXrb6IKLv8tA+52C+OQDNBMUeupxFMmuB6TLx5i8iXz1+NDAxLoROogjp3j0sBX43uMnolKLVUpSRFwRB9tUDzaWKeIEgNzws63Yfa7Vi4vL0b4yzZLrIRkn2d3Cy4mukltoqjslF7sPjtEIaK+IZMJcaMOmiO3jmmJ8QOWC36ql0Ud0cvPaEpBFsLiw+iVy9QapWIiqWRtEs93j2/u7u60NpPLoPK1y9zactTBsvyinxxSA3PqEJWj4O4h2gOH8MfIlCLqCaCrhaMxZUjtrgCBx46bBlBhX0V/CzGAC3P6+kt9IgdLioS7X/L77U60bCuMGvMgemqz3Fo/nYPM2TdumC34yYLFLKi6glQc2e4HFtETY63C5Bjcgl2wRjF7KHTqCcJa4wTTebbkA5AxBmKVfPcRdTa+WNCf9KYnEL22pfJ/U0MxlGxGHGaOgOB6JBAjZkkYotKYBfZVEQ+2NIAIFWhFGanLhIJ998+th1p3Beiuia9IYPVqqumtdu745wcD9RnTPa6SS5dQC2TD8IqiDGYNGKUR4DNI1rpAplGWAYxZXWg2KP31bOdWyTPqy3DOImhaqYT4hG6SQZSKOqBU219rhGtjWaFKkW/r+mfUhvl4dr0D9ebpBnEcyQqkwDmbldEtM12tlPUe17Td/C26mHsr7exFj/WKWIYN/ZXnEFLXZ0KEDtywBVH/kqFbMhEXbBzRjOCIwSkYCXtAhg0VVwd8n7g8eTuI48LdQVjDiqkcgWqjZS6hjMH3fmYWdCArBsdaqWinkr1mC3Cl4ImdRCpfmTtBqsOKZwsYXmJ4v7qjKqEV+0GlCIKqFRs1vry6nMZtyV9NkYOMd+cXbvKkcjdAk4kSANMxKNZxlWoi2JgZB9TNeySpS+HQ9k0kATVBvXHeb0dqJeefWwXtnFw4Sl++HQcK5zL/vHaOjrh+lHiqoiy+4J8u9NEL5lBbOos2r4IdLj3rAjUfnPcMwTqgCp6NuHMgpLbx4IacWAKWKEg6Q7Ib/RYgeRIw/J3EV50sO7dc2DpCDJaxeud7MfnCTpYvtG5Hn1QyVYL9QxY7o5l/QHnKHMBb2XSHohIDIPmWn8mD+svsBFkjB5ol3dkH1U0k9HJZOK6m86TeN2OaY5WBHFT7QK82qHyqg30aCDUnfc1plD5sHZSAa/G8UD2y2AO6uY5u53UOz+usHx0YfrczEAXvfLZVObvykjJnqCWJt3bgVJFKJpL6eKImOv+qOVZyK3vGhfN10hBEYN7iRLBKsDmE/MzNRMftxLn1FXYF+0eAfw/6qE33gplbmRzdHJlYW0KZW5kb2JqCgoxNyAwIG9iago8PAovTGVuZ3RoIDkzODYKL0ZpbHRlciAvRmxhdGVEZWNvZGUKPj4Kc3RyZWFtCnicjXoJeBPXtf+5dxZZljfZlg0IMyMGyYC8y5Y3bMubbGO82yAZL5LlFbwhFhOW2EBYInYIa7ATsvxTso5JAJu2KTSEkqZpm3RPk7bvvbbfvy196fby3gNbet+dkQwkbb+amdHce+5y7jnn/s45d9jk3twFShgDCiJ6u5ydIP9dAABzb2+X01/+CACW9A+5AuXPAeDAgHPrsFxEjwMA79qyifeXJwDAO+zu8tPxBQD83Z7+x7rlMrMOYNFTvQObtsplwQuAQrqHewbksj4YIHwfIACgqNMfpn2ntD18xX+BNkii3vqTOon8/qb1tfB7C2Z/pEwN2ggASsDy5ACKfm8IgHLlvQXelcpUuddDf8UAkAZdcAH+igQ0jF5AL6C/4hr8HP42/jlVTJ2h/kZzdBv9AbOA2cWcZ15n/j+bxHaz29hx9pZikWJE8eOghUGVQUeDPgj6q1KhTFTmK7+h/Fj5cXBCsDW4Png0eFzFqFaoelVPq95RfR6yOmRfyPMhfwoNDb0SFhS2Kmxb2O2wz8LjwldKKyyGS6CBLaAADBGQDOcB8G/DNwMFiAXQMCJEk5vOgWgA393A7XX4/osRQQPg+wMAfB1uwDiMw3U4A2cgXirtg6/BK3AdzsMP4E04h34Fp6XSJaSC3fA6PAuH4BRMwyWIhZNwHrbDQbgIv5Dqx+Gqf5QXYB88B6/AVfgGXIfdcATOw3NwGX4Ax+EcvAZvwtvoPTQrjV0GZ2HcP/45eAYugQi7YC8chKfgElyB6xALteCCrbAT9sBBOAZn4Tl4HX4Iv0AG2A5PwkkYhxfhLfowRFh8j6fvbNqR7+O25/q4bXk+7rFcC7d1hY8bWZHHbclQcJtzfNymnB5uY3YN5872cRvMPm446wNuKMvHDWa2cQOZH3D9mT5ufWYity5zHteX7uN603xcT9oHXLfJx3Wl+rjOFB/nSnmF60jp4ZxJPs6RNMa1J/u4tuSTXGuij2tJ8HFrjT6uefkHnH25j7MtD+XWLPNxq5f6uKb4JVxjfCLXoG/j6vU+rk7/Cldr8HE1hjGueomPqxKM3CrhFa5S8HErhdVchWDkyhf7uDLex1l5N1eq83ElOjdXzPm4okUnucJFPs4S5+MKFvq4vNyTlt9zK3LTuZyMMC7b7OayzDVcpnkxZ844yZnSLFxqiptLTlrJGZdbuPj5NGfQL+X0Ju38liULIjmBWTC/ZfF8H6fj8zg+a15MCzcvkVsU6+PiYnzcwhgFpzXNX7h2XnrMwrULyFssedPMz4/5f81RqZFN6tSIpkh7hD00PaSJSaebQuy0naPbaRxOj9Kf0VR4W1iTKj24SZHONqFUaAqzB9tZ+yiLktkadoilCth2dpSlwJ4MKBmG4DOglOlBTVQ6bgqyYzuH2zEOx6P4M0xRFguDptAxsdFYOaXw1VeKytq1Ijog6hvI01LXLLIHRGhqXmubROiIfe/hwxBXVCkea7BdpgDiiuyTGBfX2SZp6oh94yYwgtFoJL8bN20mBVKUK8ib/EQP/SMViFyEhKTGcuWXXwNvXyLJJenv0TaBv3nAQicAtZQRgQIFqCAcoiAWoFCjyzCpBbVOLaijNLoMhASkRiZEKWe3aM34ljl2dgv2zL6Rg+ukByOazfdqGVG695nNTMu9Q8wm+QYKLgGw9YwILKggArSWUKwIY1RB7hAaFNgNxrS0NGNamjo7JbXBhJAJCcgUpRYQ4eC3X0Wfok++NiuemN38ovYGQ794gxHvt9LPk6lmDszeIZPiLAAMT/ruUp/SOUCDFjSWYKRm3fMoSqUiEySnGdNSUrvUJrUQlRkdhoXFSThDbVJHL8KmNLOZEq5PLqhK7HxuU82eNtO0LrvMsMWTd4+y3L+NfoH7r+2rTHKc78fXZ0sq2jNj1j4NCNp9d6mv0dWQAbEWlRbC0pap3LFhCjKZMU2dnZ2SWphuMMQnURnp+diUFhOjEdINBmExy2qiF+HYRVgjsWEwZJj8PFDC+vXNx7vM2X1Prd091TGd0VVR1W7UmDtW7X21MXfoXPvR293X6dpN2at6zIhbWpqtiUpf2VlscdvSWs61JjZlJZcvXZQcv1i9qHHbmrItTcndzzWvsuuXWgGD0ncXr2EKgQINRFmUwWqVm8YUK4mGSIYoPMqkjo6JMaWZM2NZVuIM189euz292MzFmkJRTFlaibuYzjlyBCnuv5+ZFamkzihCzaP9xLu1+u5Sf6WrwQicJaInCrFRkZEwX6VwLwFVQCTJpvbWlNRSInlZJouwRqPL0GUkYWFxGNYQuUizh2FcveHaHmv1vpfXbrrUnz7zUzxEmwbbC9atWm5sGFnVccA0LPSPR1cduuFe/sT3jq2sPXrT3XAmrPyALaP3dMfyqv3dObXF9gzHCsBwGACfpauBhhiYbwlllUomWuGmWDcOdpNdkZamNqWkFqoFtUmvIAoKwwqFrDJknX4LrUGxyxZYOkri2fT4+lFbdDp1bGaYzmFfZail5a7cRR2v7q1UAoJtvrv0p8wtMBL7Ni5fzszXRFDuJYxSWv53TJHZydI8stKJCCLNZmIXscKj6zdnqnUZ9KfaLd97fu8vn7dXnf748Ev/Nhp5M7TqyHDXU47k3MFzrT1j5VHeN/CPZv+w1FXR+iZCz294HsGbrRu/vatmd81Kz63tGx+/fbBcSI1B1gsAFBwEYB+TpKCFNNBZ1MsicdLixbEqinWrFAFZqE0mtUltCsiDis+nJC2pBbVku2FYr/hSFSq9Li5cjbIGX+hfNdaWPp3da60fLIrDX9+Bsgee7VmzvzXlenZPWV6bRUe5ZsbpHG8INfT1Q1XGlmPds8n4TlN3ck73njiD/YWxyqT2p7pns/F7a7uWLa9oAwoO+e7SOhaAhgWQDPMtYboYhduoUrnpYDeArEBivw0mtUJA8pZKwvEZMpeKjHRZtgoNEW0+PnQ94mXqVFb/ha6ep9cVhIQUrDvf3T2xPuv6oqL+GmtPeaIqomL72sr1xTwL9z76CBs0W957qr5s39sjLVvf3l9Wc+L945q6owMFKXU9mX+27qrP6z9CpHsJgAmaw1CtJVTJBlEYswrsZoMIk8T4ZTsj+8wPrLRj5u6im3T7DSp/fBy7A/gJCAyYw2H4GlAQNElhkAxHo8vAYd55+NrZs4BhwHeX+j1dDVrIgWUWjTFhUfyinJzw+FSVe978YLeSCZeQKI1Ih1ieOpIgUpesM5bVCAFQUkfHxGoEgyEqVrJBGQDIHqQkBCDNKJWpu9Lalzu9YsMzHVuu9ERF3QyL4PFXa3Y0JiS1ljTtrqJqFPk9h22DL64tGXtraBonWtrTU6oTc9ytmbUXH/MGmbclRPDrMbN7flplmqkxtbw31b68uzVv9fHmNXvtSUTPXgfNSfb5BT2TjRr2QM+SXf4TPatlPSPr9Zfx77LWX+jqmRgsDAkpGrjQ3T3Rn3l9cdngKknP0eVb11YOlC2m1t37nPl49q6k6JLdV93DX1K0d9a6vbJg8CjBOWKP69hIyCZYImjNQTjYHYTcWpV//wSwJCDeaCLTRZQmWkbU+ExZvhnpsl/I8OsDlUxl9x6zDVzqiE+Lt/b2WV2vD5u3uhYsF/Zaq50JpGa5eXna6szSjnTadv8rtG3wxaGs8lObatfXVZsy19Q2u6vcpys0usinY8wptanZa+qat9StaKmzZxfbk/J3AYYMALqOESULjbOEUQoFizGjDHGrGFqCqMjs5GxTJPFbxOGbKISIjdbd/zU+dOY5bx0enUa/PztA/dn7yWwbddtvqW0AtIm5BRzMt4RERIRoGDfFcTiEjKg2GdPSklNSu8h4D9aqEdJl4CPCUSDaNFOGPrU543Pddc5dlun+Hz7tudVnrHRlebedPbsXR3U8OZBdvtlauW/N9u885nxjs2XP7sfzvHaCCRt8d+lw5hZEAA8pYAGdJSI0L0+fqNHQGYmMO44OlX1PZHZypH9tfkUEnLJizifLiomao8s8fpFOh2//cM+ej7YVb7/Uve+jx65bH29o2l5SvHP16h3FZ4e/uX3nO4ND39yx85tD0/mDFRUDeXnkmY88e6cdjum9a4735/a8NVy302rdWdc4UlAwgu+ve7mj4+V1o5fb2i7vrhguzBuuqhzOzx8GDBt9d2kVcwtiIZn4bCPLRTJuliyJyJboSd4GVMCdUpQ6PYmS9rE6ehFFNgKtsmy9tK7xyIba5YVbL/U1HR2uWX49NqF4jbmou3RJbFLRmoyS7tLF1KpfvPn56eLlrad/fPQXb/7lpGWZ/eQPvZuRtuPUuiIudd2r272/6Tg9YNWlD70BWIp97jG3YCHkwnJLjHbhIo4GiIuLNCUnLwt1h4YqIxkJfpJJ5EXALzKWCF82/b9jBoKgyZDcSiA0M/nlLbVG+59wjhZkDa+uHimeHn5/3xO3B03rXx6ZmDh4tc9YuvMrrvaXxsqni3c2NW0vXnWwjTIVbihrdOfkDa8autrfeu1A5s7+0qVDRYN7CrsnBrPMPWecq9wFuVvXrt2cTfb0KwD4Z8wUsBByhaXdiBivUd7GTIYe/2zaexCrmal75fSHB166Az6fHGkyt1kDye6RAorgGACEXqNwqhqha6vBmJ5OItLDANSv/F53viU0En/J36r/ia9F1uk3Flchy6aLHbVja1OupzmspRvqEqmGmdceONG2U+tnc/G3mnqIEw1EYn+kqyGe7Mi4+fOjFW6aBqXqgT5SUrsIxJv8og5shUfiEJxfNFzOiMzIjY3brozk5o5c2Tb69gAjMoVDK5s2FsctLN74hLk9z/Fi1+rT7wwsH3jn9OqeyeHi/sLiDU+WLS/zDBfPrZ8lHnIBxFpC1DgmWOGmYC70Cqw+6u8u/vCX187CPWBhxvoP1n4NAG2V/HDIFcBuJPleeQq09abfvQKS/LWSEUFJYncqiFEqsBszQQGwIKaqFgj8mZCaUX5zVrh5E/+KdKdd98cZ8f55uhswxAHQs4wItDwOsEFIid1U0MPjdEnZDIoVEB5Fr304+5tT3ovoUsap2d9+Sv+AsHM/8VOZp72+u3QccxnMJH4IS5i3eHECBbQ7wb/fiQ8n0jJpHooVCagSpbGsIiDBwAYi4eUSqiAi4uTtTaak2q5MS2fpEr7IVVK1t4ntCKvaeLR2YKI7NWfjV4a2iJty8s+hCObyePszt7t/7DzVnZ5q31ZR+Fh7ZuVjZWj4ma7k+idfae5568Aq53O3u9ecR0v/dITw3OnzUv/D3IIswjNkxeh0WSFGxp0V8gjPXRKjARcd4DzTFGB1LheIDqMEAaVGPXunf2liTWeWpUtiuTh/oMlE2wo3XWjpn+hKzXFfGtopDqXH1Z3/7ytRTzef/UbXL13ne82mlh0Vhds6slOb+nMbLj5R03joNXvv1YPVnV/5aKh4w+9++JITENT57tIbmVuQDZwlPNgQbk5NNSrd86Kjw6lAmpgcyN6S8D/O3qiHkMqfvk1yVft7+l/fUWTdc3X4hd9svWE9MtCzrzC+YVfzjrc2Z5fv++rGrneeab+R07XL2nWoAg2baiw5i/ia7ieamo6tX7HzPXf9aEX+upKkSot5vrB6/f4m+7HuzKzhFwcq11t1Wb2AocV3l86gq0EDRoi4tlCtcsez/owzJbXhYUFKvGXOWUlA+C0lY1c3uK/tKinZdcXtvrqrZNpQtalq1cZV8fFVG6tWbawyYHXs5vdONTScem9z7OY75OXOodi6o4MFBYNH62Jrjw5ZLENHyd7OA8DvsxpQgwY0FlW0hnWHssiNpK0tMeQU1DLEx0p5FctqYkkkcHG66dlBvpAL1mQsyG1K+O3sVfrVzRcbgoLOMHRyc5H7yBGgwQjA/IDOAQaCIRw0sMQSrVCBmopmlREhKJh1R4bRyuC5o4M0yb90IZMCCVRUrIBQlAkJFNl38egZFLNtnvc3Ixf/qN7pvU2H/fuU9/aOH6AIbov303k3qG2TMyN0zsyOq3TOzB5q5/3bdM7Mqe9RB98gq7wEQH+LEWEBLJLOLRCKCwsPX4TdcRK2pBEEJzbu1GXqiLuSBK3L0AXUQEAEm7zfxyjpwvf7Vmx6qd87hcqP3n2lpeW1v3qfuTm+54/P2He+s9860f7m7MSaidnL7X6YwqADoL4qnWc8wBfWTQUFfxFfpHWiH6OlX/du3/FzlKrZ4d36EnVSWknvc3QOIHJ2jlZLSBxyZQ6A/ci4+roMq2S9ZFv3MbeAgnCIuKYIncuTv+sPvql0olFNNImS0OrrYZnmjOzsDHMmnUOmQ1xifn6iMS+PoMMxfJC5QwlfzGKYO/fuUMLZs8BAn+8PzB7mXVCDABlQBpUgWNQVaZVMbsmytNgwnmHcaTL+3UqLuJXml3VDIDjTBMLqzEB4ljEXUP8LbaJQPOor39fStre8bG9r6/7yg0K52WxdLJSZM8oEnPOAtK9CIpUtFsoyM8qED2aze/G36MqqhgP19QcaqurIz0RVUr3JVJ9UldxgMjXM1FbXk9p6+efZ6qQGk6k+uTqZtKGq7h8pot2SjHx/Q1vgI1BB8JuU7KRTUkcekvGx3KysXHJ3JBcWJidZLESH7ZKvuAUCxIORRPPLjfEGg2I+iboUD2JeE1FaV+A8hxx4yWAm70c5SsTS8Z5Gl0El5wymRWdtyx+5faym+ti7Wws250WnDufU7lqbktqyyz0biv86G3ogMuLZsIiK4z87jqpOfHyiQh12MSIqvffZfu9k/7O96VTszp3e+zt2AII476coAz6BYAiapAGSPyCJQDRxVDgjA2W0NPTxCbGfnFr7fklFwlqn+SyJq/b6/ob66VLaAMv+C0ABy3yfUxuBgjUA9DbJryshlCA3HRKiDMVuBUWybMnfEtPwn+VI+QYSMpBJ0Ogy6G0zBur6zKYR6uDW+pmW8fFxev+9T44x/MQEYEgDoM/4M3eNJRgoiiTtcuDw4GRIR5Lvd97GJ+4/Le/OiQmgwOltov5CV0MULIN80FrCU/Qqd84ChTuMDXcDOVsjepCyVpP6iwmgGgXgOlZDcu05tDabMzPkIJ5a+ZVN39ufdeZ4qrPkVIVtrGx2ae7QhKv73Pr8EFXB+vM9zvHh3GldaX9ly9ayaFViWa911UCpjs65/+nRb/cJDdbBekvRrjYq3/uuZsf7J2rK9r+9tWXk7X1l9U+9d1BTd6Q/r3qs8s+ZPXUpBQNHgSLxDLPIH8+EwjJLNK1QBIeGsqAKCcFBFHYz2B/aEM+enW1S+880yHktQvEmRBE53fIuehcbR9Fxbxw1ihN/OfNdJvneh5Lcknfdq8XaiQliw3YA6k06x6/ThZZQSacs0SmLI6HA9I8USr0580f8+Wz6BvytLfWzcWfPnqW4mYoD1OVz58i4hwHoUAnpyLhxFjWrUDEhQSxWshS4gyU0SzMWyAmJWlArcXwmikKZCJVdp2q8S73/E/51VJvtfdyBZmRc9OZ4Fd7/fPffUef925h+cXYNYLjo+xvaIdlNOMnNMFaEqtxAzrKNn343OSW1kBKoR6CyL/SlMDYAlox4/w+05t5rEljm5/tPkJg5C19oiQhwTVPYHRyQ+xzTOoTikcz1upt0yuzz3ld5BOh3SbO/2YiPyDY6a/c+8120APP3avHtczMX/d7sACPCfEgh+p2/zIDj45HBEBYSjt0Ltdow/1aSNWxSm+RYWBcv+TYCm+TcSnJu0SyroPxOTyJk6qQzbZbFovcoRjUNO0rzdjq8v76JPh0Wt1tanh+o9q4aQGUtu0pydnR4/4jR1mV9J6pGfoovPZ3VV1HblXzvPxkxsf1Ed/PxltDZpeOWzbV1WyxPZym7LrQd+KqT5PuEf+tD3yriLGGq4GA2PEyB3ZQfCOQvCcl+syFnbQTdyE1bZ2bjb1KZsy78v7OK8fFxJkqS0xFy+iahQTWcoNPpq9L4EVcUkilC8m1TxG2iUjIMORJJn1mAa6ep0NdfR5fuf0IvITh+3neXTmJEWEZ4ilcqcdz8+VGhbgbLZyv+LDgltTA+SqfRUcQ3PQjW402PBPPI9VQF/sPs5YSl22u7nt2wItv92mbb+PaqYDGkfHN1UbdVb6jst7a24ysG/KNXvJtil5aOvTXUJ+4pT+06010/nJ20etuq0i221DTCWTUAbZC+vURZlIhhWNpN+eNzySEjAekyaMPsi+/g5pm7jNh7b4qZd5bEAgPeXPZ7zBkohF6It0RGMkxZfZTb2dmpam2Ni1uxLAWSTSTClywlgJZ+LIsyUaw/zjdLaEYpWHIiMeeLcKY50mxeQsQQyQSaSqeOSTgzn37IS7F36BTHuf7SnsL5QaaTJjZqqWneirbCJbRimfPCTw8+/qNLj5WyiqSeie+P2a7kGawftp69f3NshULR9NQHCJ05f+/rO7Lvf64IW1qYEGfJN0cWxVY0d6VXDJZolcqshr4t+f07spri2iyZjqp09N8t0+dbU1t21+Llsz+uaEmNLBg62Xjq3jf3WauOfXv2xOn77z5ZtnyJOzGh4Zn/QItffQEtvvtKS+PEr72/8lkHV8XH5Xday+t3NBoLNl109V0+1GEqMLoWpmQNvyh7berPD51lh+poOkblNqoUbiQdZUt24v9K9S+4h8zrL8/Oy9sw7nzgEdrHN+Rd11n7K1tGyqNDEst6rKsGrLqPmKR7gNX/ghMABFt9d+mfMrcgnvhD+RsGSB8xvmMyfkfKQP/ZuYF0RjbvRvjY798Y+/B0Xd25n+5/8dej4TfCVh3a4DzpSktsOeLcfqISfc/z8ahj8n/PHT/3v5cdO35+rPtk7coDb286uf5rR+qqTwROWl+W/i8BsVs1q8JulrBhVJse8ajSVzy/U6V+f+PEnw8/9dnBbzSe6ew608iIM/EvfDww8PEL1M9m4t1PlZc/5SaWPeK7ywQzt6Q8KsqijGcXqin/6IGTNSyP/tB3mkhqLoUN5FVMcP35n+zd9ZPx1U0XfrJr70+ebvhGRvfJ1ubjPVlZfceb2050pVNsywvemasOx1VEv9DyAqKuORzXvLM+aNt954DVeuDO7rY97z1ptT75nuwF6OSHvyMoWBYHq1QUdksuQApz/N+RHuAaWneTEmY34c9m1X7k3zAxgY9OTACCHAD6u4wIKlhgCVPQwYhWUpIkH/Eo5JsrOaYQEEIG1Iba/s2bjn7yH95z3nP/gX7iTWfE2Y9w0mzyrA5nz34L/xJ/SKTYRf8Zf8bcBhXEQthblFIZroFkk4mw1/CQ69M/9N6VlWHOyjJnZKE35nzhWn/KsMz/Sx2CTnYGLtF98CStg3Y8AUo6H1rxVTiMZgCYjbBNQcNB+nE4xFyBS9gMBroZBkiZ/iYcokchgx6FNnoUNtCjsJEehXZ6FF6RxlsPh+kUaKV74TBOhGukPzMP4uhR2EuPQid9A+roY9CC70AeS4GRscAl6legQ3+BC+gvcIQtgGPMJ9CHF8IxwgsZG52EOPQn2Eu/D2vo25BGPw5OJgviqP8BOx0Gh3EEXGQYuESTNR2CS7QHqulROE+PQrUiGQboPdDOZMBWJgUOMbtghO6HSwwNOZQduiwrz509c3r/vr1P7Nm9a2z08Z07tm97bOvIls2bNro3DA8NDvSvX9fX29Pd1enqcDra21pb1jbbbWtWNzU21NXWVFetqlxZUV5mXcpFBCsT0KQquFgo7gpOTIDJYFWxUKxKTEAiWywqpEqxxsiLljqbrrLeVlqi1ensWkEnWkRaX0puZ6fHFSDYExNAVBSLLBmiskGorGu28aUeh0RMTKhsfKQk07PmaP43ERc32kSrUavTPVQuk8pzxfIvkCsCZIEXodbj6ZwESt9oEy3aSSS9MMUH7WKN0S6IHUZBJ9i67IkJk0EQomt0FCcmTIYE3hBfJuJifioCOqYiwLVGmEL+t2abyDu67eWJCZOA9aJ0NUxBhrBVfneIvIvnRVYvdNTaPDoROQStv1xvE3Qicmo9OkHH2+1TvpsLSWtBl5gwiaFoUkAH6iYt6EBDs20qAkT+QKPtMka42FFkn1yCDtTZpngQLVItJrWkkhR4UoBKVFlvu4yDpPbaKQuIYxKVliqksmsKgVQnN5q2AALXFJbrIuSJDGSiaQtgcE3RMsUSaE2DaypIrhuTWy/1tw4C11QEoUwDRiBKRPlvEohmLMGMJciitITgUKydRKTqMmMJuo4AlAjeDEGhSDs5hovrpeopNDaptGinpJHkqutoDJSI1I3N1U1hIM0eGshulxd6oOnBCpqabW+GQCjSSk+73V5E/hITSidxtVF4YNZ1NhHrSydRtdFh1wqkSOlL+U6PS7Q02Ehbh1Zn1+rs9pLEBGJdvE3o0gr2yehoz3CpWGMUJp2swWH0yEZGTEuIyElMECl9hUuwOkgLkdaLtL5CpPSu1bxD7HAYRUrPR1g9VmIHTtIaYiYxpZ9EtB7lQ/4kwmyIGCx0FYkqoWiOUgAFMoUlFIVQJKIYWc6lQik/r8/jEjp4XrTU2nq03XanyLtEi+AUaaFIO0lDkU5nn4cSE/jSSag2liQmVNZNWmqMtWttvLR83uMp4ScttMHpcpJyiU4r6Dx+klBSYn+oRynvES1Ol0Mr6ErtUuPEBKGU95QKTr5TtNSJtJ4XoUEg/yWqmfRpbLZ5QjqFTqHBNmmxeJy8y6nlXXatx+6SZFySmIASEyAxgXmAR344wmSX613dItZP8dDhEDrkCrIfv1jX88WKbpF3PFwnrCTTSb9I+vWsFEo7Rawnt7NTpIrrbTq+0y4bCdRKSPEPG6GHGvEipZcG90TkBkrIXxIpvUjpPWLPo8XeuaKV3A6R1ifJtiLSBmJrNp24Tiv2241zTZziWAfv4SOEHIE8pM5l5HaIjL5MHHM5CRyxxPZERr9SHHPxtg6tzi7SBqvDE7C4xASRNszNJA4aHxlS4EXUaNOJWE+WI47V8g4773DwIqqz6XRaXmTqbDq+20mMiwBtrbye2mYbWbXT02DTiUC2jFZUNNr4bmeXoNPqSJ1dkqukGZHWrxShwSaC1uMRPCKyi7Teync7eZExiKyhgvwwBnHYKDi7RN5B5uOdXVJfK++RpUNG05YKOruzS8R6SZa0gZ/C0EEeLo/g5MVWh1Fk9GpPpIfP9timoTUCRNrgWu0wCjo+grfykqqdWkFHhFBBSvbcxAS5oVJPGoqMXroM4oBxslWhf1AjXUNGuXGQNCovQr1NrA00UUgXoxc3GEUcmyVCPVk8qm+2EeGzEiqIjL7CwYuWeptOS3rzIm6UyLS/fwXpqg0oTO6GY7MkoCWOUBfgVyXzK0/KSleIdCn1YpBeHDSKdGyWn6wgy3lgBANGwrTch5LYlRdA6clUxJORS1qIw1+g9V3SmmQHyBPA1IkWp0Bu7ZTvRq1NtDgEctvtZPogaSLSQxraIw9MxMUS4t8ThX8m+VKRq0JawsPVwdKlkHgmNHlJzKOC90tvynfDLzlJbpLoCIXS7/fvSv++69KKvXZjp9yL9SM4z7sIcrvqpPhirU2nE3QKLe8SsZ53OXmxwehxyWvbL0t1pYwOxCqRVQCryAReIAZEEMoReQAvIqFcxEI5mnsTLmNAQUIW+VEKWZMYKUQUQ8AoIjTE4xI8Lken7JprbSJkaVeQYIiVFK2UdLuFQFOjjdHSZGeJrEEckVVq8D+3GOfoI2RPKgKSDCI0zxyRCFLqTKRt8D+3GIP+bi9P0L82WZBfm6JSohE0MgT986koWUErZXWtxPLIK2WcWEn2tMdDoG2yNYzs0BCDWmQMkWKwPltU6LP9XCr14g6jCLVk6iCpRio22shCVH616VVisD5CVOpvyqatEhX6CJHV39TKrUSVfsrnk/iWW8tCGDFKciCXn+zvLVvniNEuBuut5HaIQXoruf07SeXfpSFfQH3/8LJOlY8ShbnBiKMX5kYkpUkUom+00VrGLgYb+AiR0udI8jSoRIWBj/DkTCKFwd+AIQ2wPsfjUQXwn8D/NIAFpHAS7J4vVog7jYkJHk9Q6N+nBH2xNlSq9ms5dO6XVPq3Q3CxqCom8QvxTUpiAEkio9/5rh9zpHDiIcFIVWQrPlw7j8hexr1ggsqBvgG5dUtb2t/3C7WNtp0irSeSepd4EhHp3xUZg47cWiI6aTZi40NGf2i7k2h3tzTcbiPP9zlFuhgJTtHhIO+8kyetgwwSyHk8Tr7P6ZRwSEpc5iUmVNaTeLih2SZE8GgFrJDTH8GfWdh4kdbbVmiz7SJyTPl+t5DgleT8ysjd6OH5CLWIHB4+UkROca8kXj9NkOoEXmQN/lZkBXuNHo/cjnAfgj2VDSJtIDlYcJY2mOR1gZTqrPGfkXnSX0TCFPQKW3VEFlPQJjymE3GxIPJ8i01HXP0UVC20ezy8h/cIJH9aTVIb12qJiKYgZSGJD0gsM9c+bqFdeKQiZCExPOeU75WFJFV6MO+uuXlHhMekN09g4ino+bvTEpNDa2XDE2mDtJYpyBJBkBmhDf65PS2eZkEn6KZgEZnezw8phy0kzSSGThKG/g8pYvHLCmVuZHN0cmVhbQplbmRvYmoKCjIwIDAgb2JqCjw8Ci9MZW5ndGggMzc3Ci9GaWx0ZXIgL0ZsYXRlRGVjb2RlCj4+CnN0cmVhbQp4nF1SPW+DMBDd+RUe0yHC2IakEkKqyMLQD5VmqjoQfI6QikHGGfLvK/zcNOoAT3fv3n350ro5NHbwLH1zU9+SZ2aw2tEyXVxP7ETnwSaZYHrofbTCvx+7OUnr5tBeF09jY83EyjJhLH2n87B4d2WbJz2d6GH1vTpNbrBntjnWbfC0l3n+ppGsZzypKqbJJGn93M0v3UgsDdJto8n6wV+3x7r9i/i4zsREsDO01E+alrnryXX2TEnJOedVaYwxVUJW/6Oj6GTuo1nJucoq9nln6gC7HCABKkARnSKAiIIdOOgKcGqPkOjMoINAmwASOSUEEgKJEImyEjrTIwsBwBUQqEcAuLyALgK4PApQtgC3Q9cKTezgLGKhVSd4Bk5gaIEK3dqg4B0iBUB2KBQhLitWiLODK07QwalgqbizWAhOCUvGLNhLgdQKE+UIURhMYYZ8X32tz//70OslrFd7u7L+4hxZH047XNZ6U4Ol2/XP07yqwvcDU8zRhwplbmRzdHJlYW0KZW5kb2JqCgoyMSAwIG9iago8PAovTGVuZ3RoIDcyMDgKL0ZpbHRlciAvRmxhdGVEZWNvZGUKPj4Kc3RyZWFtCnicjXkJeFPXlfC59y2yLG/yiiPDe+IhGZB3eZUXni3b4AXvNpI3JMuyzQ4CbLPakEBAMSRhSZqFbFMyk6ZJrkNoHJJ0SEoKSZN22qTzdZL+mXzTdJvQNuZv+08wtv7vvicZZ2mn4t337jnn3nvOPfds1+zy7faCFsaBgZghr7sf1N+jAJA/NOR1B+GfAcCyzds8IfivANC9xT26XQVRCwCInuFdYhD2AcDcdp83SMfbAfCPBzfvGVBhrgwg7q6hLbtGVXjRmwDw0sD2wS0qnDwMEH0UEAAwzAPr7/9gen10yV/AEKZQr3yuz6DfX/c8F33TPPtzrTtsJwBoAavMATSb5yIAtFtvmufKtG511oJfOgDkwAhcQeGoAu1HF7AB+/CPGcxEMW7mbeYLNoktZQfYPewJ9gR7meM5IzfOvc/zvJc/y7+hidd4NETzjua3YRC2KmwibCLsY61Ou0K7RXtW+6YidTo8AwkwDBrAEAOZ8DAA/k30bmAA8QAJHIF42lgbxAMErofanCvwF45AAkDgMwB4HS7DOTgHl+BBeBBSFegovAbPwiV4GN6HC/AQ+gQeUKBnkA4Ow/PwBEzAWXgFnoEkOA0Pwz64B56EjxX8OfhecJVvw1F4Cp6F78G/wiU4DCfhYXgKXoT34X54CJ6DC/B99DaaVdZeDd+Cc8H1H4LH4RkgcAiOwD1wBp6Bi3AJkqAJPDAKB+BOuAfug2/BU/A8fAAfIzPsg+NwGs7BeXiJPQExcuBg7oH2/WUBYV9xQNhbGhD2FMvCaElAGCkpFYbzNMJuW0DYZRsUdhY1Cr6igLAjPyBsL3xP2FYYELYW9ApbCt4TNhcEhE0F6cLGgkXChtyAMJQTEAZz3hMGrAHBmx0Q+rMCgifrWaEva1BwZwQEV8a4sD4zIPRmnhZ60gNCd1pA6LIEhM6V7wnOlQHBsTJSWLciIHQsDwjtqcuEttR0odXUK7SYAkKz6VmhyRwQGs3jQsOygLBWsgj10rNCnRQQaqUOoUayCGuWBoTVYkCoFn1ClTEgVBp9gl0ICBVLTgvlSwKCvDggrEoJCKXFp+X/FkqKcwVbXpRQlO8TCvMbhYL8pUJ+3mnBmiML2Vk+ITOjVrCslIXUZFYwm5YLJqshuXvZHbGCxN2R3L00OSAYxVJBLFyU2C0sSheWJAWExYkBISVRIxisySldi3ITU7ruoL0k2ktILkt8ujMuO7Zdnx3THuuMcUbmRrRzuWx7hJN1Cux6FkezY+yfWCa6N6pdlxversnl21E2tEc5w528c4xHmXwjv41nVvHr+TGeAWcmoEzYBn8CRpsb1s7k4vYwJ3YKeD3G0XgM/wkzjCxzaArdR9osdVOaQEsd0TZ1EXSMmFrpW27uJPwxAu2dXY5JhE46j5w4AYsr6sh9rY4XGYDFFc5JjO3NjkmWOencuQssYLFY6Hfnrt0UoKCKoD31jRb8owhEH0pCymAV+fVuqPc1kgopvy+PCf0WAQ/9AMxyjgADGtBBNMRBEkB5gjHPqpf0Rr2kj0sw5iEkIT2yIkY7O2zIx1fyk2aHsX/2BRtuVl4cyc+/2cQRpR3Nz+e6b05wu9QGGM4AsP/JEVgEi0GSYw13aJmICJ0OUpIXhfkSAfvAkmPJyYktyrTGJhVlZbcacxITE+J5XqMxphpz8vPzcs1myaiXjMiEEs5g5un/PtB0yls/l41RV+doafHe3rn/mWFWzX0HaVAXR/p/cO+Wp3cIpqvytur6HaUzi/BJNHswEhA0B66z4WwDWECQYwbjEB8XGwvJOo1vGehUKfRFmdb1PVnZVUszcF5ebhm25izBCQnGPGNeBpaWRuGEhPgl2JqTX5AUhbFz9I2719Te9dKGXc/vLLr1Gu7Ama6mkp4yY2r95qp1x3LGpO1PxjeevLxt+diPTzc0nHhz9+BzceW+aqvr7rblq/d0WqvlfdYeGyBoCFxnptkGSIVkOWJxcnK8xseyoFWkysm05GTmZGV7c/LzC6xRWLotW2JikrRALpxfvL6Y+RUe/eHo/qm9paV7p/YdvrID/4rJW19R48pPSixwfTezrWDDd73tD1zZLm1/64H2wZf3lLhtxd4Ddsl+0FMMgGEvAHOTB2DgDkiSI/Q4MVzjY8CHw33UkHL01qzscmoaqWWMoh69pKcntDQKo42f/7ABlW57dH3Tod7sG+kdZeWeCiMPN4GHW1Vo+/dPrE1zP7Jttga/0tC9IrdzeJ4f2wAsGCBZjozFSTqG9+k0IYZ6a4ijlfkGlpumf7W4Aa3a8Zi7Yawr60Z6+6qyPvsypvXWc6xtTod2XvbXWVwPbZutwq81dKUGeY4ErjNfsDaFZ4IcjvS8bxHD6BR9Z+ZYqLb1Vr0UVxAf1LfeqlcPPp/R3Pg0vjmr/9EtjXetz51OyZKXDY5YA0zxzA/RJ3jLy3fXZbge3oRfnbUXN2bFN/uBgZa5djaCbYA4WAFlYJCjs0w6n+0OjS+Kj/YBT3eZQ/9lZZdb9fE8Ly01m1MLEhMpuzw9CtlhUkIUQ4UpCNpgfkFeBkN1wGR/tP/jU2UPnsjcYZtY27pbni0o2f6Ed8PZ/qKoyLKBs17P4ztKpheXri9v31IcwZvKeuVyV+kS1jbz6al3Ny1rlE9WyaXD7Uza3LsJ+350urH+xA9G7LsuT9S3nHn7noTacXfBmn31F4sH1loK+w4DgprAdeYq2wB5kCTrDBCVs0LnS4rShFyoKCu7PNdsTs1gQlaaICmnxfNU8qQlOEFRq9mcZ1U3gj9a5u3ruHeg0Lb5EdexHwxNWzrKy5pTE3LWVey/4Crd9WT/6Xc3/J61e/PLHRnItKw4Kz4ur36osmK4M7frEbelLjO1zGSwSEui7mgec68ZWZe14bzT3ihJpcDAfgB+f9C+csAo61fE4oylS79mZVZqaLctLeT8t02N03wdh7ZM/yq5pXDzkxtr93VlT2euK6lcX5KCH99RsOmxgdY7u7NuZHaUFLbbFjO9t55SDJI6gaX7voHZTPxaYyc1SCa574Uj9emuhzbPVuLXWzqlFTW9gOEAAH5FkTuR+gWv1XLxGh/DzzvivCdaTRpVGo0qYSLaOv0b1IETrcllvauWMgXLm/c1J1qZzbfOsDbNJywrlXcXsQPP31UbFgjAWODP6GG2mTVD0hcAGkgK3GTagIGmwHUW8wAs3AGZVAIjyybqfBadxocgaLOZIU/5B4w05sZHsytsWx/z9J0ZKouMLBs66+k7t9U2bbD1lLdsLNXxprKusoru4pRPOPEmYP0/YIqAoUPx5AYwgA1WyAmWtCWpS2y26NRsnW9RcrhPy0Urdqn4F00x+lhqn171/Hg+QQqZqD4+MSlBMpvjkpR4Gq+6X0ES3Y7ZrGwPf7yyXS7uyPq8bPjbA3tf35IQ///0cRJ+zj5QuXT52oLabTJuiLD1HGrb+HRv+djU8H9g1taWsbzSIo/25rec3z8n1O62xKTuQTfOJmdVWiyrl5c6l29a0due335/d8eRzkzAEB64jndzdmAgAeJkbbhe52MxQ2MEzQNZ2TQ5x1n1qngFSWqwyMObZx8j04tzpeSMKLSk0do6voa1EYK0M7/LyYvlmSltVPHRbRDMxsuCGT9BDmcw5jXYx4fRA1UjrZdy0Et6dtmsqXrm6tWr7O9pZgdMPQndx/07MBANMS9rIudt8cdUML2kZ3LzrTk0d0tLzejgjZiacrm2Vi6vYW0zP2RtKKWgpqYgf80amluoHLnzlYdBjtTwPA7X6Rjsw4owOXorzcbqwoiWIbTdO8Osnd2Kfz1rUOuN2TuvXsUHrl0LBFRL4N7jzRAJ9KKStg0g8mUGN0Uj9E8dYMnNpberCQB0UMluERfnk1qQycEbaqqi46h8P+EIJNEYhxGKiojGvqigZKpcxryF1Yk+VLbg1+eOoH2evUVFez1zP5vBK575w/79f8DCVXlHTdWe2plFHBn56dET72wGTPM+W8I2QAJYIOblFL3Ol8oH42hWduvtAiSYhoJOVUbzv5r3GyoPvTo88urhysrDl5Tv9BK5v8rukQWh3FNZ6ZGXYH3S7rfPtraefXt30u5rtHNtIqnmcF9hYd/hmqQ1h/qLivoP0R0fDfwZPQGzoIPwC4xaemRljyw40aP15RV1dRXl9aOFa9cWFtbXh+zpPEcgGbJghRyfvMKMU1OR2azoK8VgUFSWo7eqWrPqrYr/lS+o7CRFdzQp8LyGMRbcVmqBUckVPI+/N3cCo8qWnSWFO53/dwb9cfT1I1Ud/3Kga65mB6pu9xXlbF439xuMthWNPlK/57/wqZezeypquldSXWe4zwx0nu3VzmZeLfJWrt5Q9HIV2/do5z2vuYGBA4HrbNaCGBdlTNT4LDqdjw33gRLkgkdh1WskFDqG1Dy1DNGETkGToB7LgemkD5kLeZvODXof8NIY5z3bP/T4xrzpRQU9VXJ3mcRrize327sLknm4+dvf4tSE0bfPNNdPvLnbPvzGifqm0+/cm1BzqK8orb7fdrHuQF2++3DQV/iNHAEedBBDfQVrojhdmC+CBY1SPtPwlqOntbMVISuSkDVOLyFaw9/8BJ1H3/5k9oMXZ7f93HSTg3+f4cjMOdZDnedW7lwKdSP0KT3/usB19iR3BYpAkKPDzdH52dkWrW9RfHw0EyqLMkPZPQP/7ezOhNSUZw2VTKcMlfvWD71weE3dPd/f+dRnY1+U7ut1DtvMDcNNe14aLak9/q+7N/zo6b6ZbMduu2OkBI2kV9sKFouNG453Ok9tKh59Z++abXJ+t22FvSgnadm6rfc4uk8PFhTufG7X6v5VS3I6gVXscO2Cm8xiOUoXHs5HR2mwj8FKfAtqKXNBjAvFFXbtrZnVM0zbrIuBWZiPebNPXLmCXdeuAQPNAMwbrA0Y0EIkpMiRbESENpL3aRiGx7Gwipp2MCXTxRGS8pBVSjDmMW/c+pCJma14FF96omc2+vLly/jTW92PMI9fvkzP9sCci81UsvxXLJAG16jbFqjk+f/dAtHW6Y/xBwWbHh3wPji0KjJy1dAD/QOPbc6fTinpKZe7y5ZqImyb2sq7i1OYjTf/yn04+4eE4bfPttT5X93ePPLmRH3j/T+6P6HuUF+Bpd5b/Oaa0dWFHlrxbQpcZ29wV8BCrc+yciWXnBDD+JZxWiVWvWulmZXKqJZ1NDzF5ud/7X6iJFS9MY+9Idz5iyePf3q+s/XR/zNx4bNx/V8jqsa86+5al2Z1Tzg6tpbHzv0U/272gxXu6p6XEPO09zxiXuoZ+dnd9aNVFeNTw4Ojl8bLF6+IQ8ZXqeWOBa6zRRyBFfTUU7VavDg5OS7Sx2FWDaXUbBX5UuOMCUaGShaqQTNwqlKDlmFVkzzadLmR0c++vHzp6NrBf/KVFA9f2Nv1z3c18de1pQP2UkfxYmN5n9zRhc9n4l++O/dIfKp97OIOLzlal7fhEe9qT66leatd3thgyaGSLZ2bQr3wOwiHsEkWIPO9rGyvJp7XpNIQjnrRQNuhlIyU33134BfVdendQ6suAoJKADZP8fY4WYs4jmd9TEQwI9L8jyRkzGPzZi/N4arZKI7cdfMD9vPLlNt3qEFxF4GHiIs860PKLNV0uDwTA9Nzj+Ai7uLNOvbBPVf/jc5oAWDLuCsg0HtnTExEAudjBAFHhGJ2TmbQnKl+5ism9WipAjWILbuVhT5s6DRZ+6qbtxZO7/rlI6fe3ZTWvLVi7q3Ll89jzjE+mF21obR6X+PY+wf6XtpXefTIkcq58zR3DAWusxJ3BZIgk+7VwguxnI+PXLBX9YyY0FWcYfS5ajWZoI9fwtBjYyX7wRc2d5webk2vPPjC5nWnd7emTcen2mozCh0lQvzyorr0IkfJEqblj89OP1Cd1nv2347/8bt/OFtp6T79k7lBlLvuSE+xwdL70Ja5dx1H15empLkfBQa6A9dZK3cFJEgFC7WqlZZUs1mTHMv5QEMFDFaTtPDxhuowek1UQ2JSsB6nUmLlTyg0ENTnD2Qsth0s3/feA62tD/10rGx38eK0wdy1+zrSMzv2DN26wUTduvFiTMy1qJg19/78JGo99dGZWn3U29GxGT2nvHPP9p9wrsR/OX587s/Hj9P6HIA9qUQ8GpEEOVqJSJhGJBwMePq/FZTYk7cimV/eOvQvzOHzPbdKaMBruPnZ45z+2jXA9C/M7Eu3a0RgGFojIrX4mb91GBOMefizL/CbM3vUWuzaNUAwELjOfsZdgVQ6U40SoISJd62Wd+nMv/sXDCVbfH4z4thfyd2/eLi59dGPjj//+ZHom+H2wxs6xjssqc0HHZuOVKEP7/3PcfeFuXN7zs1ddI3/16neo6vl/Rd37dt6Yby68s5gzuSSFtaXWj7sy8VuUaY1aGVqLqA1HNtxa6Zshr3zJtN09Sp2hf6qBRg87K+ZNO490EESRL3EaLXRCZBptdKw0rqgRjIt6HsqC4sqK4sKK9FPKosKq6oKiyo5Z7bdnp1lt2cGv8wE9HNaOMPWQDObDg2sD/ayu2AvuxNG2OPQwi6BGv5/YD/+AA7gFBhjD0MT2wQd+DsQzrbAGRwO+9khOKPgwmECzQJwBjjD+qEBF8FRLhLOsGNwgA/AGfYXUMcegTMsD80Ux+2ETewEjKF3YCk7AZXsBHyHnYAWdgKG6DrsBHSz70MT+wmkc0UwwD0HZ5hT4JFrH/rWgw/cffTIXXcePjQ+dvDA/n1794yODO/etdO3Y/u2rVs2b9q4YWhwwNvv6XO71vf2dHd1Oh3rOtrbWpubGhvW1tfV1qxZXb1ciAnXpqFJXbhdsnvD09NgMlxnl+y69DREeDvRKEjSaBGJ3Oww1rU4qioNRqPTIBmJTFhTFW3ufr8nRHCmpwHR2AlPl6hrleqaOx1ild+lENPT6tq+BKn0wnlasEewvc1Bqi0Go3EBvFqB58E1XyHXhMiSSKDJ7++fBMbU5iCyYRIpHc5+j5M0WpwS6bNIRsnhdaanTYZBhLHNZU9Pm4wI9ZC4mmC7OBUDfVMx4FknTaFgr9NBRNeAc0162iRgE1Ge1inIk0bVvouIHlEkvEnqa3L4jQS5JEMQbnFIRoLcBr9RMopO51TgjRQ6WjKmp01iqJiU0LHmSRkda+10TMUAEY+1OV7ECNtdFc7JZehYs2NKBCIrWEyxFEkBkQJQh+paHC/iMGW8YUoGMq5QWQWhwJ4pBApOHfSKDAg8U1jFxaiMzJTRKzL1tClWpcih0Sx4psJU3Lg6enlwdBh4pmIo5RXACIhCVH+TQE9GDufkMFkrR+BIbJhEFPUiJ4ddQgBaBBciUCQyTI5je4uCnkLjk1rZMKWspKIuoXHQIoobn8dNYaDDFizkdKobPdZ+ewftnY4LERCJDMrb6XRW0F96WtUkbrBIt8262UGwqWoSNVhcToNEQcZUJfb7PURuddCxLoPRaTA6nZXpadS6RIfkNUjOyfh4//Yq0miRJt282WXxq0ZGTUuKsaWnEcZU45GqXXQEYU2ENdUQxuTpEF2kz2UhjEmMqfZXUztw09GQOIkZ0yRiTagMyiYR5iNIuOStIDqpYp6yClapFJ5SNFIFQYmqnqukKnHRBr9H6hNFIjc5Bg0DTjcRPUSW3ISVKgyTLFQYjc5FKD1NrJqEBktlelpd86TcaGnqcojK9kW/v1KclFmz2+OmcKXRIBn9QZJUWelcMKNK9BPZ7XEZJGOVUxmcniZVif4qyS32E7mZsCaRQKtE/6umk85p63T4I/qlfqnVMSnLfrfocRtEj9Pgd3oUHVemp6H0NEhP427Ho2A4wtTLTZ4Bgk1TIvS5pD4VQf3xq7jBryIGiOhaiJNqKTvli5Svv1aq6ifYRJu7nzD2FodR7HeqRgJNSqT4m4PQgkEiYUzK4v6Y4hCEghBhTIQx+cngl8GhebCaNhdhTRmqrRDWTG3NYSQbDWSz0zI/xE3G+0S/GCPZJPpSJq+mzUU402oy7nHTcMRT2yOcqZaMe0RHn8HoJKy52uUPWVx6GmHN85zIVsuXlpREgtocRoJNdDtkvEl0OUWXSySo2WE0GkTCNTuM4oCbGhcNtE3qfpo6HXTXbn+rw0iAuoyBaNoc4oDbKxkNRopzKnpVToawploCrQ4CBr9f8hPkJKypWhxwi4QzE95cQz+cmWy3SG4vEV2Un+j2KnOrRb+qHbqaoUoyOt1egk2KLlmzOIWhj748fsktkh6XhXAmvT/WLxb5Ha9ATwwQ1uzpcFkkoxgjVovKUbsNkpEqoYZCzuL0NHWg1kQHEs6kPGayxTLZozHdxijPNos6OExZVSTQ4iBNoSEa5eFMZIeF4KRCAi1086il00GVzytRgXCmGpdI5BaH0UBniwS3KWQ2OL+GTjWEDkydhpMKlUBLE6ExJK9OlVdlyitPhPJoTSTMRLZaCJtUGCRr6HZuG8EWCxVancMo4qobYEyUFc1k9FE24goCrMmr7ElNgCINmEYiuyXaDFOBy00OIrsk2pxOyj5MYURnKEv71YWpunhK/CZVBDmpj44+NcoWFqLDlUejyExp6pa4Lys+qL2pwOWg5hS9KaqjFMZ0d9Arg37nNZAhp6VfncUHI7goemjk9jQr9UWXw2iUjBqD6CHYJHrcImm1+D3q3u5WtVqrRgdqlahagmrChTqQCASkNYi+QCRIWkOwtAbN96QXMaAwqZB+tFLhJEYaghJpMIqJjPB7JL/H1a+m5iYHgUJDCS2GeOWgtcrZDtPQ1ObgDCz1LMKbyYh6pObge9gyTx+hPqkJaTKM0vzzRKpIZTLVtjn4HraEfeMsf9g/xiwseJpEq9BoNDKH/X1WjHpAtepx1WJ15Vo1TtRSn/b7aWib7ImiHhph1hPOHEvCTUVEYyoKSqk1kf0WAk2UdZiCUcA2B92ILnhsJh0JN8UQrekN1bR1RGOKIbzpDYM6iuhMU4GAIrc6WlXCiEXRA32C5OBs1TpHLE4SbqqmzUXCTNW0BT1JF/TSiK9E/eDy6plqv0yU5hejiV6aX5FCkyjC1OZgDZyThJvFGMKYbIo+zTqiMYsxftsk0piDAzg6AJtsfr8uFP9p+H8FQAalnASn/6sIcsCSnub3h0V+MyXsq9hIBR085cj5L0UG3SHcTnR2Wr/Q3KSlBpBBONOBt4IxRyknFihGQVFXXIhdRHWvxr1wGpVDc0N6G1BcOjj3K9g2xwHCmqim3qKZhCDTW4QzG2kzUNUp3KiNb7MES9sD9HQPK8sdtojiBjdh7UhyE5eL9kW3SEeHmZUg5/e7xQ1utxKHlIvLovS0uhZaD7d2OqQYEZVAiXr9kYI3C4dIWJOjxFDkJMg1Ffh9Co1XSvJbTVubXxRj9AS5/GIsQW5yRFFvkCYpOEkkvDk4iu7giMXvV8dR6SOwv66VsGZ6BwsvNITTe13oSvUty98ji3Q+QdIUDEmjRqqLKeiV9hgJtktEFLsdRprqp2BtitPvF/2iX6L3pw56tfF0KEQ0BVkptD6gtcz8+MUpTulLiIgUanjuqcCzKfSqdJvvoXm+I9IepecPMZ6CwW9kS00OdamGR1izspcpKCQgqYKw5iBvf7e/UzJKxilYQtkH5aFwVAodpgh0mgr0/wEVneT5CmVuZHN0cmVhbQplbmRvYmoKCjI0IDAgb2JqCjw8Ci9MZW5ndGggMzMwCi9GaWx0ZXIgL0ZsYXRlRGVjb2RlCj4+CnN0cmVhbQp4nF1STW+DMAy98yt87A4VKR+lkxDSRC8c9qGxnqYdQuKgSCNEIT3w7yfirJ12gKdn+8VPttO2O3dGe0jf3Cx69KC0kQ6X+eoEwoCjNskhA6mFjyz8xcRtkrbduV8Xj1Nn1Ax1nQCk7zjqxbsVdk9yHvBhi706iU6bEXaXtg+R/mrtN05oPLCkaUCiStL2mdsXPiGkQbrvJBqv/bq/tP294mO1CFngB7IkZomL5QIdNyMmNWOMNbVSSjUJGvkvHUWD+lsNNWPZ0MDnnZZZgGNJkBOcCDBAFXMVsVgiiZE85xQsCA6UI1YICj4SOwbAWEm5LHohOCoKUvciGiQoqG1JJgpyVlH3iuQF+cwpl1GHPAbJWR5dk4BvkDFOlSU9VkbzsdGp+dqG/DvObd7bbdx2Ka7OofHhgML+ts1pg7cbs7PdVOH7AbpWsbMKZW5kc3RyZWFtCmVuZG9iagoKMjUgMCBvYmoKPDwKL04gMwovTGVuZ3RoIDQ4MAo+PgpzdHJlYW0KAAAB4GxjbXMEIAAAbW50clJHQiBYWVogB+IAAwAUAAkADgAdYWNzcE1TRlQAAAAAc2F3c2N0cmwAAAAAAAAAAAAAAAAAAPbWAAEAAAAA0y1oYW5keem/Vlo+AbaDI4VVRvdPqgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKZGVzYwAAAPwAAAAkY3BydAAAASAAAAAid3RwdAAAAUQAAAAUY2hhZAAAAVgAAAAsclhZWgAAAYQAAAAUZ1hZWgAAAZgAAAAUYlhZWgAAAawAAAAUclRSQwAAAcAAAAAgZ1RSQwAAAcAAAAAgYlRSQwAAAcAAAAAgbWx1YwAAAAAAAAABAAAADGVuVVMAAAAIAAAAHABzAFIARwBCbWx1YwAAAAAAAAABAAAADGVuVVMAAAAGAAAAHABDAEMAMAAAWFlaIAAAAAAAAPbWAAEAAAAA0y1zZjMyAAAAAAABDD8AAAXd///zJgAAB5AAAP2S///7of///aIAAAPcAADAcVhZWiAAAAAAAABvoAAAOPIAAAOPWFlaIAAAAAAAAGKWAAC3iQAAGNpYWVogAAAAAAAAJKAAAA+FAAC2xHBhcmEAAAAAAAMAAAACZmkAAPKnAAANWQAAE9AAAApbCmVuZHN0cmVhbQplbmRvYmoKCjI3IDAgb2JqCjw8Ci9UeXBlIC9NZXRhZGF0YQovU3VidHlwZSAvWE1MCi9MZW5ndGggNzAyCj4+CnN0cmVhbQo8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlIenJlU3pOVGN6a2M5ZCI/Pjx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iPjxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6cGRmYWlkPSJodHRwOi8vd3d3LmFpaW0ub3JnL3BkZmEvbnMvaWQvIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1sbnM6cGRmPSJodHRwOi8vbnMuYWRvYmUuY29tL3BkZi8xLjMvIj48cGRmYWlkOnBhcnQ+MzwvcGRmYWlkOnBhcnQ+PHBkZmFpZDpjb25mb3JtYW5jZT5CPC9wZGZhaWQ6Y29uZm9ybWFuY2U+PHhtcDpDcmVhdG9yVG9vbD54aHViaW8tc2FhcyBwZGYtYmFja2VuZDwveG1wOkNyZWF0b3JUb29sPjx4bXA6Q3JlYXRlRGF0ZT4yMDI2LTExLTA1VDE2OjE4OjQ5WjwveG1wOkNyZWF0ZURhdGU+PHhtcDpNb2RpZnlEYXRlPjIwMjYtMTEtMDVUMTY6MTg6NDlaPC94bXA6TW9kaWZ5RGF0ZT48cGRmOlByb2R1Y2VyPnhodWJpby1zYWFzIHBkZi1iYWNrZW5kPC9wZGY6UHJvZHVjZXI+PC9yZGY6RGVzY3JpcHRpb24+PC9yZGY6UkRGPjwveDp4bXBtZXRhPjw/eHBhY2tldCBlbmQ9InciPz4KZW5kc3RyZWFtCmVuZG9iagoKMjggMCBvYmoKPDwKL1R5cGUgL0VtYmVkZGVkRmlsZQovU3VidHlwZSAvdGV4dCMyRnhtbAovUGFyYW1zIDw8Ci9TaXplIDYzMTkKL0NyZWF0aW9uRGF0ZSAoRDoyMDI2MTEwNTE2MTg1MFopCi9Nb2REYXRlIChEOjIwMjYxMTA1MTYxODUwWikKPj4KL0xlbmd0aCA2MzE5Cj4+CnN0cmVhbQo8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/Pgo8cnNtOkNyb3NzSW5kdXN0cnlJbnZvaWNlIHhtbG5zOnJzbT0idXJuOnVuOnVuZWNlOnVuY2VmYWN0OmRhdGE6c3RhbmRhcmQ6Q3Jvc3NJbmR1c3RyeUludm9pY2U6MTAwIiB4bWxuczpxZHQ9InVybjp1bjp1bmVjZTp1bmNlZmFjdDpkYXRhOnN0YW5kYXJkOlF1YWxpZmllZERhdGFUeXBlOjEwMCIgeG1sbnM6cmFtPSJ1cm46dW46dW5lY2U6dW5jZWZhY3Q6ZGF0YTpzdGFuZGFyZDpSZXVzYWJsZUFnZ3JlZ2F0ZUJ1c2luZXNzSW5mb3JtYXRpb25FbnRpdHk6MTAwIiB4bWxuczp1ZHQ9InVybjp1bjp1bmVjZTp1bmNlZmFjdDpkYXRhOnN0YW5kYXJkOlVucXVhbGlmaWVkRGF0YVR5cGU6MTAwIj4KICA8cnNtOkV4Y2hhbmdlZERvY3VtZW50Q29udGV4dD4KICAgIDxyYW06R3VpZGVsaW5lU3BlY2lmaWVkRG9jdW1lbnRDb250ZXh0UGFyYW1ldGVyPgogICAgICA8cmFtOklEPnVybjpjZW4uZXU6ZW4xNjkzMToyMDE3PC9yYW06SUQ+CiAgICA8L3JhbTpHdWlkZWxpbmVTcGVjaWZpZWREb2N1bWVudENvbnRleHRQYXJhbWV0ZXI+CiAgPC9yc206RXhjaGFuZ2VkRG9jdW1lbnRDb250ZXh0PgogIDxyc206RXhjaGFuZ2VkRG9jdW1lbnQ+CiAgICA8cmFtOklEPklOVi0yMDI2LTAwNDI8L3JhbTpJRD4KICAgIDxyYW06VHlwZUNvZGU+MzgwPC9yYW06VHlwZUNvZGU+CiAgICA8cmFtOklzc3VlRGF0ZVRpbWU+CiAgICAgIDx1ZHQ6RGF0ZVRpbWVTdHJpbmcgZm9ybWF0PSIxMDIiPjIwMjYwMzIwPC91ZHQ6RGF0ZVRpbWVTdHJpbmc+CiAgICA8L3JhbTpJc3N1ZURhdGVUaW1lPgogICAgPHJhbTpJbmNsdWRlZE5vdGU+CiAgICAgIDxyYW06Q29udGVudD5WaWVsZW4gRGFuayBmw7xyIElocmVuIEF1ZnRyYWchPC9yYW06Q29udGVudD4KICAgIDwvcmFtOkluY2x1ZGVkTm90ZT4KICA8L3JzbTpFeGNoYW5nZWREb2N1bWVudD4KICA8cnNtOlN1cHBseUNoYWluVHJhZGVUcmFuc2FjdGlvbj4KICAgIDxyYW06SW5jbHVkZWRTdXBwbHlDaGFpblRyYWRlTGluZUl0ZW0+CiAgICAgIDxyYW06QXNzb2NpYXRlZERvY3VtZW50TGluZURvY3VtZW50PgogICAgICAgIDxyYW06TGluZUlEPjE8L3JhbTpMaW5lSUQ+CiAgICAgIDwvcmFtOkFzc29jaWF0ZWREb2N1bWVudExpbmVEb2N1bWVudD4KICAgICAgPHJhbTpTcGVjaWZpZWRUcmFkZVByb2R1Y3Q+CiAgICAgICAgPHJhbTpTZWxsZXJBc3NpZ25lZElEPlNWQy1ERVYtMDAxPC9yYW06U2VsbGVyQXNzaWduZWRJRD4KICAgICAgICA8cmFtOk5hbWU+U29mdHdhcmUgRGV2ZWxvcG1lbnQgU2VydmljZXMg4oCUIE1hcmNoIDIwMjY8L3JhbTpOYW1lPgogICAgICA8L3JhbTpTcGVjaWZpZWRUcmFkZVByb2R1Y3Q+CiAgICAgIDxyYW06U3BlY2lmaWVkTGluZVRyYWRlQWdyZWVtZW50PgogICAgICAgIDxyYW06TmV0UHJpY2VQcm9kdWN0VHJhZGVQcmljZT4KICAgICAgICAgIDxyYW06Q2hhcmdlQW1vdW50PjEyMC4wMDwvcmFtOkNoYXJnZUFtb3VudD4KICAgICAgICA8L3JhbTpOZXRQcmljZVByb2R1Y3RUcmFkZVByaWNlPgogICAgICA8L3JhbTpTcGVjaWZpZWRMaW5lVHJhZGVBZ3JlZW1lbnQ+CiAgICAgIDxyYW06U3BlY2lmaWVkTGluZVRyYWRlRGVsaXZlcnk+CiAgICAgICAgPHJhbTpCaWxsZWRRdWFudGl0eSB1bml0Q29kZT0iSFVSIj40MC4wMDwvcmFtOkJpbGxlZFF1YW50aXR5PgogICAgICA8L3JhbTpTcGVjaWZpZWRMaW5lVHJhZGVEZWxpdmVyeT4KICAgICAgPHJhbTpTcGVjaWZpZWRMaW5lVHJhZGVTZXR0bGVtZW50PgogICAgICAgIDxyYW06QXBwbGljYWJsZVRyYWRlVGF4PgogICAgICAgICAgPHJhbTpUeXBlQ29kZT5WQVQ8L3JhbTpUeXBlQ29kZT4KICAgICAgICAgIDxyYW06Q2F0ZWdvcnlDb2RlPlM8L3JhbTpDYXRlZ29yeUNvZGU+CiAgICAgICAgICA8cmFtOlJhdGVBcHBsaWNhYmxlUGVyY2VudD4xOS4wMDwvcmFtOlJhdGVBcHBsaWNhYmxlUGVyY2VudD4KICAgICAgICA8L3JhbTpBcHBsaWNhYmxlVHJhZGVUYXg+CiAgICAgICAgPHJhbTpTcGVjaWZpZWRUcmFkZVNldHRsZW1lbnRMaW5lTW9uZXRhcnlTdW1tYXRpb24+CiAgICAgICAgICA8cmFtOkxpbmVUb3RhbEFtb3VudD40ODAwLjAwPC9yYW06TGluZVRvdGFsQW1vdW50PgogICAgICAgIDwvcmFtOlNwZWNpZmllZFRyYWRlU2V0dGxlbWVudExpbmVNb25ldGFyeVN1bW1hdGlvbj4KICAgICAgPC9yYW06U3BlY2lmaWVkTGluZVRyYWRlU2V0dGxlbWVudD4KICAgIDwvcmFtOkluY2x1ZGVkU3VwcGx5Q2hhaW5UcmFkZUxpbmVJdGVtPgogICAgPHJhbTpBcHBsaWNhYmxlSGVhZGVyVHJhZGVBZ3JlZW1lbnQ+CiAgICAgIDxyYW06QnV5ZXJSZWZlcmVuY2U+MDQwMTEwMDAtMTIzNDUtMzQ8L3JhbTpCdXllclJlZmVyZW5jZT4KICAgICAgPHJhbTpTZWxsZXJUcmFkZVBhcnR5PgogICAgICAgIDxyYW06TmFtZT5UZWNoQ29ycCBHbWJIPC9yYW06TmFtZT4KICAgICAgICA8cmFtOkRlZmluZWRUcmFkZUNvbnRhY3Q+CiAgICAgICAgICA8cmFtOlRlbGVwaG9uZVVuaXZlcnNhbENvbW11bmljYXRpb24+CiAgICAgICAgICAgIDxyYW06Q29tcGxldGVOdW1iZXI+KzQ5IDMwIDEyMzQ1Njc8L3JhbTpDb21wbGV0ZU51bWJlcj4KICAgICAgICAgIDwvcmFtOlRlbGVwaG9uZVVuaXZlcnNhbENvbW11bmljYXRpb24+CiAgICAgICAgICA8cmFtOkVtYWlsVVJJVW5pdmVyc2FsQ29tbXVuaWNhdGlvbj4KICAgICAgICAgICAgPHJhbTpVUklJRD5iaWxsaW5nQHRlY2hjb3JwLmRlPC9yYW06VVJJSUQ+CiAgICAgICAgICA8L3JhbTpFbWFpbFVSSVVuaXZlcnNhbENvbW11bmljYXRpb24+CiAgICAgICAgPC9yYW06RGVmaW5lZFRyYWRlQ29udGFjdD4KICAgICAgICA8cmFtOlBvc3RhbFRyYWRlQWRkcmVzcz4KICAgICAgICAgIDxyYW06UG9zdGNvZGVDb2RlPjEwNjIzPC9yYW06UG9zdGNvZGVDb2RlPgogICAgICAgICAgPHJhbTpMaW5lT25lPkthbnRzdHJhw59lIDEyPC9yYW06TGluZU9uZT4KICAgICAgICAgIDxyYW06Q2l0eU5hbWU+QmVybGluPC9yYW06Q2l0eU5hbWU+CiAgICAgICAgICA8cmFtOkNvdW50cnlJRD5ERTwvcmFtOkNvdW50cnlJRD4KICAgICAgICA8L3JhbTpQb3N0YWxUcmFkZUFkZHJlc3M+CiAgICAgICAgPHJhbTpVUklVbml2ZXJzYWxDb21tdW5pY2F0aW9uPgogICAgICAgICAgPHJhbTpVUklJRCBzY2hlbWVJRD0iRU0iPmJpbGxpbmdAdGVjaGNvcnAuZGU8L3JhbTpVUklJRD4KICAgICAgICA8L3JhbTpVUklVbml2ZXJzYWxDb21tdW5pY2F0aW9uPgogICAgICAgIDxyYW06U3BlY2lmaWVkVGF4UmVnaXN0cmF0aW9uPgogICAgICAgICAgPHJhbTpJRCBzY2hlbWVJRD0iVkEiPkRFMTM2Njk1OTc2PC9yYW06SUQ+CiAgICAgICAgPC9yYW06U3BlY2lmaWVkVGF4UmVnaXN0cmF0aW9uPgogICAgICAgIDxyYW06U3BlY2lmaWVkVGF4UmVnaXN0cmF0aW9uPgogICAgICAgICAgPHJhbTpJRCBzY2hlbWVJRD0iRkMiPjI3LzEyMy80NTY3ODwvcmFtOklEPgogICAgICAgIDwvcmFtOlNwZWNpZmllZFRheFJlZ2lzdHJhdGlvbj4KICAgICAgPC9yYW06U2VsbGVyVHJhZGVQYXJ0eT4KICAgICAgPHJhbTpCdXllclRyYWRlUGFydHk+CiAgICAgICAgPHJhbTpOYW1lPk11c3RlciBHbWJIPC9yYW06TmFtZT4KICAgICAgICA8cmFtOlBvc3RhbFRyYWRlQWRkcmVzcz4KICAgICAgICAgIDxyYW06UG9zdGNvZGVDb2RlPjgwMzMxPC9yYW06UG9zdGNvZGVDb2RlPgogICAgICAgICAgPHJhbTpMaW5lT25lPkhhdXB0c3RyYcOfZSA0MjwvcmFtOkxpbmVPbmU+CiAgICAgICAgICA8cmFtOkNpdHlOYW1lPk3DvG5jaGVuPC9yYW06Q2l0eU5hbWU+CiAgICAgICAgICA8cmFtOkNvdW50cnlJRD5ERTwvcmFtOkNvdW50cnlJRD4KICAgICAgICA8L3JhbTpQb3N0YWxUcmFkZUFkZHJlc3M+CiAgICAgICAgPHJhbTpVUklVbml2ZXJzYWxDb21tdW5pY2F0aW9uPgogICAgICAgICAgPHJhbTpVUklJRCBzY2hlbWVJRD0iRU0iPmludm9pY2VAbXVzdGVyLmRlPC9yYW06VVJJSUQ+CiAgICAgICAgPC9yYW06VVJJVW5pdmVyc2FsQ29tbXVuaWNhdGlvbj4KICAgICAgICA8cmFtOlNwZWNpZmllZFRheFJlZ2lzdHJhdGlvbj4KICAgICAgICAgIDxyYW06SUQgc2NoZW1lSUQ9IlZBIj5ERTgxMTU2OTg2OTwvcmFtOklEPgogICAgICAgIDwvcmFtOlNwZWNpZmllZFRheFJlZ2lzdHJhdGlvbj4KICAgICAgPC9yYW06QnV5ZXJUcmFkZVBhcnR5PgogICAgPC9yYW06QXBwbGljYWJsZUhlYWRlclRyYWRlQWdyZWVtZW50PgogICAgPHJhbTpBcHBsaWNhYmxlSGVhZGVyVHJhZGVEZWxpdmVyeT4KICAgICAgPHJhbTpBY3R1YWxEZWxpdmVyeVN1cHBseUNoYWluRXZlbnQ+CiAgICAgICAgPHJhbTpPY2N1cnJlbmNlRGF0ZVRpbWU+CiAgICAgICAgICA8dWR0OkRhdGVUaW1lU3RyaW5nIGZvcm1hdD0iMTAyIj4yMDI2MDMyMDwvdWR0OkRhdGVUaW1lU3RyaW5nPgogICAgICAgIDwvcmFtOk9jY3VycmVuY2VEYXRlVGltZT4KICAgICAgPC9yYW06QWN0dWFsRGVsaXZlcnlTdXBwbHlDaGFpbkV2ZW50PgogICAgPC9yYW06QXBwbGljYWJsZUhlYWRlclRyYWRlRGVsaXZlcnk+CiAgICA8cmFtOkFwcGxpY2FibGVIZWFkZXJUcmFkZVNldHRsZW1lbnQ+CiAgICAgIDxyYW06SW52b2ljZUN1cnJlbmN5Q29kZT5FVVI8L3JhbTpJbnZvaWNlQ3VycmVuY3lDb2RlPgogICAgICA8cmFtOlNwZWNpZmllZFRyYWRlU2V0dGxlbWVudFBheW1lbnRNZWFucz4KICAgICAgICA8cmFtOlR5cGVDb2RlPjU4PC9yYW06VHlwZUNvZGU+CiAgICAgICAgPHJhbTpQYXllZVBhcnR5Q3JlZGl0b3JGaW5hbmNpYWxBY2NvdW50PgogICAgICAgICAgPHJhbTpJQkFOSUQ+REU4OTM3MDQwMDQ0MDUzMjAxMzAwMDwvcmFtOklCQU5JRD4KICAgICAgICAgIDxyYW06QWNjb3VudE5hbWU+VGVjaENvcnAgR21iSDwvcmFtOkFjY291bnROYW1lPgogICAgICAgIDwvcmFtOlBheWVlUGFydHlDcmVkaXRvckZpbmFuY2lhbEFjY291bnQ+CiAgICAgICAgPHJhbTpQYXllZVNwZWNpZmllZENyZWRpdG9yRmluYW5jaWFsSW5zdGl0dXRpb24+CiAgICAgICAgICA8cmFtOkJJQ0lEPkNPQkFERUZGWFhYPC9yYW06QklDSUQ+CiAgICAgICAgPC9yYW06UGF5ZWVTcGVjaWZpZWRDcmVkaXRvckZpbmFuY2lhbEluc3RpdHV0aW9uPgogICAgICA8L3JhbTpTcGVjaWZpZWRUcmFkZVNldHRsZW1lbnRQYXltZW50TWVhbnM+CiAgICAgIDxyYW06QXBwbGljYWJsZVRyYWRlVGF4PgogICAgICAgIDxyYW06Q2FsY3VsYXRlZEFtb3VudD45MTIuMDA8L3JhbTpDYWxjdWxhdGVkQW1vdW50PgogICAgICAgIDxyYW06VHlwZUNvZGU+VkFUPC9yYW06VHlwZUNvZGU+CiAgICAgICAgPHJhbTpCYXNpc0Ftb3VudD40ODAwLjAwPC9yYW06QmFzaXNBbW91bnQ+CiAgICAgICAgPHJhbTpDYXRlZ29yeUNvZGU+UzwvcmFtOkNhdGVnb3J5Q29kZT4KICAgICAgICA8cmFtOlJhdGVBcHBsaWNhYmxlUGVyY2VudD4xOS4wMDwvcmFtOlJhdGVBcHBsaWNhYmxlUGVyY2VudD4KICAgICAgPC9yYW06QXBwbGljYWJsZVRyYWRlVGF4PgogICAgICA8cmFtOlNwZWNpZmllZFRyYWRlUGF5bWVudFRlcm1zPgogICAgICAgIDxyYW06RGVzY3JpcHRpb24+WmFobGJhciBpbm5lcmhhbGIgdm9uIDMwIFRhZ2VuIG9obmUgQWJ6dWc8L3JhbTpEZXNjcmlwdGlvbj4KICAgICAgICA8cmFtOkR1ZURhdGVEYXRlVGltZT4KICAgICAgICAgIDx1ZHQ6RGF0ZVRpbWVTdHJpbmcgZm9ybWF0PSIxMDIiPjIwMjYwNDE5PC91ZHQ6RGF0ZVRpbWVTdHJpbmc+CiAgICAgICAgPC9yYW06RHVlRGF0ZURhdGVUaW1lPgogICAgICA8L3JhbTpTcGVjaWZpZWRUcmFkZVBheW1lbnRUZXJtcz4KICAgICAgPHJhbTpTcGVjaWZpZWRUcmFkZVNldHRsZW1lbnRIZWFkZXJNb25ldGFyeVN1bW1hdGlvbj4KICAgICAgICA8cmFtOkxpbmVUb3RhbEFtb3VudD40ODAwLjAwPC9yYW06TGluZVRvdGFsQW1vdW50PgogICAgICAgIDxyYW06VGF4QmFzaXNUb3RhbEFtb3VudD40ODAwLjAwPC9yYW06VGF4QmFzaXNUb3RhbEFtb3VudD4KICAgICAgICA8cmFtOlRheFRvdGFsQW1vdW50IGN1cnJlbmN5SUQ9IkVVUiI+OTEyLjAwPC9yYW06VGF4VG90YWxBbW91bnQ+CiAgICAgICAgPHJhbTpHcmFuZFRvdGFsQW1vdW50PjU3MTIuMDA8L3JhbTpHcmFuZFRvdGFsQW1vdW50PgogICAgICAgIDxyYW06RHVlUGF5YWJsZUFtb3VudD41NzEyLjAwPC9yYW06RHVlUGF5YWJsZUFtb3VudD4KICAgICAgPC9yYW06U3BlY2lmaWVkVHJhZGVTZXR0bGVtZW50SGVhZGVyTW9uZXRhcnlTdW1tYXRpb24+CiAgICA8L3JhbTpBcHBsaWNhYmxlSGVhZGVyVHJhZGVTZXR0bGVtZW50PgogIDwvcnNtOlN1cHBseUNoYWluVHJhZGVUcmFuc2FjdGlvbj4KPC9yc206Q3Jvc3NJbmR1c3RyeUludm9pY2U+CmVuZHN0cmVhbQplbmRvYmoKCjMxIDAgb2JqCjw8Ci9UeXBlIC9NZXRhZGF0YQovU3VidHlwZSAvWE1MCi9MZW5ndGggMzM5Nwo+PgpzdHJlYW0KPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyI+CiAgPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIKICAgICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgICB4bWxuczpwZGY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGRmLzEuMy8iCiAgICAgIHhtbG5zOnBkZmFpZD0iaHR0cDovL3d3dy5haWltLm9yZy9wZGZhL25zL2lkLyIKICAgICAgeG1sbnM6cGRmYUV4dGVuc2lvbj0iaHR0cDovL3d3dy5haWltLm9yZy9wZGZhL25zL2V4dGVuc2lvbi8iCiAgICAgIHhtbG5zOnBkZmFTY2hlbWE9Imh0dHA6Ly93d3cuYWlpbS5vcmcvcGRmYS9ucy9zY2hlbWEjIgogICAgICB4bWxuczpwZGZhUHJvcGVydHk9Imh0dHA6Ly93d3cuYWlpbS5vcmcvcGRmYS9ucy9wcm9wZXJ0eSMiCiAgICAgIHhtbG5zOmZ4PSJ1cm46ZmFjdHVyLXg6cGRmYTpDcm9zc0luZHVzdHJ5RG9jdW1lbnQ6aW52b2ljZToxcDAjIj4KICAgICAgPHhtcDpDcmVhdGVEYXRlPjIwMjYtMTEtMDVUMTY6MTg6NTAuMTUwWjwveG1wOkNyZWF0ZURhdGU+CiAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDI2LTExLTA1VDE2OjE4OjUwLjE1MFo8L3htcDpNb2RpZnlEYXRlPgogICAgICA8eG1wOkNyZWF0b3JUb29sPmxpYi1pbnZvaWNlLWZhY3R1cngtZW1iZWRkaW5nPC94bXA6Q3JlYXRvclRvb2w+CiAgICAgIDxkYzpmb3JtYXQ+YXBwbGljYXRpb24vcGRmPC9kYzpmb3JtYXQ+CiAgICAgIDxwZGY6UHJvZHVjZXI+cGRmLWxpYjwvcGRmOlByb2R1Y2VyPgogICAgICA8cGRmYWlkOnBhcnQ+MzwvcGRmYWlkOnBhcnQ+CiAgICAgIDxwZGZhaWQ6Y29uZm9ybWFuY2U+QjwvcGRmYWlkOmNvbmZvcm1hbmNlPgoKICAgICAgPHBkZmFFeHRlbnNpb246c2NoZW1hcz4KICAgICAgICA8cmRmOkJhZz4KICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICA8cGRmYVNjaGVtYTpzY2hlbWE+RmFjdHVyLVggUERGQSBFeHRlbnNpb24gU2NoZW1hPC9wZGZhU2NoZW1hOnNjaGVtYT4KICAgICAgICAgICAgPHBkZmFTY2hlbWE6bmFtZXNwYWNlVVJJPnVybjpmYWN0dXIteDpwZGZhOkNyb3NzSW5kdXN0cnlEb2N1bWVudDppbnZvaWNlOjFwMCM8L3BkZmFTY2hlbWE6bmFtZXNwYWNlVVJJPgogICAgICAgICAgICA8cGRmYVNjaGVtYTpwcmVmaXg+Zng8L3BkZmFTY2hlbWE6cHJlZml4PgogICAgICAgICAgICA8cGRmYVNjaGVtYTpwcm9wZXJ0eT4KICAgICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5Om5hbWU+RG9jdW1lbnRGaWxlTmFtZTwvcGRmYVByb3BlcnR5Om5hbWU+CiAgICAgICAgICAgICAgICAgIDxwZGZhUHJvcGVydHk6dmFsdWVUeXBlPlRleHQ8L3BkZmFQcm9wZXJ0eTp2YWx1ZVR5cGU+CiAgICAgICAgICAgICAgICAgIDxwZGZhUHJvcGVydHk6Y2F0ZWdvcnk+ZXh0ZXJuYWw8L3BkZmFQcm9wZXJ0eTpjYXRlZ29yeT4KICAgICAgICAgICAgICAgICAgPHBkZmFQcm9wZXJ0eTpkZXNjcmlwdGlvbj5OYW1lIG9mIHRoZSBlbWJlZGRlZCBYTUwgaW52b2ljZSBmaWxlPC9wZGZhUHJvcGVydHk6ZGVzY3JpcHRpb24+CiAgICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5Om5hbWU+RG9jdW1lbnRUeXBlPC9wZGZhUHJvcGVydHk6bmFtZT4KICAgICAgICAgICAgICAgICAgPHBkZmFQcm9wZXJ0eTp2YWx1ZVR5cGU+VGV4dDwvcGRmYVByb3BlcnR5OnZhbHVlVHlwZT4KICAgICAgICAgICAgICAgICAgPHBkZmFQcm9wZXJ0eTpjYXRlZ29yeT5leHRlcm5hbDwvcGRmYVByb3BlcnR5OmNhdGVnb3J5PgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5OmRlc2NyaXB0aW9uPlR5cGUgb2YgdGhlIGVtYmVkZGVkIGRvY3VtZW50PC9wZGZhUHJvcGVydHk6ZGVzY3JpcHRpb24+CiAgICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5Om5hbWU+Q29uZm9ybWFuY2VMZXZlbDwvcGRmYVByb3BlcnR5Om5hbWU+CiAgICAgICAgICAgICAgICAgIDxwZGZhUHJvcGVydHk6dmFsdWVUeXBlPlRleHQ8L3BkZmFQcm9wZXJ0eTp2YWx1ZVR5cGU+CiAgICAgICAgICAgICAgICAgIDxwZGZhUHJvcGVydHk6Y2F0ZWdvcnk+ZXh0ZXJuYWw8L3BkZmFQcm9wZXJ0eTpjYXRlZ29yeT4KICAgICAgICAgICAgICAgICAgPHBkZmFQcm9wZXJ0eTpkZXNjcmlwdGlvbj5GYWN0dXItWCBjb25mb3JtYW5jZSBsZXZlbDwvcGRmYVByb3BlcnR5OmRlc2NyaXB0aW9uPgogICAgICAgICAgICAgICAgPC9yZGY6bGk+CiAgICAgICAgICAgICAgICA8cmRmOmxpIHJkZjpwYXJzZVR5cGU9IlJlc291cmNlIj4KICAgICAgICAgICAgICAgICAgPHBkZmFQcm9wZXJ0eTpuYW1lPlZlcnNpb248L3BkZmFQcm9wZXJ0eTpuYW1lPgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5OnZhbHVlVHlwZT5UZXh0PC9wZGZhUHJvcGVydHk6dmFsdWVUeXBlPgogICAgICAgICAgICAgICAgICA8cGRmYVByb3BlcnR5OmNhdGVnb3J5PmV4dGVybmFsPC9wZGZhUHJvcGVydHk6Y2F0ZWdvcnk+CiAgICAgICAgICAgICAgICAgIDxwZGZhUHJvcGVydHk6ZGVzY3JpcHRpb24+RmFjdHVyLVggdmVyc2lvbjwvcGRmYVByb3BlcnR5OmRlc2NyaXB0aW9uPgogICAgICAgICAgICAgICAgPC9yZGY6bGk+CiAgICAgICAgICAgICAgPC9yZGY6U2VxPgogICAgICAgICAgICA8L3BkZmFTY2hlbWE6cHJvcGVydHk+CiAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICA8L3JkZjpCYWc+CiAgICAgIDwvcGRmYUV4dGVuc2lvbjpzY2hlbWFzPgogICAgICA8Zng6RG9jdW1lbnRGaWxlTmFtZT5mYWN0dXIteC54bWw8L2Z4OkRvY3VtZW50RmlsZU5hbWU+CiAgICAgIDxmeDpEb2N1bWVudFR5cGU+SU5WT0lDRTwvZng6RG9jdW1lbnRUeXBlPgogICAgICA8Zng6Q29uZm9ybWFuY2VMZXZlbD5FTiAxNjkzMTwvZng6Q29uZm9ybWFuY2VMZXZlbD4KICAgICAgPGZ4OlZlcnNpb24+MS4wPC9meDpWZXJzaW9uPgogICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KPD94cGFja2V0IGVuZD0idyI/PgplbmRzdHJlYW0KZW5kb2JqCgozMiAwIG9iago8PAovRmlsdGVyIC9GbGF0ZURlY29kZQovVHlwZSAvT2JqU3RtCi9OIDIyCi9GaXJzdCAxNDkKL0xlbmd0aCAxNDc4Cj4+CnN0cmVhbQp4nMVXa2/bNhT97l/BjwkGU3w/hqKAY8epsWUt8tiKFsWgWIwr1LYMSy6Sf79DSnaUJkG7AsMCOKTIy8vLc8+5ojhhRBCliCTeEEUE48TgvyWWSKOII8piimgmCGdES0s4LCyeBLEw5pI4qQlXxFs0mniHxhDv0TiswRD3sDaeCEEEj60kQsUHQySDnfBECsHxQKRijrx6Nciu7jeBZO/yRagH2bjarRvCB9lvZVGTj4iNkQvyafD69SDaTkLd1GnVH/kqRIM0lZ2ubkJRhGJaLjEK71i1X9P6H+dNvqwWg3YjwpNF50W0D293zWbXzNZNWDfRNYJuN8/OQ5MXcEBkt240jfP+UXDddu+21fwyNJjP3k2mJLsKdw3JZitse9K1466dRd+nd83ZZZM3IR3rrObIRNrjrBbE77syJqM7VDatgFG0nvKYqmQyTXnaW4yrZbW93OTz5BUjj7CIEEQgtiFi3a4/D0WZn1R3iDt61F5T4YhTnDofwxxXHS66tb8IdbXbzoGeaQeu67C9XpcxeY82O5xvkM3z701m49G3JvGwg+xyd9OkxzjIBtlJXocEQ3byIf79clHdVE01vAiL3TLfAtb1vCrK9QJQF4i7bO6HbxJ/5mFd5OsmLo5J5vskZlcVwseiAFE85U8v0n8f4/hRjBHq3erHQ4SInoao+iGCc8VuHrbk6O7z7qashnWe12RT3A5v8vkXeDtG1NuQN9X3TcpqPYlsPJr8KpgwnDPNDXfKf4DFeVW8OIlYjuBvlX8Jx/3eM6aPkYsn3pYbBNdSO4ryxbxOl/miJqq1PGkJO7TSUsmUcZYMhWXUe8O8gmSUo15o66JOtKFcC4kKCCRnqAblfLReLANBqkYR84Z4YamVSlq9z0MDh0pRrpgRGBznmzehXHxuiOXYJhm+70a0cFQKJrkEFZqw+jM6jlHGogR12qek+oY349kkjsQ58QMUh/nlfY2dZuvbKtUDTJV1s70nR6OiugH42dttEbaRY0d7jh3HDTebZVjF07FDQXnIQqzmSdJ/pWLwkXhUamclTQhrojWnKPIaxRAppZxLAYAlsAPeSjq8OxgVEUdHpHTUGcudA2Xd3oNxfJ8LZw2NrgT8Gk7jIJZZLqm0zjO8oWAgWw9aSeoVjGXfVntFrTDaxFFBGecWov7Zbu9sWlChEpGwE42swBijYBOCFZZTn7btB2ukoQg1Wj7v3ksaJ8HRdGSpLIUL9Cw2Vgb4KYIBihH0adxT4NTcgICy37UOkZjk1EpBlUi7CiOpaQPowd0LgHsEaG1EHi9m2obqPeWCp4Ni2lhvItgPCBsgkVRBFOaZT0gwQ3Ed8JiGwGjCxIACSkWtoPtAFwNd6HaRgU4d2PJSqpy3yLAXaRTJ3gPCqOsAxqlSJHBNvYu+UqJa1WLbA5s+pbfWbHJVnc0m5/nmoco+1eDzFej5qv1CAUL2IjPFNwXIAjmT9PG/FyDBf7oAPY/Ef1Z/hHhaf4zwVCbxo7xoalTbFQcVao3RVhsaSJsEWOp2oGsDxnYeuKKmrVUOOm4ZLbWkmicx9mQUaahsW12kp8mplCA3s4nGilEmfRKnVtR15D6UicOa3mxUJs6ArVAvHDQIdai+NoSFoFImYcAhPZsO2JOJVQg1dQ3TdK8zBe0k9eEOj/deJ+PDql7V7WlSQKmJofKxUr/T7R2iN2oYkBGpvEAAqXzF4tEdxmJItdn6UXX27+QgDsnOri7/xr16xPf3dVxMizLeWloHt2W8BtUXZycgWiJmeiCz07FB8TNDFL3j9kOiXY+70y30gQQ9I4/4ObEJczCUHN3m82a3Hd7Ru9USHq6n5NX0dDplzBj8OH4SpFD4afwEY2ISSYL2tG0Nns34datscvTh+mwaLiZktv5albiovz///Th+WVyEZbqF1Z9LwDJaNmG7xsBX3DxPp+21n4juDX196D7c8fdfRj8X3aOvmn8ADWOMaQplbmRzdHJlYW0KZW5kb2JqCgozMyAwIG9iago8PAovU2l6ZSAzNAovUm9vdCAzIDAgUgovSW5mbyAxMyAwIFIKL0lEIFsgPGMxYjY5NDFhNGEzODdkYmMzM2U1NmQ4ZTgxODk0ZmFmPiA8YzFiNjk0MWE0YTM4N2RiYzMzZTU2ZDhlODE4OTRmYWY+IF0KL0ZpbHRlciAvRmxhdGVEZWNvZGUKL1R5cGUgL1hSZWYKL0xlbmd0aCAxMTUKL1cgWyAxIDIgMiBdCi9JbmRleCBbIDAgMzQgXQo+PgpzdHJlYW0KeJxjYGD4/5+JQYGBAUQwgggmEMHMyCAAEWMBEawggg1EsIMIDhDBCSK4QAQ3iOABEbwggo+RoxGilx9ECDDqljEwMOpbQsQEQYQQo/caoJivA0RMmNE/CsgNyoZwRUCEKGP2RaBYZRaQqJ/FwAAAvkQNowplbmRzdHJlYW0KZW5kb2JqCgpzdGFydHhyZWYKMzI2NjYKJSVFT0Y=\",\n  \"targetFormat\": \"xrechnung\"\n}"

response = http.request(request)
puts response.read_body
```

```java ZUGFeRD (PDF) → XRechnung
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://service.invoice-api.xhub.io/api/v1/invoice/convert")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"source\": \"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\",\n  \"targetFormat\": \"xrechnung\"\n}")
  .asString();
```

```php ZUGFeRD (PDF) → XRechnung
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://service.invoice-api.xhub.io/api/v1/invoice/convert', [
  'body' => '{
  "source": "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",
  "targetFormat": "xrechnung"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp ZUGFeRD (PDF) → XRechnung
using RestSharp;

var client = new RestClient("https://service.invoice-api.xhub.io/api/v1/invoice/convert");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"source\": \"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\",\n  \"targetFormat\": \"xrechnung\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift ZUGFeRD (PDF) → XRechnung
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "source": "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",
  "targetFormat": "xrechnung"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://service.invoice-api.xhub.io/api/v1/invoice/convert")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```