<?xml version="1.0" encoding="UTF-8"?>
  <?xml-stylesheet type="text/xsl" href="rfc2629.xslt" ?>
  <!-- generated by https://github.com/cabo/kramdown-rfc version 1.7.32 (Ruby 3.3.0) -->


<!DOCTYPE rfc  [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">

]>


<rfc ipr="trust200902" docName="draft-ietf-jmap-conditional-03" category="std" consensus="true" submissionType="IETF" updates="8620" tocInclude="true" sortRefs="true" symRefs="true">
  <front>
    <title abbrev="JMAP Conditional">JMAP Conditional Set</title>

    <author initials="B." surname="Gondwana" fullname="Bron Gondwana">
      <organization>Fastmail</organization>
      <address>
        <email>brong@fastmailteam.com</email>
      </address>
    </author>

    <date year="2026" month="November" day="15"/>

    
    
    <keyword>Internet-Draft</keyword>

    <abstract>


<?line 31?>

<t>The JMAP base protocol (<xref target="JMAP-CORE"/>) provides the Foo/set method for
creating, updating, and destroying objects.  It offers a single concurrency
control, the "ifInState" argument, which guards an entire object type: if any
object of that type has changed, the whole method is rejected.</t>

<t>This extension adds a finer, per-object conditional mechanism.  A client may
require that an individual update or destroy proceed only if the target object
still matches a set of expected property values, expressed using the JMAP
PatchObject already defined for updates.  This provides optimistic concurrency
control scoped to a single object — the equivalent of an HTTP "If-Match"
precondition — for any JMAP data type.</t>

<t>This extension also defines an optional "atomic" argument that applies an
entire Foo/set as a single unit: either every change it requests takes effect,
or none does.  Combined with the per-object precondition, this lets a client
express a multi-object change that is safe only when applied together — such as
an atomic rename that exchanges two names.</t>



    </abstract>



  </front>

  <middle>


<?line 51?>

<section anchor="introduction"><name>Introduction</name>

<t>The Foo/set method defined in <xref target="JMAP-CORE"/> is the mechanism by which clients
create, update, and destroy objects.  It provides one form of concurrency
control: the optional "ifInState" argument, which aborts the entire method if
the account's state string for that data type does not match the value the
client supplies.</t>

<t>This guard is coarse.  The state string changes whenever <em>any</em> object of that
type changes, by any client.  In a busy account — or one that receives
server-initiated changes, such as the arrival of new mail — the state can
change between a client's read and its write for reasons entirely unrelated to
the object the client is modifying.  Using "ifInState" to protect a single
update therefore leads to frequent spurious rejections and retries.</t>

<t>Clients commonly need a narrower guarantee: "apply this change only if the
specific object I read still holds the values I depend on".  This is the same
need met by the HTTP "If-Match" precondition (<xref target="HTTP"/>) and the
entity-tag model of WebDAV (<xref target="WEBDAV"/>): a conditional write scoped to a single
resource.</t>

<t>This document defines a generic, per-object conditional mechanism for Foo/set.
It introduces no new properties and no new version tokens.  Instead it reuses
the PatchObject already defined by <xref target="JMAP-CORE"/> for updates: a client states
its precondition as a PatchObject describing the values it expects the object
to currently hold, and the server performs the change only if applying that
patch would change nothing.</t>

<t>Because the mechanism is defined entirely in terms of an object's properties
and the existing PatchObject semantics, it applies uniformly to every data
type that implements Foo/set, with no per-type additions.</t>

<t>A second, related need is atomicity.  <xref target="JMAP-CORE"/> processes the creations,
updates, and destroys within a Foo/set independently: some may succeed while
others fail, and the method gives no guarantee that a set of related changes
takes effect together.  The only all-or-nothing control Core offers is
"ifInState", which — like the concurrency problem above — is scoped to the
entire object type rather than to the changes the client actually requested.
This document therefore also defines an optional "atomic" argument that commits
a Foo/set as a single unit, evaluated against the state that results from
applying all of its changes together (see <xref target="atomic"/>).</t>

<section anchor="conventions-used-in-this-document"><name>Conventions Used in This Document</name>

<t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>", "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL
NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>",
"<bcp14>MAY</bcp14>", and "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as
described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they
appear in all capitals, as shown here.</t>

<?line -18?>

<t>The terms "Id", "PatchObject", "SetError", and "Foo/set" are defined in
<xref target="JMAP-CORE"/>.  A "pointer" is a JSON Pointer as used within a PatchObject
(see <xref target="JMAP-CORE"/>, Section 5.3).</t>

</section>
</section>
<section anchor="addition-to-the-capabilities-object"><name>Addition to the Capabilities Object</name>

<section anchor="urnietfparamsjmapconditional"><name>urn:ietf:params:jmap:conditional</name>

<t>The presence of the "urn:ietf:params:jmap:conditional" property in the
"capabilities" object of the JMAP Session resource indicates support for the
conditional Foo/set behaviour defined in this document.  The value of this
property <bcp14>MUST</bcp14> be an empty object.</t>

<t>A client indicates that it wishes to use this extension by including the
capability URI in the "using" array of a request.  When a server that
advertises this capability receives a request whose "using" array includes
this URI, it <bcp14>MUST</bcp14> honour the "ifUnchangedBy" argument (<xref target="conditional-set"/>) on
every Foo/set method it implements.  It <bcp14>MUST</bcp14> also honour the "atomic" argument
(<xref target="atomic"/>): either applying the method atomically, or, if it cannot, rejecting
it with a "cannotApplyAtomically" error (<xref target="atomic"/>).  A server <bcp14>MUST NOT</bcp14> apply
the changes of a method requested with "atomic" only in part.</t>

<t>The capability is generic: it does not depend on any particular data type, and
its presence applies to all types for which the server implements Foo/set.</t>

<section anchor="capability-example"><name>Capability Example</name>

<figure><artwork><![CDATA[
"urn:ietf:params:jmap:conditional": {}
]]></artwork></figure>

</section>
</section>
</section>
<section anchor="conditional-set"><name>Conditional Foo/set</name>

<t>This document adds the following arguments to the standard Foo/set method
(<xref target="JMAP-CORE"/>, Section 5.3):</t>

<t><list style="symbols">
  <t>ifUnchangedBy: "Id[PatchObject|null]" (default: an empty object)  <vspace blankLines='1'/>
A map of object id to a PatchObject expressing a precondition on that
object.  For each entry, the precondition is satisfied if and only if
applying the given PatchObject to the current server-side object would
leave the object unchanged.  <vspace blankLines='1'/>
Equivalently: for every pointer in the PatchObject, the object's current
value at that pointer <bcp14>MUST</bcp14> equal the value given in the PatchObject.  A
JSON "null" value matches a property that is not present (it asserts that
removing the property would be a no-op).  Comparison uses the same
representation the server would return for that property from Foo/get.  <vspace blankLines='1'/>
As in an update (<xref target="JMAP-CORE"/>, Section 5.3), a PatchObject with a
pointer whose parent does not exist in the current object cannot be
applied.  Such a precondition is never satisfied, whatever the value,
including "null": for example "participants/p1/name" cannot be satisfied
by an object with no "participants" property.  The server rejects the
method as for an invalid pointer (rule 4 of <xref target="evaluation-rules"/>).  <vspace blankLines='1'/>
A "null" value instead of a PatchObject asserts that the object does not
exist: the precondition is satisfied if and only if no object with that
id exists or is visible to the client, for example because it has been
destroyed.  <vspace blankLines='1'/>
An empty PatchObject ("{}") is valid and asserts only that the object
exists: the precondition is satisfied if and only if an object with that
id exists and is visible to the client.</t>
  <t>atomic: "Boolean" (default: false)  <vspace blankLines='1'/>
If true, the Foo/set is applied as a single unit: the server <bcp14>MUST</bcp14> either
commit every change the method requests, or make no change at all.  See <xref target="atomic"/>.</t>
</list></t>

<section anchor="evaluation-rules"><name>Evaluation Rules</name>

<t><list style="numbers" type="1">
  <t>Preconditions are evaluated against the state of each object as it exists
at the start of the method, before any create, update, destroy, or other
change in the same method is applied.</t>
  <t>Each key in "ifUnchangedBy" is the id of an object of the same type as the
method (the "Foo" of "Foo/set").  The object need not be one the method
changes.  A client <bcp14>MAY</bcp14> set a precondition on an object the method does not
change, for example its parent.  A PatchObject precondition is not
satisfied if its object does not exist, or is not visible to the client;
a "null" precondition is not satisfied if it does.  The server then
handles it as in <xref target="effect"/>.  A creation id (an id prefixed with "#") <bcp14>MAY</bcp14>
be a key.  It references an object created by an earlier method call in the
same request (<xref target="JMAP-CORE"/>, Section 5.3), and stands for the id that
creation produced.  If no object of this type has that id, because the
creation failed, created an object of a different type, or its object has
since been destroyed, the precondition is evaluated as for an object that
does not exist.  This lets a client require that an object it created
earlier in the request has not changed since then, or that it has since
been destroyed.</t>
  <t>Unlike the PatchObject supplied in the "update" argument, which may only
reference properties the client is permitted to set, the PatchObject in
"ifUnchangedBy" <bcp14>MAY</bcp14> reference any property of the object, including
server-set and otherwise read-only properties (for example a content
identifier, a size, or a server-maintained change timestamp).  This allows
a client to condition a change on properties it cannot itself modify.</t>
  <t>If a pointer in an "ifUnchangedBy" PatchObject is not a valid pointer for
the object's type, or the PatchObject is otherwise malformed, the server
<bcp14>MUST</bcp14> reject the whole method, with either an "invalidArguments" error or
a "stateMismatch" error as for an unsatisfied precondition.  A server need
not distinguish an invalid pointer from one that does not apply cleanly to
the current object.</t>
  <t>The "ifUnchangedBy" and "ifInState" arguments are both method-level guards
and compose.  If both are supplied, the server checks "ifInState" first and
then the "ifUnchangedBy" preconditions; if either does not hold, the method
is rejected with a "stateMismatch" error and no change is made.</t>
</list></t>

</section>
<section anchor="effect"><name>Effect</name>

<t>If every precondition in "ifUnchangedBy" is satisfied, the method proceeds
exactly as it would without this extension.</t>

<t>If any precondition is not satisfied, the server <bcp14>MUST</bcp14> make no change — no
creation, update, or destroy in the method takes effect — and <bcp14>MUST</bcp14> reject the
whole method with a method-level "stateMismatch" error (<xref target="statemismatch"/>).
The state string for the type <bcp14>MUST</bcp14> be unchanged.</t>

<t>This is all-or-nothing at the method level, by design: a single Foo/set is
the unit of conditional application.  A client that wants changes to succeed or
fail independently of one another places them in separate method calls within
the same request, each with its own "ifUnchangedBy".</t>

</section>
<section anchor="statemismatch"><name>The "stateMismatch" error</name>

<t>A failed "ifUnchangedBy" precondition is reported using the method-level
"stateMismatch" error already defined by <xref target="JMAP-CORE"/> for a failed "ifInState"
guard.  It is returned as an "error" response in place of the Foo/set response,
so no create, update, or destroy result is returned and the client knows the
method made no change.</t>

<t>The error discloses no object data: a client that needs the current values
fetches them with Foo/get or Foo/changes before deciding how to proceed.  A
server <bcp14>MAY</bcp14> include a "description" for debugging, and <bcp14>MAY</bcp14> include:</t>

<t><list style="symbols">
  <t>failed: "Id[]"  <vspace blankLines='1'/>
The ids of the objects whose preconditions were not satisfied.  This lets a
client re-fetch only what it needs, without disclosing any values.  A server
that does not wish to distinguish which precondition failed <bcp14>MAY</bcp14> omit this
property.</t>
</list></t>

</section>
</section>
<section anchor="atomic"><name>Atomic Foo/set</name>

<t>When the "atomic" argument is true, the server <bcp14>MUST</bcp14> apply the Foo/set as a
single unit: either every change the method requests takes effect, or none of
them does.  The changes are every creation, update, and destroy, and any other
change that an extension to Foo/set allows the method to request.</t>

<section anchor="evaluation"><name>Evaluation</name>

<t>The server evaluates the method as though all of its changes were applied
together.  Any constraint that <xref target="JMAP-CORE"/> or a data-type extension evaluates
on the resulting object set — for example a uniqueness constraint on a name
within a parent — is checked once, against the state produced by applying all
the changes, not against any intermediate state.</t>

<t>This guarantees that a set of changes that is valid only as a whole can
succeed.  For example, exchanging two names — renaming object A to the name
currently held by B and B to the name currently held by A — collides if applied
one change at a time, but the combined result is conflict-free.  <xref target="JMAP-CORE"/>,
Section 5.3 already permits a server to accept such a change when the final
state is valid, but also permits it to process the changes sequentially and
reject one of them, possibly after committing the other.  With "atomic", the
client can rely on the server evaluating the final state, and on the changes
succeeding or failing together (see <xref target="exchange"/>).</t>

</section>
<section anchor="failure"><name>Failure</name>

<t>If any part of an atomic method fails — an invalid patch, a name collision, a
permission error, a violated constraint, or any other SetError that would place
an id in "notCreated", "notUpdated", "notDestroyed", or any other map of
SetErrors in the Foo/set response — the server <bcp14>MUST</bcp14> make no change and <bcp14>MUST</bcp14>
reject the whole method with a method-level "atomicFailure" error.  The state string for the type <bcp14>MUST</bcp14> be unchanged.</t>

<t>A failed "ifUnchangedBy" precondition is reported as a "stateMismatch" error
(<xref target="statemismatch"/>) whether or not "atomic" is set; preconditions are already
all-or-nothing at the method level.  The "atomicFailure" error is specific to
the method's own changes not being committable together.</t>

<t>The "atomicFailure" error object <bcp14>MAY</bcp14> carry "notCreated", "notUpdated", and
"notDestroyed" maps, and any other map of SetErrors that the Foo/set response
could contain — of the same form as in that response — identifying the ids
whose processing failed and the SetError for each.  Ids that would have
succeeded are omitted; they were not committed, because the method as a whole
was rejected.  A server <bcp14>MAY</bcp14> report only the first failure it encounters.</t>

</section>
<section anchor="cannotapply"><name>Servers That Cannot Apply Atomically</name>

<t>A server that advertises this capability but cannot apply a given method
atomically — either at all, or because this particular method is beyond what it
can commit as a unit — <bcp14>MUST</bcp14> reject the method with a method-level
"cannotApplyAtomically" error and make no change.  It <bcp14>MUST NOT</bcp14> fall back to
applying the changes non-atomically.</t>

<t>A client that receives "cannotApplyAtomically" <bcp14>MAY</bcp14> retry without "atomic" if it
can tolerate partial application, or surface the failure otherwise.  A client
that does not recognise the error treats it as "serverFail" (<xref target="JMAP-CORE"/>):
since a rejected atomic method makes no change, this fallback is safe, if less
informative.</t>

</section>
</section>
<section anchor="examples"><name>Examples</name>

<section anchor="force-with-lease-on-file-content"><name>Force-with-lease on file content</name>

<t>A client last synchronised a file node "f42" with content blob "G_old".  It has
since produced new content "G_new", and wishes to replace the content only if no
other client has changed it in the meantime.  It conditions on the server-set
"blobId" (<xref target="JMAP-FILENODE"/>):</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "f42": { "blobId": "G_old" } },
  "update":       { "f42": { "blobId": "G_new",
                             "modified": "2026-05-01T09:30:00Z" } }
}, "0" ]]
]]></artwork></figure>

<t>If "f42" still references "G_old", the update succeeds.  If another client has
already replaced the content (so "blobId" is now, say, "G_other"), the
precondition fails and the server makes no change, returning a method-level
"stateMismatch" error:</t>

<figure><artwork><![CDATA[
[[ "error", {
  "type": "stateMismatch",
  "failed": [ "f42" ]
}, "0" ]]
]]></artwork></figure>

<t>The client fetches "f42", resolves the conflict (for instance by preserving its
own version as a separate file), and retries.</t>

</section>
<section anchor="conditional-destroy"><name>Conditional destroy</name>

<t>Destroy a message only if it has not been read on another device.  In
<xref target="JMAP-MAIL"/>, an unread message has no "$seen" keyword, so the client asserts
that "keywords/$seen" is absent:</t>

<figure><artwork><![CDATA[
[[ "Email/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "M7": { "keywords/$seen": null } },
  "destroy":      [ "M7" ]
}, "0" ]]
]]></artwork></figure>

<t>If the message has since been marked "$seen", the precondition fails, the whole
method is rejected with a "stateMismatch" error, and "M7" is not deleted.</t>

</section>
<section anchor="a-condition-that-ignores-unrelated-changes"><name>A condition that ignores unrelated changes</name>

<t>Because the precondition references only the pointers the client supplies,
concurrent changes to other properties of the same object do not cause it to
fail.  Here a client removes a grantee's access, but only if that grantee
currently holds exactly the rights the client saw:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "d3": { "shareWith/bob/mayRead": true } },
  "update":       { "d3": { "shareWith/bob": null } }
}, "0" ]]
]]></artwork></figure>

<t>The change applies only if Bob currently has "mayRead" of "true".  A concurrent
change to an unrelated property of "d3" (its name, or another grantee's rights)
does not trigger a "stateMismatch".</t>

</section>
<section anchor="conditioning-on-an-object-the-method-does-not-change"><name>Conditioning on an object the method does not change</name>

<t>A precondition may name an object the method is not creating, updating, or
destroying.  Here a client updates the content of file "f42", but only if it is
still in the parent directory the client last saw ("d3"), so the write does not
land in an unexpected place after a concurrent move:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "f42": { "parentId": "d3" },
                     "d3":  { "name": "Reports" } },
  "update":       { "f42": { "blobId": "G_new",
                             "modified": "2026-05-01T09:30:00Z" } }
}, "0" ]]
]]></artwork></figure>

<t>If either "f42" has been reparented or "d3" has been renamed, the method is
rejected with a "stateMismatch" error and the content is not written, even
though "d3" itself is not being changed.</t>

</section>
<section anchor="conditioning-on-an-object-having-been-destroyed"><name>Conditioning on an object having been destroyed</name>

<t>A "null" precondition requires that an object no longer exists.  Here a client
renames "t" to "report.txt", but only if the file "r" that used to hold that
name has already been destroyed, by this client or another:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "r": null },
  "update":       { "t": { "name": "report.txt" } }
}, "0" ]]
]]></artwork></figure>

<t>If "r" still exists, the method is rejected with a "stateMismatch" error and
"t" keeps its name.</t>

</section>
<section anchor="conditioning-on-an-object-still-existing"><name>Conditioning on an object still existing</name>

<t>An empty PatchObject requires only that an object still exists, whatever its
current values.  Here a client has generated a thumbnail of the file "f42" and
uploads it as a new file, but only if "f42" has not been destroyed in the
meantime, so that no orphaned thumbnail is left behind:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "ifUnchangedBy": { "f42": {} },
  "create": { "th1": { "parentId": "thumbs",
                       "name": "f42.png",
                       "blobId": "G_thumb" } }
}, "0" ]]
]]></artwork></figure>

<t>If "f42" no longer exists, the method is rejected with a "stateMismatch" error
and no thumbnail is created.  Changes to "f42" that leave it in place, such as
a rename, do not cause the precondition to fail.</t>

</section>
<section anchor="whole-object-compare-and-swap"><name>Whole-object compare-and-swap</name>

<t>A data type that maintains a server-set change token can be used to require
that nothing at all has changed.  For example, a type with a server-maintained
"changed" timestamp that is updated on every modification:</t>

<figure><artwork><![CDATA[
"ifUnchangedBy": { "f42": { "changed": "2026-04-30T12:00:00Z" } }
]]></artwork></figure>

<t>Because the server updates "changed" on any modification to the object, this
asserts that the entire object is unchanged since the client last read it,
recovering the coarse "If-Match" behaviour as a special case of the general
mechanism.</t>

</section>
<section anchor="exchange"><name>Atomic exchange of two names</name>

<t>Two file nodes, "a" (named "current.txt") and "b" (named "previous.txt"), are
to swap names.  Applied one at a time, either rename collides with the name the
other still holds; applied together, the result is conflict-free.  A server
conforming only to <xref target="JMAP-CORE"/> may accept this swap, but is not required to.
With "atomic" set, the rule that sibling names are unique is evaluated only
against the resulting state:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "atomic": true,
  "update": {
    "a": { "name": "previous.txt" },
    "b": { "name": "current.txt" }
  }
}, "0" ]]
]]></artwork></figure>

<t>Both renames take effect, or — if either is rejected for any reason — neither
does, and the server returns an "atomicFailure" error identifying the offending
id.</t>

</section>
<section anchor="replace"><name>Atomic replace of one file by another</name>

<t>A common pattern in POSIX applications is to write new content to a temporary
file and then rename it over the original, so that other readers see either the
complete old file or the complete new one, never a partial write.  Here "t"
(named "report.txt.tmp") holds the new content, and "r" (named "report.txt",
with content "G_old") is the file to be replaced:</t>

<figure><artwork><![CDATA[
[[ "FileNode/set", {
  "accountId": "u1",
  "atomic": true,
  "ifUnchangedBy": { "r": { "blobId": "G_old" } },
  "update":  { "t": { "name": "report.txt" } },
  "destroy": [ "r" ]
}, "0" ]]
]]></artwork></figure>

<t>Without "atomic", a server may process each change sequentially against the
current state (<xref target="JMAP-CORE"/>, Section 5.3), so the rename of "t" could be
rejected because "r" still holds the name, while the destroy of "r" succeeds,
leaving neither file named "report.txt".  With "atomic", the sibling-name
uniqueness rule is evaluated only against the resulting state, in which "r" no
longer exists, and the two changes succeed or fail together.</t>

<t>The "ifUnchangedBy" precondition additionally ensures that "r" is replaced only
if no other client has changed its content since this client read it; if it has,
the method is rejected with a "stateMismatch" error and neither file is changed.
A client that wants the unconditional behaviour of POSIX rename(2) omits the
precondition.</t>

</section>
</section>
<section anchor="implementation-considerations"><name>Implementation Considerations</name>

<section anchor="evaluating-preconditions"><name>Evaluating Preconditions</name>

<t>A server can implement "ifUnchangedBy" generically, without code specific to any
data type.  For each entry, the server reads the current object in the
representation it would return from Foo/get, applies the PatchObject to a copy
of it using the same logic it uses for the "update" argument, and compares the
result with the original.  Any difference means the precondition is not
satisfied.  Every data type that supports Foo/set already has both a Foo/get
representation and PatchObject application, so no new per-type machinery is
required.</t>

<t>If the PatchObject does not apply cleanly, the precondition is not satisfied,
and the server may report it either way rule 4 of <xref target="evaluation-rules"/> allows.</t>

<t>A server <bcp14>MAY</bcp14> instead compare the referenced values directly, or use any cheaper
method, provided the outcome is the same.</t>

<t>The precondition check is only meaningful if no other change to the referenced
objects can occur between evaluating the preconditions and applying the
method's changes.  A server therefore evaluates the preconditions and applies
the changes within the same lock or transaction.</t>

</section>
<section anchor="applying-methods-atomically"><name>Applying Methods Atomically</name>

<t>A server backed by a transactional store can implement "atomic" by performing
the whole Foo/set within a single transaction, deferring constraint checks such
as name uniqueness until all of the changes have been applied, and rolling the
transaction back if any part fails.  A server that cannot do this for some or
all of its data types still supports this extension by returning
"cannotApplyAtomically" (<xref target="cannotapply"/>) for those methods.</t>

</section>
</section>
<section anchor="implementation-status"><name>Implementation Status</name>

<t>EDITOR: please remove this section before publication.</t>

<t>This section records the status of known implementations of the protocol
defined by this specification at the time of posting of this Internet-Draft,
and is based on a proposal described in <xref target="IMPL-STATUS"/>.  The description of
implementations in this section is intended to assist the IETF in its
decision processes in progressing drafts to RFCs.  Please note that the listing
of any individual implementation here does not imply endorsement by the IETF.
Furthermore, no effort has been spent to verify the information presented here
that was supplied by IETF contributors.  This is not intended as, and must not
be construed to be, a catalog of available implementations or their features.
Readers are advised to note that other implementations may exist.</t>

<section anchor="cyrus-imap"><name>Cyrus IMAP</name>

<t><list style="symbols">
  <t>Organization: Cyrus IMAP project</t>
  <t>Description: "ifUnchangedBy" and "atomic" for all JMAP data types implemented
by Cyrus.  "cannotApplyAtomically" is returned only for operations that
cannot be undone: immediate sends, and destroys that would remove data at
once under the server's configured delete or expunge mode.</t>
  <t>Level of maturity: complete, under review
(https://github.com/cyrusimap/cyrus-imapd/pull/6104)</t>
  <t>Licensing: BSD-style</t>
  <t>Contact: Bron Gondwana <eref target="mailto:brong@fastmailteam.com">brong@fastmailteam.com</eref></t>
</list></t>

</section>
<section anchor="fastmail"><name>Fastmail</name>

<t><list style="symbols">
  <t>Organization: Fastmail</t>
  <t>Description: "ifUnchangedBy" in Fastmail's internal JMAP server</t>
  <t>Level of maturity: in development</t>
  <t>Licensing: proprietary</t>
  <t>Contact: Bron Gondwana <eref target="mailto:brong@fastmailteam.com">brong@fastmailteam.com</eref></t>
</list></t>

</section>
</section>
<section anchor="iana-considerations"><name>IANA Considerations</name>

<section anchor="jmap-capability-registration-for-conditional"><name>JMAP Capability Registration for "conditional"</name>

<t>IANA is requested to register the "conditional" JMAP Capability as follows, in
the "JMAP Capabilities" registry established by <xref target="JMAP-CORE"/>:</t>

<dl>
  <dt>Capability Name:</dt>
  <dd>
    <t>urn:ietf:params:jmap:conditional</t>
  </dd>
  <dt>Specification document:</dt>
  <dd>
    <t>this document</t>
  </dd>
  <dt>Intended use:</dt>
  <dd>
    <t>common</t>
  </dd>
  <dt>Change Controller:</dt>
  <dd>
    <t>IETF</t>
  </dd>
  <dt>Security and privacy considerations:</dt>
  <dd>
    <t>this document, <xref target="security"/></t>
  </dd>
</dl>

</section>
<section anchor="jmap-error-code-registration-for-atomicfailure"><name>JMAP Error Code Registration for "atomicFailure"</name>

<t>IANA is requested to register the "atomicFailure" JMAP Error Code in the "JMAP
Error Codes" registry established by <xref target="JMAP-CORE"/>:</t>

<dl>
  <dt>JMAP Error Code:</dt>
  <dd>
    <t>atomicFailure</t>
  </dd>
  <dt>Intended use:</dt>
  <dd>
    <t>common</t>
  </dd>
  <dt>Change Controller:</dt>
  <dd>
    <t>IETF</t>
  </dd>
  <dt>Description:</dt>
  <dd>
    <t>A Foo/set requested with "atomic" set to true could not commit all of its
changes together; no change was made.  Returned as a method-level error.</t>
  </dd>
  <dt>Reference:</dt>
  <dd>
    <t>this document</t>
  </dd>
</dl>

</section>
<section anchor="jmap-error-code-registration-for-cannotapplyatomically"><name>JMAP Error Code Registration for "cannotApplyAtomically"</name>

<t>IANA is requested to register the "cannotApplyAtomically" JMAP Error Code in
the "JMAP Error Codes" registry established by <xref target="JMAP-CORE"/>:</t>

<dl>
  <dt>JMAP Error Code:</dt>
  <dd>
    <t>cannotApplyAtomically</t>
  </dd>
  <dt>Intended use:</dt>
  <dd>
    <t>common</t>
  </dd>
  <dt>Change Controller:</dt>
  <dd>
    <t>IETF</t>
  </dd>
  <dt>Description:</dt>
  <dd>
    <t>A Foo/set was requested with "atomic" set to true, but the server cannot
apply this method atomically; no change was made.  Returned as a method-level
error.</t>
  </dd>
  <dt>Reference:</dt>
  <dd>
    <t>this document</t>
  </dd>
</dl>

</section>
</section>
<section anchor="security"><name>Security Considerations</name>

<section anchor="information-disclosure"><name>Information Disclosure</name>

<t>The conditional mechanism returns no object data.  A failed precondition yields
only a "stateMismatch" error, optionally naming the ids whose preconditions did
not hold, but never their values — nothing beyond what the client could already
obtain by reading the objects with Foo/get.</t>

<t>A precondition does not bypass access control.  A server <bcp14>MUST</bcp14> require the same
permissions to read the properties referenced in an "ifUnchangedBy" PatchObject
as it would to return them from Foo/get.  In particular, a server <bcp14>MUST NOT</bcp14>
evaluate a precondition on a property the requesting client is not permitted to
read; such a condition <bcp14>MUST</bcp14> cause the method to fail with a "forbidden" error,
so that the mechanism cannot be used as an oracle to probe the values of
properties the client cannot otherwise see.</t>

<t>This differs deliberately from a precondition on an object that does not exist
or is not visible to the client, which is reported as "stateMismatch"
(<xref target="effect"/>).  For a client, an invisible object is indistinguishable from one
that does not exist, and reporting it differently would disclose its existence.
A property the client may not read, by contrast, belongs to an object the client
can see; the restriction depends only on the client's rights, not on the
property's value, so "forbidden" discloses nothing about the value and tells the
client that the request cannot succeed however it is retried.</t>

</section>
<section anchor="atomic-methods-and-resource-consumption"><name>Atomic Methods and Resource Consumption</name>

<t>Applying a method atomically may require the server to hold a transaction, or
equivalent locks, across all of its changes, and so a very large atomic Foo/set
can hold resources longer than the same changes made independently.  The limits
a server already applies to the number of objects in a single Foo/set
(<xref target="JMAP-CORE"/>) continue to apply, and a server <bcp14>MAY</bcp14> reject an atomic method it
considers too large rather than attempt it.</t>

</section>
<section anchor="resource-consumption"><name>Resource Consumption</name>

<t>Evaluating a precondition is comparable in cost to validating an update
PatchObject and imposes no significant additional load.</t>

</section>
</section>
<section anchor="changes"><name>Changes</name>

<t>EDITOR: please remove this section before publication.</t>

<t>The source of this document exists on github at:
https://github.com/brong/draft-gondwana-jmap-conditional/</t>

<t><strong>draft-ietf-jmap-conditional-03</strong></t>

<t><list style="symbols">
  <t>"atomic" covers every change a Foo/set requests, including a change that
an extension adds to Foo/set, and "atomicFailure" may carry any map of
SetErrors that the Foo/set response could contain.  Thanks to Mark Atwood
for raising this.</t>
</list></t>

<t><strong>draft-ietf-jmap-conditional-02</strong></t>

<t><list style="symbols">
  <t>Clarified that a precondition with a pointer whose parent does not exist in
the current object is never satisfied, whatever its value.</t>
  <t>Allowed a server to reject such a precondition, an invalid pointer, or a
malformed PatchObject with either "invalidArguments" or "stateMismatch".</t>
  <t>A creation id stands for the id it produced; if no object of the method's
type has that id, the precondition is evaluated as for an object that does
not exist, rather than rejecting the method.</t>
  <t>Allowed "null" in place of a PatchObject, asserting that the object does not
exist.</t>
  <t>Clarified that an empty PatchObject is valid and asserts only that the
object exists, and added an example.</t>
  <t>Updated the Cyrus IMAP implementation status: "atomic" is now implemented.</t>
</list></t>

<t><strong>draft-ietf-jmap-conditional-01</strong></t>

<t><list style="symbols">
  <t>Moved the examples into their own section; they were previously nested under
the "Atomic Foo/set" section.</t>
  <t>Added an example of atomically replacing one file with another (the POSIX
write-then-rename pattern).</t>
  <t>Added Implementation Considerations, describing a generic way to evaluate
preconditions and to apply methods atomically.</t>
  <t>Added an Implementation Status section.</t>
  <t>Explained why a precondition on an unreadable property yields "forbidden"
while a precondition on an invisible object yields "stateMismatch".</t>
  <t>Clarified that <xref target="JMAP-CORE"/> already permits, but does not require, a server
to accept changes such as a name exchange whose final state is valid;
"atomic" makes this a guarantee.</t>
</list></t>

<t><strong>draft-ietf-jmap-conditional-00</strong></t>

<t><list style="symbols">
  <t>Upload with working-group adopted name.</t>
</list></t>

<t><strong>draft-gondwana-jmap-conditional-01</strong></t>

<t><list style="symbols">
  <t>Added the "atomic" argument to Foo/set: a method requested with "atomic" is
applied as a single unit, with constraints evaluated against the resulting
state (enabling changes valid only as a whole, such as an atomic name
exchange).</t>
  <t>Added the "atomicFailure" method-level error (the method's changes could not
be committed together) and the "cannotApplyAtomically" method-level error
(the server cannot apply the method atomically), both registered with IANA.
A server <bcp14>MUST NOT</bcp14> apply an atomic method's changes only in part.</t>
  <t>Generalised "ifUnchangedBy" to allow a precondition on any object of the
method's type, including objects the method does not itself create, update,
or destroy (for example a parent or container).</t>
  <t>Changed the effect of a failed precondition from a per-object "stateMismatch"
SetError to a method-level "stateMismatch" error that rejects the whole
method and makes no change; a client wanting independent application uses
separate method calls.  Removed the bespoke per-object SetError definition in
favour of Core's method-level "stateMismatch", optionally carrying the
"failed" ids.</t>
</list></t>

<t><strong>draft-gondwana-jmap-conditional-00</strong></t>

<t><list style="symbols">
  <t>Initial proposal.</t>
</list></t>

</section>


  </middle>

  <back>


<references title='References' anchor="sec-combined-references">

    <references title='Normative References' anchor="sec-normative-references">



<reference anchor="JMAP-CORE">
  <front>
    <title>The JSON Meta Application Protocol (JMAP)</title>
    <author fullname="N. Jenkins" initials="N." surname="Jenkins"/>
    <author fullname="C. Newman" initials="C." surname="Newman"/>
    <date month="July" year="2019"/>
    <abstract>
      <t>This document specifies a protocol for clients to efficiently query, fetch, and modify JSON-based data objects, with support for push notification of changes and fast resynchronisation and for out-of- band binary data upload/download.</t>
    </abstract>
  </front>
  <seriesInfo name="RFC" value="8620"/>
  <seriesInfo name="DOI" value="10.17487/RFC8620"/>
</reference>

<reference anchor="RFC2119">
  <front>
    <title>Key words for use in RFCs to Indicate Requirement Levels</title>
    <author fullname="S. Bradner" initials="S." surname="Bradner"/>
    <date month="March" year="1997"/>
    <abstract>
      <t>In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements.</t>
    </abstract>
  </front>
  <seriesInfo name="BCP" value="14"/>
  <seriesInfo name="RFC" value="2119"/>
  <seriesInfo name="DOI" value="10.17487/RFC2119"/>
</reference>

<reference anchor="RFC8174">
  <front>
    <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
    <author fullname="B. Leiba" initials="B." surname="Leiba"/>
    <date month="May" year="2017"/>
    <abstract>
      <t>RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings.</t>
    </abstract>
  </front>
  <seriesInfo name="BCP" value="14"/>
  <seriesInfo name="RFC" value="8174"/>
  <seriesInfo name="DOI" value="10.17487/RFC8174"/>
</reference>




    </references>

    <references title='Informative References' anchor="sec-informative-references">



<reference anchor="JMAP-MAIL">
  <front>
    <title>The JSON Meta Application Protocol (JMAP) for Mail</title>
    <author fullname="N. Jenkins" initials="N." surname="Jenkins"/>
    <author fullname="C. Newman" initials="C." surname="Newman"/>
    <date month="August" year="2019"/>
    <abstract>
      <t>This document specifies a data model for synchronising email data with a server using the JSON Meta Application Protocol (JMAP). Clients can use this to efficiently search, access, organise, and send messages, and to get push notifications for fast resynchronisation when new messages are delivered or a change is made in another client.</t>
    </abstract>
  </front>
  <seriesInfo name="RFC" value="8621"/>
  <seriesInfo name="DOI" value="10.17487/RFC8621"/>
</reference>

<reference anchor="HTTP">
  <front>
    <title>HTTP Semantics</title>
    <author fullname="R. Fielding" initials="R." role="editor" surname="Fielding"/>
    <author fullname="M. Nottingham" initials="M." role="editor" surname="Nottingham"/>
    <author fullname="J. Reschke" initials="J." role="editor" surname="Reschke"/>
    <date month="June" year="2022"/>
    <abstract>
      <t>The Hypertext Transfer Protocol (HTTP) is a stateless application-level protocol for distributed, collaborative, hypertext information systems. This document describes the overall architecture of HTTP, establishes common terminology, and defines aspects of the protocol that are shared by all versions. In this definition are core protocol elements, extensibility mechanisms, and the "http" and "https" Uniform Resource Identifier (URI) schemes.</t>
      <t>This document updates RFC 3864 and obsoletes RFCs 2818, 7231, 7232, 7233, 7235, 7538, 7615, 7694, and portions of 7230.</t>
    </abstract>
  </front>
  <seriesInfo name="STD" value="97"/>
  <seriesInfo name="RFC" value="9110"/>
  <seriesInfo name="DOI" value="10.17487/RFC9110"/>
</reference>

<reference anchor="WEBDAV">
  <front>
    <title>HTTP Extensions for Web Distributed Authoring and Versioning (WebDAV)</title>
    <author fullname="L. Dusseault" initials="L." role="editor" surname="Dusseault"/>
    <date month="June" year="2007"/>
    <abstract>
      <t>Web Distributed Authoring and Versioning (WebDAV) consists of a set of methods, headers, and content-types ancillary to HTTP/1.1 for the management of resource properties, creation and management of resource collections, URL namespace manipulation, and resource locking (collision avoidance).</t>
      <t>RFC 2518 was published in February 1999, and this specification obsoletes RFC 2518 with minor revisions mostly due to interoperability experience. [STANDARDS-TRACK]</t>
    </abstract>
  </front>
  <seriesInfo name="RFC" value="4918"/>
  <seriesInfo name="DOI" value="10.17487/RFC4918"/>
</reference>


<reference anchor="JMAP-FILENODE">
   <front>
      <title>JMAP File Storage extension</title>
      <author fullname="Bron Gondwana" initials="B." surname="Gondwana">
         <organization>Fastmail</organization>
      </author>
      <date day="2" month="November" year="2026"/>
      <abstract>
	 <t>   The JMAP base protocol (RFC 8620) provides the ability to upload and
   download arbitrary binary data.  This binary data is called a &quot;blob&quot;,
   and can be used in all other JMAP extensions.

   This extension adds a FileNode data type and methods to expose blobs
   as a filesystem, along with the types of metadata that are provided
   by other remote filesystem protocols.

	 </t>
      </abstract>
   </front>
   <seriesInfo name="Internet-Draft" value="draft-ietf-jmap-filenode-20"/>
   
</reference>

<reference anchor="IMPL-STATUS">
  <front>
    <title>Improving Awareness of Running Code: The Implementation Status Section</title>
    <author fullname="Y. Sheffer" initials="Y." surname="Sheffer"/>
    <author fullname="A. Farrel" initials="A." surname="Farrel"/>
    <date month="July" year="2016"/>
    <abstract>
      <t>This document describes a simple process that allows authors of Internet-Drafts to record the status of known implementations by including an Implementation Status section. This will allow reviewers and working groups to assign due consideration to documents that have the benefit of running code, which may serve as evidence of valuable experimentation and feedback that have made the implemented protocols more mature.</t>
      <t>This process is not mandatory. Authors of Internet-Drafts are encouraged to consider using the process for their documents, and working groups are invited to think about applying the process to all of their protocol specifications. This document obsoletes RFC 6982, advancing it to a Best Current Practice.</t>
    </abstract>
  </front>
  <seriesInfo name="BCP" value="205"/>
  <seriesInfo name="RFC" value="7942"/>
  <seriesInfo name="DOI" value="10.17487/RFC7942"/>
</reference>




    </references>

</references>



  </back>

<!-- ##markdown-source:
H4sIAAAAAAAAA8192ZLbVprm/XkKDDURlhRkarFqMVVRPanFVdlhWWot7elx
OTpAEsxEiwQ4OGCm2RpVzEPMA8yzzKP0k/T//ctZQGSm7PDF1EU5RQJn+fed
s9nM9XW/qebFP746fVM8b5tV3ddtU26Kd1XvysWiqy6Pv3SrdtmUW3pt1ZXr
flZX/Xr2b9tyN1vGh2YPv3Z+v9jW3tO/3x929PjZy/ffumXZV+dtd5gXvl+5
/W5F//bz4o+/f/zQtQvfbir829W7bl703d73jx8+/ObhY/exOly13YpWafqq
a6p+9gK7O9+Xzepfy03b0A6HyrtdPS9+7NvltPBt13fV2tNfhy3++Mm5ct9f
tN3cFTNX0P/qhvZ+dlL8hU5+VTYlfyiXe9a1Tf55253Pi29L32/LesOfVPhr
Xizo0fP/ttZv+qrcnizbrXNN223Lvr6s5vw0ADl7/vrty3nx9tvnfGNXN+uR
h16dnn1nDz3ij//6/v0b/uSbR48e8ic/vHz24vSf+bMn3zz6Y3z527PvXn7/
+gXtcjZ7cRKxs643VdOuKn7y7NWb72bv3p++//COl/jDN08eOzebzYpy4fuu
XPbOvb+oBPmL0lfFrmsJqu2muPvpU7jJ58/38MVlvap80dPz37btA1/1xbYi
OK8KupxbdhXdrzmfFoxt/otwVtArfdce6N9Fu/i3atn7EzpXX7TrddX5oiw8
fbWpCqKq5b7rqmZ5cPQ3vbOZ8l6Ten3WvOuJgCZF2Z3vt1XTT4uri3p5UZzv
y25FizQFfVh3lW5R9EyJ9Zq+OTj9rF3TcqV8V1yUvlhelM15tZJdri6IJu0+
tS+6Ci9VqxMAiP5d/dxXDYi8KFfYsVjXTdVNi13VzXSDhC9oIaxe+y1d9rRY
bmo6X7EtD66r/uceB+Wj0Llreofguqd3hEuI/gxmgPmyqlZF22wOuA0O2hMM
CPKyJ/FFvaHdyn55UTEwK75o9fOOT48V6IT9obgsN/uKeIS+6Srv6as9AM9L
As/uDdZ4LTcpN4TM1YHOgVsyfvV0QB7DI5BDu+tr4v++Xo6hsPBLOsCq6NuI
aQXXf/zv/8O7AyB0OgCoBcKYCYrJ2Xr2CkeaODpwAC2/heMQYoVq6VQl43QE
Uxvf6h2YRnBUxs6k7NttvYz0pOjY7QhReNQpORmdlwmh7pu6nxdVTWfviuqy
6g5KSUXdF0AvIY+4pPxIK1VE5Mt+6ujADYmuYtUyBJ+32wUD9opWYSAkZJRe
F7RJVyJpiQMIGTlFIX2w3W/6OpCfHIJvQu/4cl0J4VxdVI3eDYgg6sHJAUi/
Jx4qvSPYCETo/BCLskj1syxJl7lqWVz6ExEe23q12lTO3YGY7trVfonDiigZ
iAYjobopMoGCI+LigVGKxUGZWq7pRaJUKk+qTJrkoiTSIoEYghaENEKMc94x
UsENgqVckFaREyopmGhYO3xYLpftvum/IjhjAfr/DtwEymTYBapklBPye2FS
XpF5EX85FQx+L5RnJMxiDRBatmXnK+a5Kt/JUAPkggiL+8QR94tc1jk+gT46
BYTBNrIpQEdoLxZ7f7DrMFHQFQBHvgaRYkU6yztfdbTJrCbar0sIlrCo0hBf
rOw6sDK2b6qrAmoysLmcfkm8pYS6qPqrCpSpB/oKQrdcMZprgv1VV/eMTnzs
28YrJoii9w39h4/Rt4wOE/v0p4KUgLdtV/Uaioeu+oGFXYpxkkjQdSzulLXV
TsEyZEe0hPQNHcjj0TUzNlC123d1uzcFUeNcOHFXEV4Yg8+FfAl32y3zXwMR
XhIDdV17RZgCdksyb0hDTcCWB2FyBUsi650nKV6viS31fmcCIRH6pLBWPtKT
p29X1a5qoC4mJqaVyzwxr+NzEBmDDvDhQM5mggfqH99D8+N6OA3A3x9mfXkO
0FaM5h+qBZkneFoMFXp+DowmqlDweKwHSBX6dt8tg+Amg1OEcRDZxTkRd1cv
b1ezTCcqek4cyYRaBRMzH1OjqkIR8Cv7lKiadUXffiStwUzhewCZhfneE+0D
VjdpRwJnLtoSdTkP5C0M4B1IO4M065Z0fZJky65emHZW7Na9anXBqOp/gqdI
uZ6oBhQxNXQVwrKAHESivDWgMaY+2YeExY4F1FW73xh7Q25dgIGce1YtS4LG
QGYDawqFwJwk6cl0pw1Fm8tBv/IJ/J0dsfoZhgPtn17fk7lNay1JttRRJ5PW
xTXALK1qXchYkXCi87a7TbVl1lNCmIp+JUyDfPhJMt4Y6mDUU9oKaJgWJk2Y
Q+hOogyJ2IkectSyRUbmk4KTbV5abWouTqalPO9fQ8SZViRzj3mUEUbOUUvK
lsxCSFG29Ej7EGe0kEC+WJP8jPhUBXQOeYw7BTGixovZfnYZldAutUSC+leV
woRQbjaztpsprguz3J5DAKqVXnuXyE5TkhDtm/qjEEWibwGlBeECWvSy4sdg
kAQJYMIkt9eLrmTDhG7T6FNByyWCnXwWMpbp2GpqwUTPxUcU37/UAITIJv50
5bWGHxnQ4EcGcHlekmPZJ9pNdaYns4yw15FzGDiMjgzkgPvDpcwUu+sJiZ8+
yZlIghJt3rkDX/wSUIKG+eDFhOKLvtCLir1FHnMBl9kXk1cf3r0n5PB/i+9f
899vX/7Th7O3L1/g73d/Pf3uu/CH0yfe/fX1h+9exL/im89fv3r18vsX8jJ9
WmQfucmr03+ZCH1OXr95f/b6+9PvJsz+GTpKeDstqXvI5Koj2cfA807lnNzs
2fM3/+//PnpCYPgv5Kc+fvToG+I2+ccfH/3hCf0Dlo7sFqxadt0OAHJVdlgF
UF6Wu7onzE+BPH/RXjUFCIKAev9HQOanefGnxXL36Mmf9QNcOPvQYJZ9yDA7
/uToZQHiyEcj2wRoZp8PIJ2f9/Rfsn8b3JMP//QPG6L3Yvboj//wZyc0IvJ4
crYCIhNZy0iv+pdkmHSGSaX8CeMtWu8uk4Ps1U52LWN0wiKz+Md3r78v3shH
AP3eq4PDAjDZ1Sm9J+tNi3diTBW/O/ma6b84VUltouB5uSsX9aZmBa4LgU32
XTNH9GO+I3G49XMEQeaJjSAQgMdEoqkSy7gqJre9NomuM1N05SbL5ASTzNLW
AMq7isNghRk27NwjEubZwiePQh2EyqVGjMmaRXVRXpJt2aVOU8ZLKrXFf+Cd
STCHczItE5shGrLd9eYksaYzqzgcSFRmTwjyFyyLCtHumQO9wOWXm/1KbREX
QHAoPrw9U8gQMCEhQTEdqTKofRPOdOAf2Ps0a4QNjXJ1CUNAtCgs37iqORxx
CURm/HAPORXbZvQ+HYVtBQbARdsAhBo5+tBolOfZIRH2ZK6mQUwCPuxc8mDF
sBi4sHVqW4jHyTuxdkm3GyoVdzcR6iFkkBhdQanLU1BrU/K/prDNaFdylkgp
T83VaM4dI4xMmrKYyJenWOw0vD0pKvBykW7MvKrgN3Enh3CpimW06XGCapXd
wsXEbmwK4pn+RBgrwR0cV7HX5zh9cHyDV8LeJ96tl/sNCezgJLPoMctY+NTs
PjgMJNTxlGfuEdMjMXCP7T7Wn3eixDgUL38u8ZRzf//7393tvD8vPn3mR92d
LF5uhPHpzpB8hi4MBwlxyHW72bRXbAEoVXiTaBzThqOf05u7e4NonJMWKzKy
nkOu/+3HRL7+7X81+83mbz9NirskSEoyRuZDmXDPOVAF3Rt4V1FWq3uWGuMa
a+Lz524LJDOYuTAxU9A9uqIqCTt0y+4gcdXsHQ5LEeOvEYni6GyIbdI6GWPA
zG2yo5hJKO6OYn/m61WwItl1oYXIa7+sEi+JLDcF1wnu/TIEHGGCg6aE7VWd
mVRL9p4mi5Eno0egpUQSl2o+2gLMZcRCRDEx3CMXOl4b7EkrsfacAHETfSEG
dYOEt9geuEo4hWQZnCTySCRcxQjpqm17aYAML4tjB/1A78/a3T0JRBIP1J5w
szenhmMFWER3KEULR4aThciMIz6KEa+wD+xeJulz5kS6nmfTrLEA9030PR3Q
n0g7WsRgK9qADs2BAhMx7EgacI1CLF7AgpIuriRGtEc3f8dhqyPylFhaIFJ4
OnRk0VyKyakrEq0oKFMyEilDhhHLuHpH7pl/sHv0ALHTSTxIXJ+W4qBcoGD1
V7MVoiligUDBg6gFRhqtY5rEa3iczkjHJZ42yN3t9nS2J2D4T5/Ui6Fbz/Cx
F6+DrbqUBmsNhrByyGIgCcWlnGYYoaUYJ/NfJARw9RQSSs90CV7MIzZJr1/W
vib/MkgEtm2mGQoWGq4g5kCqZ1FVDS2kfrnKgVOTienF7k4+fZ7c410Yejid
XZZPObixXdT/wpsOcH50U46CXnNVuDJqMpD0f9a2JPCaVNqvyTSpWMafrZFe
raZZ1g7muqYDjhMbCaOLHGOrhZYS5zjPeCQmjGU+YMCQ7PqI4JE9hvDEZgOu
yxxd8XNfBlIs3oIUSbseUadzj+jtNwlwPfsnNznjSINBGbVGsRJCA3Q5N1qG
h7tgxstdpkQvEj9AtHyQhVAa4mu2CpoiZICaIEKTXKJJHece0y1e4lDw2unh
oYWq4dp6lQXP7HS8rISxjOsD399lC5QwPMHTwYu7Z4EeWYgDXCqEJMhv50xu
4dOcJTmcHFg61v7xeAkVJPxvy+WMyUYeS2/eJWW9I1msy2Q8hPcHskaQOlXh
gA9GueapYN0E3Mhuw50sXZfIXFqu4XXoaquNhGVLL9ktCbGpc2yhQeDybsn/
oR3X9c/BqL5DYoagy6uxViaaEO+CnqsQSNOglaoxpsOV6ouq7OhSnYEdxr/5
qQIyohRzoG7Rt81KLFFvzikbgiKPiniPnYTToTvPUkGtbmhMq4uRwkwUQsb5
UohrQrfalTJCL4tVveb79+obAK8R67SFXLGGmwDBHsX6uMmZCImgHAPl6jVz
WrLsSZZ3LYapezObA26kWEQxo6LAkADIYH1ldj1+z0EsM6FUWfFXShbp7Uh+
fI1UVhNirlnYfK8iPTjlLLCOU5sIN0ML8Q6B1NL0SJ5Go09J7kuyreCo+nDr
WlhiKMwgOuL67PuZjagCrVXrOphTglm17CF1oDEhZK9qX3Hya8YKNDns3VS6
cOapF9sc2hTxU+Lnbspa7t+FmCwYMduSyuhLjrSYPqu3BG1a656RQAn3TRWG
AQVJl5i+iUmV9FjBfQftVpu1ZiMJh0+Eg8rU3yiPVUEGYKGdssgtOpTd4GCZ
cxJ45ghLPgHlttwgnWIsIwDhxVjpi2lZDAtjNKFigQwcWozMU/NtLQChJyNp
y8r4Ve23kmSUryMj7psodFPGTaMW0FpSsoVogqSM9rW/GLNy2fsI+evA1pJn
XcJQ4hRSgFvuLBB6fqcC/yh4hODoSMWAGCILAq0CabYhE2mjpUkCBXqVrKdd
y6l8wj0/jdeMaVMsED1Vy48+22xdd565wc7djAa4UgD6p1BiiqoAB0kRDtR+
Uu4UwkvjaJO8qRk7nshoVakVJ/klst1ECzpH91S/OpPHo0ZP4nAlxoSWP3lH
7L1EglNsOPE/cdB23w9Clie8r8iaG/R7Bm+m+IHFipxV0zpTWdH8S6qzVNDq
YbM0G14HsAbM5LIqMwV1RjXjcCcNzp9v9XP21o5KQkx9sya2YHAa+rCKgEHC
r8wsOD4H14rQPevzZh4dhOg/cOQQ/oJW2oQIGZu6yzJwsElMMONV2WTZr5D0
JGEBkyBPjnJgqoHeYKlV7DblUnTTFpD3FYJ3fZVaQJZvdcFYVu07FU+AAc6m
xNURFQoVM+OPouDTnRwDCKqLHXMjFwpvIfSfVdylOHfX8NqXVBmUyRlMWDiW
PGJJ8u6I06irR9fm1SfIUexISLDLwqA1nWxItgemzrfMGAM/KGEEyXjmm2nS
WvH/sSElyhyg6ILgiOymsWS5OAn45ab1kuQ2U7/sy6SUgskJWsFnMlwqJdy6
ksAZkwrjXKNRhdaIGAmql7eqljXHci7aKy0LAllyYM5EBJkymnOAcJTMJSeT
J4yHVbXYn5+HmtfkcQ7YCpI0Uvu3nybwzN+zoe1zU8hbfCvzdK/IhMrlV26g
wjk3E3XGt7cUqRiVDKlpkJgKYGb9xipDE33rioHyRI4IgElVr9iSGakrKeLy
LSIFnJ0qYvCKs3pSZhgD6RoLcO6HoNSOcvPwLkIQIxXaVj2VF2q6Wws1R8IW
ecFmYQWbLZf7bVNP0KhH4g+86pGWSIpA5B8AtEQL0jJNOHIh2UYADrdgozPT
Lm1IqQ2CJsI6ChVzdbJ32Sdr9+cXY0UITFsaoHBJdcgpQh9EfH0HI1mOm8sf
Fj9gTKmsiRcJh3Ct+UCQD7ECnAMKVsgbTXfCF2rsUNqa7MwmNgKoLuSSNfqr
dSVsLnGR9BKQP4oDmePKnnNSjpFmv6ZiJOq7QBZbk2Qf16Jg6f/T4kyuu1FX
NxTexGIVidKLYSolNnAjRfmjAlIVn6VMBAJTK7hlJWEVt3xLrspN4HdqkQ2G
S1IAVm34ms+Y5p6lTxXHT53y2st2s+HiWa0HAx2A8pPQHbtFZBLstcLSqpej
3Cd8rUnv97N1V1XDoqmpSyIOQa+JW+mT1HCLMtRq12tJqZ3gygQD6cFy4wSp
Bl45FWdibcG6D0Lcp1VvZGVKDWfN5UMwptUyE0ZnfTElR8IjeEQPrOFPSNSz
N8XdKnv8kOZFp5IbFxFM+C24Di5PmlhIU9fhuwhdWU1LelSjEMZ5x5KV3xxU
DFmFdqgZ+pYe3HdVNII1thkLvK1jgx70aqZGHwr2x1TZTQjDs1grHQNXqhtY
S+Opy7rVSrPAreJfm6wrrLZE7T+229nYcBIRgzNAjPdcwieoRqF/fWAZav96
YdGPyWBtyV0628KbOT60X2IB8vXWvpnq7hq/d9xUF4gqyNVsGyvVvtUu/+WW
JMuTUbvRjfgKYCGGGWu1PmpYeF5V/3RgbpRcOcdc6m53FcxdHoMGb2A1zFqq
Le9+JUa4caaEpKX6kPmtlPCtqiPRceNbqEiE1bEsO9LGN1EUmD6nKtCRH+ho
y4tH2gpJnyF1uaWUy7YcSJL6+SRYz80IpdJmOSBKDU+FlDdZg87MPxZeTDxC
GWZPB45aa64ddv7Kpwx2UV5WJj/wJqosJYD3FEscojmpsK7yWG1iNqjOcldl
0hCVlpNwhI8LmzQ3VmmoYi1I4pRLw70FVedFRr3jdz1RDR35ucTIuIyliHUs
qLDgb1hhf5Za3VBAVNxQQAR1oIE3sQ5LzbxrvCNW2jAOLJTFNhdLmAiJ2qfF
KjGds6gOxCxmXTsIfM2NMcjYLcbaw0ja9bLE3VzNA+TnEiupQkI1zxqG3aJc
fgSTZWUUkcGaWbx6WhKW9XlcW1YkmO6JvcyLiEJkbVDoiVbYJ2ew5dEAhq3f
d+tSwt6BQkJMMokXuNz/gHQ6b2olT4FJDw639MtEiAOSYTJsXJw7CbWXMcaV
q8ItG/4BtNpyBZAyRLWVimuyNsSUaS8nuzRaW+RFAbfdspoBRoRZ9FPCL6ql
vZHj0hHwm5L4xB9I3nctLrfipsINsExe5mT95PFEaEVfLRabdlFM/vKv7WY1
EQJALkRuF4xc9DTYC/Qs/VMLO2OhH3HsxrBgj8YEvBSf2yGTPkmug7OQFyr0
t0qGierIbB5E8N0Epz5bRbRY3yqjhousfvyxmHxLF/+e7s1Jy2nxifzGiTYl
0cvkOe8fTVB4MdCQ8+KTQIr/0K3mBqTic/GZX9JUyLyQ/133DgPLFTf9b8Jh
fLKR8cbjh49/P3v4u9nDR+8ffjP/+uH84cP/wZu6z6R4Hk6Kn36SKjKyxgSf
0rmT5Pf0pOLaan2Mym6veYJmiBBnJrQicpVh8i6ZwgHoHPe8mhIFkx+KvbDU
5J4YrEfOux/2jhyxhsR3pBrs9hhWgt9KS4wZsTCEAL/8HcaUqDv68keF2E9D
WL6PUSUL9PCTUy673Vxa/ko9EskPwa0rOV94kMKpjuujUOsPM8SagKQawiKL
YEZNkMburjt5RaA6+c6pRcFw8b5MmmzqmPzjfB63cHH+XBC7qi7rJbNSKLJG
YzgytZwf4edtUVmpmPxXcgCaSaHt8miCT8NtWrAiYnSiD/kH+hIiwAtUdiX4
eYlevV/DfK/+IP8dbDIvkGUPDKhgMg78kd87xu2ZVWHEyyZp3m3Zwc/Xu4/k
epmGk3ZuF3X2F+U3tAIeR6utdBWDClaC99Mk6yc+/nnTdtybNOy5ydqlsjMm
vB9MJs1dZYlXawmdutBY06excw2Kx4RjanaGAgkx86wSiowDgIhI7a8c9YlR
w20rNdfnEtkg6xyuuPfiXseWRLq0PuLytjOkYCRHwwGf+vyiz69TXv1G0n71
tfzXX5BlCzf8waJdPNiWh7fEJxOeJlHdIPhHX0/IdVTcqJeoJckGjmekjhMo
wA6xY3ANDk4yEasmoDCE/1pjbiGcNDOOM6Ks07Mfrm6v4DviR0B8zwUjiQTU
+TlM2SFtD4QWhxRuqd7RG8NYyYgXpQMcGxh9W3lmbBAE+aVxDsQR/WnvXG6Q
rMUYUtmekmHNGShRpWqQWD1oTaft2+6Qkp7YWeVVcReAvRdkpfSlhoKlDVfc
SZ1qE+cnsKUkoaAywWMBjvmt7Re5hTwPGvh8jTEiRIw3uLCUnn7LTpj//8ri
UddK1LgVYcJm4Vty2k+umXyH++Q5YML0l+emUwJSagSWexTZkJmCxCDHwXlb
rcuos+hDiMncyDLo06HP8vIccMtYbZmWDVm0OCxCanzTNmBZKUocsoUTcJBU
6blbfSKe9kn/cz8ZyuVKmaWbyC7ce9W3LJqlyInZFpA243FYObWwNnThmih0
fiMq74KQvYZAe3nOSDq57XUmdWcGtQBwQDdfXtPgAOGPVbXzhUnd2ygg2Rdl
S260ljhgPhYOj67gkzJzmKR5PvNIXAKL3GgjNW208H67aJBAb1NaYL7D7fa7
TYsxBhaggIuIR3IiinwaLNVAHVZaaH6fytCSibjtdoRp9kLsHJyZXHNHW92s
flsxaRJO8tHyVX/x6FiC8nH89eItUBotfLJrzm94MhWZvOzNXt6Qs38VYTot
tsmgqoWG6NyIpqBsyuiQzhdx1Fl1TeOMFxWv09wsPDJQMewCRiIzwA8wo+Pg
BTSLVDM62MxflTsIvDjnhPe3irqY1uEyvmD0fCSqQqQIAXAVUcokTskpxJkR
0kqiD8Ncme6qEDwq6HMTfW8Sa/pCYk5kDzthksAVFSeBKqXWGxW1rR004pPZ
1w/fP3pM6jBqRKaJ1A9Qp9qsnXhC7YxLT2GpO6uQ5Fz6UdNF3kSPm9mRY31p
ZgZ1Mtli6oBxOkwIE/KcmXQYSGxGFacYUfwSzdU+VIqIDNq4OOtK3CSJrllu
ip8O2cxPd0LOimxr+jhEvIhLJiXZvWwCEHBEBrL8lxEkk0X8ligWh/Py9RRB
bozCAFXqoKKCY8o1YznLYqpZooOOQvYzTGLS+Uc6hCGdtfL0aIjSNElvj6VB
Q0UFvmg7SeFKAeIgmQ7LWrOfrIVxE5HPtcVAmU2w94nLso+xJpcbfJg4kMHE
ZgJ0pAAkuZ6XQ3MVcJowj4l6lki/RnDrocQPyzX9J6kSLnM9n6HSTN7JIn8o
pQZireJY+D5DSaVZTKjlSEs5ONsSLNJUAtsoMRkxJGV/2vECz+BomooEwKSS
ajzjNUjqYIBGw6XN9SrjD4vCapkb8wHX9gvdfbqjD3DyQ2YJIUGLqYiQ7m9e
vzv772mAXWb9tOrWpGFgbursyTxpu7I7ON5Jr2U2N1RGa11uLXmSSE9HLd8q
y5QrRCmQe1ZQct67hURGww3Zmry45jvDFzgM3XGq3XVlyA/wWc2+ISPMGX9H
4++k3+5IAMRhR8nNNF7TRbmQmsguC55roPWetdjwQWUshYVRfxtyv8b0/bLw
9K1m8CCa9iPf/iiO9sMgRzONVRYQNFYbwUWRKqXz2ogoE4IxKintm3tJ1LNW
muIYyKRYat9p9OMsxRYN+AS9bKLwGBz+dxj4pva+xsanDqYOizglRVEkR2Qw
Wqth8nHG9TNJ3RFL0CMZWdwgI9G8oMVwOF/TuoHpZwIEOjAUooTCV7a1jhLd
N5UB2AQjRlTV+H1wLScyiSNkBVi8a1Pl9TkdH1jETIboBKq58DSGsadJDv8X
1o2neKqjXefGioQ5G9KkhcXRHiFKEOEnZHb38T3Ob/ujnAZn585sOoCYVeTR
oWO8E5GZldJhDFVaB5EknWGyhjEDR+jRoQcyvcHSo0sk8ZLaB55EGmdVjjfL
ByVTDipbzcITN2zQmh1K4q0lO2nAnsZBCoN2ENYKy3Z3cFwRmBQncwh5057T
ufnzKnaGjTQVWXNDKXTIY91gDgWDytSJFhVad9dS0oj+2APR1r+02PVlGPiV
OBs6U8UnZZMS2uCAErdYGBiGIMOhs3bmNFEt9c48Ms7Ghm0JUZj3epB4lJhi
JyFhkU1vG205Ge9My3sS3FH27WDVFSijEPa5woc3NnJr9ehJQr9Sjyyt3Ior
lWWKipVNmZMIqowh4Ykw3AJ7UZUECmdNQDpvUw5LxL7EFLNk0uBJmLkTb8tV
mtyDBIEKzBO5rfebIhNQITien85ZdTQYsV0SV4TpkYO6ukElE6p6knIIF4qP
0k7X2NqpY8PyKtrxJWsdDBjqaKU4NeEfui7XKRCNl0uTR3ek1AXnecVn8UnV
S4IxlB5oyWq6BNcM4ogDiWSuwOJg8/5gcYZEWOCQUEKrJdLJ0uhsJnh3OgLO
ym+1GQlRBFdKbCwt1CWDiPSX1hWn8EAVkkSRSmtx4kQq/C1FRrK5FK/USdEi
5/Jy9JShsmfVapEGakpAfAiXxNrmICe8mhdBUhzPNwoZ7WtrcDAsKKlF+nxP
pSEKtYSe/JimQTPGnpTIyxdn71+/nRc7qQeRXJs6eWo8aR/Cbr8IvTNaa2xP
gAQ71QmeF8Zd0VWRkIG6AYoIG+TtkgYS2VWVkkpCsWrgG+PNXSsDGa2rNx/D
LiIKJVCll/iJDCdpvaTC4zi3T5+S0ePcEv1ejDnrm0Dt5vDkNu7Kbo1uJZgm
Kx0c6n2tRhhmzONxREvRvuG1Q1lnM9b8j3ObXMMD7Nk5evvtcxDVG8EF4bSK
wZSNxnLbtRaAh8Hc+Tl5mlwU8/gShtiq7bxwo45XxRlP3Lf7DoJlSwhGkTm8
Ugj0kPMgbIiLhmjMWt4MFUZ8KVZbBAFs69RG8rHdl3ZjaPDYxnqxJ/EQhnSr
iglALNUe3e49x9rcolJe3wuIFxxZI9IoSf9z4fAl8SEXYx6RGUvMmgy6iuix
Q3HEW3UQuYB0dVlrhC+CWaT8cCXoOWm7lqD7oSPyPsNMcne/eN2dk6r4dwnN
Jd8BwTx/437xIlLVfLxt08Qje/skD/LB4T6eyCay8D4nxbXlcGmrEys0rIwM
rl5J+8rjxJc90Qd+uqDehp4CQslwXGhSxalygg8pU5ZgMdEy6qSLVPxKYk71
+R6hIalWKDhMuttDk2JO7wmB6DuuWCZ8boGruj/Mg3c+1UURhqmuaKO7F32/
8/MHD85JWewX+I2DB0vAo96WO/lrhj9XD3b7zebB7x89fHIPW9RLSNXmfF48
e/di5vvDpqKPn6MydtkPfmih+NP4jyn8WavY9ccXjvAfvrkF6yQA7NGvRIh0
0J2Mdw3JjQKlRtKDPm13PL8tuxUEXVdXPWIov+Zexdnp96djDoj88kYsYX1b
nddQv1LTgixpOpuMjE6swxRoU9o4jI6XlDiyF47W5+ZrthHhvLKVMMmf4QGH
siKZvIiek2byFyNdiHPnkpW/x09quPkXzGR8lykhG5uGd7OBh3RZk11kjOJr
iYTRrmIqPpdhtRukKfWnR9Btwuhk3tphIvlSepki3I82mtK1vL73+XNEixRb
P4czd4yWPAD4RYgZxAyHe9jsBv5Fhvj5L8DGYEVcNNvzV0E05TX68DQpgx8f
FIjvYMWjFkfiP7HePOlCc0VS0iQhkKdJWwb0HHeYFwT8pIs178OQvgtH2kfd
hREq+iJ0jsv6L+O3cTVxjN6E234r9I7u/duiWer/b0V1bBGLcRMZ4pOMuT+a
ePmLMY6RW1+C8yIIglzoopfbWJ1J4yyxt15IcyxzynspJxmZNm9pgLxDmd0V
bdjInN9DXW1WaIfkfoRrag9tOPWGa6ySppDRnuBVvXJxoAPg3tiYOrLJ1JuX
KQaSUk27FpK0oHCntfu0C25jYb+oXIUchvUmJ73UJ0fFYcEiXhx2pbcKQhsn
fjSFNE7T0ZGDscVMq9TLlTkyVuOYxCtuHZri0mERvB4Hx3p082YjCvl3MGKj
RxIrt/4KZwGBsSlY6XTGMHCAnegwQYfHNSZTdBzu9jS0OYbleL+jPhxNyIcI
K9Hqol6tUMkrlOMsTSMvGY0mxqcP7f9tVy4l8YEZ7bKPEgs5ZOMzgHShODzG
V/E3G2oZEE+mJ7l+qEjZ6ATImweGlcPxXe6W6V02vWjQBTfgJXS/2Riuexpk
LcMK0uqoq8ekOTy90NjOvo4NkXEjB7WCcJxBasjjwKqNTdm0GQYcjuDXQLUn
zDIJtcTfhdIcbymFWMwzJfZaVEgneK0XPfqZE267IXQ8tdQEuYDiO8skDQ23
WXNp+J0VLh6Vpmf5LkyR/srrlEuEQVNaS8cyaJHGolVxr2NQEb6sMIajj+2w
gTBtEJZSk6VALtorrXtSp6qrqzxRanEyLP/WJmtDou+3O2mADyG18li7aBQ1
kTWh25iL48o8BtZ2Lvk9KgTx4KMtu9b7ke55nZ6GSDoHqDf4bS5rL1LlySji
rWwsuLfqIPmlA4sYmiXEozGyUSgaPdnU+uMEegULdyejkjmDtt8uqi7O9ZXp
q4MZLm74824gubrZS2Uy4Kk9kXmrnwTLh83EaP9SDYtTtAqH9PcckLgmdNGj
gttxRCapmOPRrBK4llgEOu68hE3Quayv2ITZ/LfMELHi2UusrjHShh0PGdJs
qh0VchzFe24V/L8+bkf4lLtZEC1MhbYppk0hvjWBZe5G3G12Ih/I7y6eq2t5
9NuLD8g9vn/zbzPevw8XOphqXPLj81EY5dCW98k4ttiErwGNbGCFzLgOUyum
aawleDhgP+nL5RInadouvqS1tshaa5kHyuYj7/iq7D6SeLhqeYAV/0RUWWv+
qkY09hbAPBbAPCc65dLmQgc5ZCSn+vbLBg+7sWliNw8UhhxhwYkAzSn88Srh
N7ZYdLDf0aRiU2Xp5DPpE8AgYBvtdjxI2Uqyj6e2wf8Ztg3cH4yxPJ4SWfeh
8fBpPr43m6f6FRy94/mQYxmxW2Y1MuBdkWrjVMqEQfnJ5il0tTw7HXlU5nO+
pcTOfhIpsX6PJhufjBDQWBHw7ZOEwwj1rGaAuEtGY2rJI/bTRnY+VhIKHcSn
JUEwz9r8m/YqjXLeziKPhEVekciw32qSNldE01p1M5B+UGGY9pZbSRf/9hm7
jBxiVB6Z5DOAJrYCI2pwacZQ1OVS2iBVdFrCI1yqRVM8BJeLA2gvLi6aochp
pgUpWj51L+50Y3XANP0lrvBbZJyB5d+gEkrlCUfDDKEpUUsQJZfIrjmaM0oB
8vJnurH8VOTFYdymlg5B1ovBuBSHM7XfABAuqhld48gstgWOZcKA5vMyxsFw
F3FMkz5uNsOihwWKCFNfkuKYCy1UB9JCHakI4GRwSmCtp0kllvasst4t46ye
2wn+oRD8By6WF7K6aruPqBI679r9jhiSPHR0WEuG25a7Vj8HHhJsJ+G/9Gen
gvqc3/7zGzxO67rJ3dPQLK6pW3/NdOxQwESLaVEXsYfUixoORkcXxd96jBZg
Iz8WYEhKWGss3HkctxOWHablY8zQ8WzkMKgihAnDrxJeG3s73gu5jaPgVDJD
7Mh3uDeVMhKL9RlCEBA8cdf+rMqRgZxcLP8FlfvFX6SGmlNlw2CG/PQJCe4x
lj3kmjb8AECYABuNOHMDkjvG7KU0QQ2G+0EjxfF+gwm7agK1nZlmhA0WDFpS
xspCxmCyfh0LiFmEIP6q49CRL5LhQe2XTcnUSRbxstIEHH8aoTka9vA0dtWg
8Iz9+eh5pWVBXAcFjhmbO8nhym1QlQtYsB+zH/UNl+FsvI1ChfFaXmpRG35v
7yt/40WzICFb1VZLEVvnETH8MvGkEu+Mf9N1ExL5+hu/qMhw/wkc6cPmPX4A
AA==

-->

</rfc>

