# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: address@hidden # c5t6kwjae2hznq8p # target_branch: bzr://bzr.savannah.gnu.org/emacs/trunk/ # testament_sha1: 4cd4c68f62bb48cee2f221b129164f70bcd611f9 # timestamp: 2011-01-09 17:06:19 +0100 # base_revision_id: address@hidden # 1x68s956czngphh2 # # Begin patch === modified file 'doc/misc/ChangeLog' --- doc/misc/ChangeLog 2011-01-04 12:38:33 +0000 +++ doc/misc/ChangeLog 2011-01-09 15:56:26 +0000 @@ -1,3 +1,8 @@ +2011-01-08 Jan Moringen + + * dbus.texi (Receiving Method Calls): Rearrange node to mention + dbus-register-service and dbus-unregister-service first. + 2011-01-04 Jan Moringen * dbus.texi (Receiving Method Calls): Describe new optional === modified file 'doc/misc/dbus.texi' --- doc/misc/dbus.texi 2011-01-04 12:38:33 +0000 +++ doc/misc/dbus.texi 2011-01-09 15:34:23 +0000 @@ -1244,9 +1244,69 @@ @cindex method calls, returning @cindex returning method calls -Emacs can also offer own methods, which can be called by other -applications. These methods could be an implementation of an -interface of a well known service, like @samp{org.freedesktop.TextEditor}. +In order to register methods on the D-Bus, Emacs has to request a well +known name on the D-Bus under which it will be available for other +clients. Names on the D-Bus can be registered and unregistered using +the following functions: + address@hidden dbus-register-service bus service &rest flags +Register the known name @var{service} on D-Bus @var{bus}. + address@hidden is either the symbol @code{:system} or the symbol address@hidden:session}. + address@hidden is the service name to be registered on the D-Bus. It +must be a known name. + address@hidden is a subset of the following keywords: address@hidden address@hidden @code{:allow-replacement}: Allow another service to become the primary +owner if requested. + address@hidden @code{:replace-existing}: Request to replace the current primary owner. + address@hidden @code{:do-not-queue}: If we can not become the primary owner do not +place us in the queue. address@hidden itemize + +One of the following keywords is returned: address@hidden address@hidden @code{:primary-owner}: We have become the primary owner of the name address@hidden + address@hidden @code{:in-queue}: We could not become the primary owner and +have been placed in the queue. + address@hidden @code{:exists}: We already are in the queue. + address@hidden @code{:already-owner}: We already are the primary +owner. address@hidden itemize address@hidden defun + address@hidden dbus-unregister-service bus service +Unregister all objects from D-Bus @var{bus}, registered by Emacs for address@hidden + address@hidden is either the symbol @code{:system} or the symbol address@hidden:session}. + address@hidden is the D-Bus service name of the D-Bus. It must be a +known name. Emacs releases its association to @var{service} from +D-Bus. + +One of the following keywords is returned: address@hidden address@hidden @code{:released}: We successfully released the name @var{service}. address@hidden @code{:non-existent}: The name @var{service} does not exist on the bus. address@hidden @code{:not-owner}: We are not an owner of the name @var{service}. address@hidden itemize address@hidden defun + +When a name has been chosen, Emacs can offer own methods, which can be +called by other applications. These methods could be an +implementation of an interface of a well known service, like address@hidden It could be also an implementation of an own interface. In this case, the service name must be @samp{org.gnu.Emacs}. The object path shall @@ -1491,18 +1551,6 @@ to the service from D-Bus. @end defun address@hidden dbus-unregister-service bus service -Unregister all objects from D-Bus @var{bus}, registered by Emacs for address@hidden - address@hidden is either the symbol @code{:system} or the symbol address@hidden:session}. - address@hidden is the D-Bus service name of the D-Bus. It must be a -known name. Emacs releases its association to @var{service} from -D-Bus. address@hidden defun - @node Signals @chapter Sending and receiving signals. === modified file 'etc/NEWS' --- etc/NEWS 2011-01-04 16:57:45 +0000 +++ etc/NEWS 2011-01-08 05:43:02 +0000 @@ -557,8 +557,13 @@ *** It is possible now, to access alternative buses than the default system or session bus. -*** dbus-register-{method,property} do not necessarily register names anymore. +*** dbus-register-{service,method,property} + The -method and -property functions do not automatically register + names anymore. + The new function dbus-register-service registers a service known + name on a D-Bus without simultaneously registering a property or a + method ** Tramp *** There exists a new inline access method "ksu" (kerberized su). === modified file 'lisp/ChangeLog' --- lisp/ChangeLog 2011-01-04 19:50:21 +0000 +++ lisp/ChangeLog 2011-01-09 15:34:49 +0000 @@ -1,3 +1,10 @@ +2011-01-08 Jan Moringen + + * net/dbus.el (dbus-unregister-service): translate returned + integer into a symbol + (dbus-register-property): use `dbus-register-service' to do the + name registration + 2011-01-04 Ken Manheimer * Summary: Reconcile with changes in line movement behavior for === modified file 'lisp/net/dbus.el' --- lisp/net/dbus.el 2011-01-04 10:57:24 +0000 +++ lisp/net/dbus.el 2011-01-09 16:03:20 +0000 @@ -193,9 +193,14 @@ (puthash key (delete elt value) dbus-registered-objects-table) (remhash key dbus-registered-objects-table)))))) dbus-registered-objects-table) - (dbus-call-method - bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus - "ReleaseName" service)) + (let ((reply (dbus-call-method + bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus + "ReleaseName" service))) + (case reply + (1 :released) + (2 :non-existent) + (3 :not-owner) + (t (signal 'dbus-error "Could not unregister service"))))) (defun dbus-call-method-non-blocking-handler (&rest args) "Handler for reply messages of asynchronous D-Bus message calls. @@ -914,17 +919,20 @@ bus dbus-service-dbus dbus-path-dbus dbus-interface-dbus "RequestName" service 0)) - ;; Add the handler. We use `dbus-service-emacs' as service name, in - ;; order to let unregister SERVICE despite of this default handler. - (dbus-register-method - bus service path dbus-interface-properties "Get" 'dbus-property-handler - dont-register-service) - (dbus-register-method - bus service path dbus-interface-properties "GetAll" 'dbus-property-handler - dont-register-service) - (dbus-register-method - bus service path dbus-interface-properties "Set" 'dbus-property-handler - dont-register-service) + ;; Add handlers for the three property-related methods. + (dbus-register-method + bus service path dbus-interface-properties "Get" + 'dbus-property-handler t) + (dbus-register-method + bus service path dbus-interface-properties "GetAll" + 'dbus-property-handler t) + (dbus-register-method + bus service path dbus-interface-properties "Set" + 'dbus-property-handler t) + + ;; Register the name SERVICE with BUS. + (unless dont-register-service + (dbus-register-service bus service)) ;; Send the PropertiesChanged signal. (when emits-signal === modified file 'src/ChangeLog' --- src/ChangeLog 2011-01-04 11:11:43 +0000 +++ src/ChangeLog 2011-01-08 05:38:56 +0000 @@ -1,3 +1,34 @@ +2011-01-08 Jan Moringen + + Symbols for flags, return values in request-service in dbusbind.c + * dbusbind.c (QCdbus_request_name_allow_replacement): new symbol; + used by dbus-register-service + (QCdbus_request_name_replace_existing): likewise + (QCdbus_request_name_do_not_queue): likewise + (QCdbus_request_name_reply_primary_owner): likewise + (QCdbus_request_name_reply_in_queue): likewise + (QCdbus_request_name_reply_exists): likewise + (QCdbus_request_name_reply_already_owner): likewise + (Fdbus_register_service): changed number of arguments to MANY; + rest arguments are used to supply flags; adapted docstring + accordingly; translate value returned by DBus to a symbol + (Fdbus_register_method): use Fdbus_register_service to do the name + registration + (syms_of_dbusbind): added symbols :allow-replacement, + :replace-existing, :do-not-queue, :primary-owner, :existing, + :in-queue and :already-owner + +2011-01-05 Jan Moringen + + Added function dbus-register-service in dbusbind.c + * dbusbind.c (Qdbus_register_service): new variable; holds + function dbus-register-service + (Fdbus_register_service): new function; register a service known + name on a D-Bus + (Fdbus_register_method): use Fdbus_register_service to register + the service name + (syms_of_dbusbind): added symbol `dbus-register-service' + 2011-01-04 Jan Moringen * dbusbind.c (Fdbus_register_method): Added optional parameter === modified file 'src/dbusbind.c' --- src/dbusbind.c 2011-01-04 11:11:43 +0000 +++ src/dbusbind.c 2011-01-09 15:53:12 +0000 @@ -38,6 +38,7 @@ Lisp_Object Qdbus_method_return_internal; Lisp_Object Qdbus_method_error_internal; Lisp_Object Qdbus_send_signal; +Lisp_Object Qdbus_register_service; Lisp_Object Qdbus_register_signal; Lisp_Object Qdbus_register_method; @@ -50,6 +51,17 @@ /* Lisp symbol for method call timeout. */ Lisp_Object QCdbus_timeout; +/* Lisp symbols for name request flags. */ +Lisp_Object QCdbus_request_name_allow_replacement; +Lisp_Object QCdbus_request_name_replace_existing; +Lisp_Object QCdbus_request_name_do_not_queue; + +/* Lisp symbols for name request replies. */ +Lisp_Object QCdbus_request_name_reply_primary_owner; +Lisp_Object QCdbus_request_name_reply_in_queue; +Lisp_Object QCdbus_request_name_reply_exists; +Lisp_Object QCdbus_request_name_reply_already_owner; + /* Lisp symbols of D-Bus types. */ Lisp_Object QCdbus_type_byte, QCdbus_type_boolean; Lisp_Object QCdbus_type_int16, QCdbus_type_uint16; @@ -1835,6 +1847,112 @@ xd_in_read_queued_messages = 0; } +DEFUN ("dbus-register-service", Fdbus_register_service, Sdbus_register_service, + 2, MANY, 0, + doc: /* Register known name SERVICE on the D-Bus BUS. + +BUS is either a Lisp symbol, `:system' or `:session', or a string +denoting the bus address. + +SERVICE is the D-Bus service name that should be registered. It must +be a known name. + +FLAGS are keywords, which control how the service name is registered. +The following keywords are recognized: + +`:allow-replacement': Allow another service to become the primary +owner if requested. + +`:replace-existing': Request to replace the current primary owner. + +`:do-not-queue': If we can not become the primary owner do not place +us in the queue. + +The function returns a keyword, indicating the result of the +operation. One of the following keywords is returned: + +`:primary-owner': Service has become the primary owner of the +requested name. + +`:in-queue': Service could not become the primary owner and has been +placed in the queue. + +`:exists': Service is already in the queue. + +`:already-owner': Service is already the primary owner. + +Example: + +\(dbus-register-service :session dbus-service-emacs) + + => :primary-owner. + +\(dbus-register-service +:session "org.freedesktop.TextEditor" +dbus-service-allow-replacement dbus-service-replace-existing) + + => :already-owner. + +usage: (dbus-register-service BUS SERVICE &rest FLAGS) */) + (int nargs, register Lisp_Object *args) +{ + Lisp_Object bus, service; + struct gcpro gcpro1, gcpro2; + DBusConnection *connection; + unsigned int i; + unsigned int value; + unsigned int flags = 0; + int result; + DBusError derror; + + bus = args[0]; + service = args[1]; + + /* Check parameters. */ + CHECK_STRING (service); + + /* Process flags. */ + for (i = 2; i < nargs; ++i) { + value = ((EQ (args[i], QCdbus_request_name_replace_existing)) + ? DBUS_NAME_FLAG_REPLACE_EXISTING + : (EQ (args[i], QCdbus_request_name_allow_replacement)) + ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT + : (EQ (args[i], QCdbus_request_name_do_not_queue)) + ? DBUS_NAME_FLAG_DO_NOT_QUEUE + : -1); + if (value == -1) + XD_SIGNAL2 (build_string ("Unrecognized name request flag"), args[i]); + flags |= value; + } + + /* Open a connection to the bus. */ + connection = xd_initialize (bus, TRUE); + + /* Request the known name from the bus. */ + dbus_error_init (&derror); + result = dbus_bus_request_name (connection, SDATA (service), flags, + &derror); + if (dbus_error_is_set (&derror)) + XD_ERROR (derror); + + /* Cleanup. */ + dbus_error_free (&derror); + + /* Return object. */ + switch (result) { + case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER: + return QCdbus_request_name_reply_primary_owner; + case DBUS_REQUEST_NAME_REPLY_IN_QUEUE: + return QCdbus_request_name_reply_in_queue; + case DBUS_REQUEST_NAME_REPLY_EXISTS: + return QCdbus_request_name_reply_exists; + case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER: + return QCdbus_request_name_reply_already_owner; + default: + return Qnil; + } +} + DEFUN ("dbus-register-signal", Fdbus_register_signal, Sdbus_register_signal, 6, MANY, 0, doc: /* Register for signal SIGNAL on the D-Bus BUS. @@ -2014,6 +2132,7 @@ DBusConnection *connection; int result; DBusError derror; + Lisp_Object args[2] = { bus, service }; /* Check parameters. */ CHECK_STRING (service); @@ -2028,18 +2147,9 @@ /* Open a connection to the bus. */ connection = xd_initialize (bus, TRUE); - /* Request the known name from the bus. We can ignore the result, - it is set to -1 if there is an error - kind of redundancy. */ - if (NILP (dont_register_service)) - { - dbus_error_init (&derror); - result = dbus_bus_request_name (connection, SDATA (service), 0, &derror); - if (dbus_error_is_set (&derror)) - XD_ERROR (derror); - - /* Cleanup. */ - dbus_error_free (&derror); - } + /* Request the name. */ + if (NILP(dont_register_service)) + Fdbus_register_service (2, args); /* Create a hash table entry. We use nil for the unique name, because the method might be called from anybody. */ @@ -2091,6 +2201,10 @@ staticpro (&Qdbus_send_signal); defsubr (&Sdbus_send_signal); + Qdbus_register_service = intern_c_string ("dbus-register-service"); + staticpro (&Qdbus_register_service); + defsubr (&Sdbus_register_service); + Qdbus_register_signal = intern_c_string ("dbus-register-signal"); staticpro (&Qdbus_register_signal); defsubr (&Sdbus_register_signal); @@ -2112,6 +2226,27 @@ QCdbus_session_bus = intern_c_string (":session"); staticpro (&QCdbus_session_bus); + QCdbus_request_name_allow_replacement = intern_c_string (":allow-replacement"); + staticpro (&QCdbus_request_name_allow_replacement); + + QCdbus_request_name_replace_existing = intern_c_string (":replace-existing"); + staticpro (&QCdbus_request_name_replace_existing); + + QCdbus_request_name_do_not_queue = intern_c_string (":do-not-queue"); + staticpro (&QCdbus_request_name_do_not_queue); + + QCdbus_request_name_reply_primary_owner = intern_c_string (":primary-owner"); + staticpro (&QCdbus_request_name_reply_primary_owner); + + QCdbus_request_name_reply_exists = intern_c_string (":exists"); + staticpro (&QCdbus_request_name_reply_exists); + + QCdbus_request_name_reply_in_queue = intern_c_string (":in-queue"); + staticpro (&QCdbus_request_name_reply_in_queue); + + QCdbus_request_name_reply_already_owner = intern_c_string (":already-owner"); + staticpro (&QCdbus_request_name_reply_already_owner); + QCdbus_timeout = intern_c_string (":timeout"); staticpro (&QCdbus_timeout); # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWYdIc7EAIkZfgHgwcf////// /+7////+YCvega6b73Pt8Pvffc8Xsttl0ly++r3vvfevfPtZO7jhSTbGQA1yAFsXb0AAB7t7YPvd 6t83tb73vu58Y18ddwzMvtzMPbzzfFz4++77ana77qe+G+PbKjTVkyqDfZyctbY1Nshz7cHu+++H yAHy+8JIiGgmmmgaGiYmowJlRo02pskGjI9TQaG1NojaglCAAQEgUxMKYpjUA0A0ADQAAaNAkQgm knqaAUn6U9qj1DJ6nqNB6jT0g0xAZGgAAAk0pEZCRtTT0U00A9KZMafqhGajBA9EGIMJoyaYIkkE mnqTU9plTyp/k1T9ETJ6PSRkaZPSgZ6oMajAIPUMgVJEENAECaMmk9Q0HqBMU8o9Jk0NGg0aaADJ lfiaSIFogWcwk5aUKgyCW/Of17O3suftw/mBi32vV7hurEcn+ygla8Tt+5vEN8Jve3xna510ZGCZ LxniB2sizvdRaYYGaY8O7WcO+LxfxHg82sNCQU5B1AwuuIDW3vx5Tc4pyilCK4x2GiM6PuzXNnbf Bf7IEI/B2htZuJQfA+12aMzcyGJ7z8INvH95L0DWHwPlKI3c2Z73dxgaDdcKyaaed+kxlnckzYYd Gbt3w4GG/s/76Ufl2wkaWZoO1fyNALuhxukwmWu2+9Z6nqbIQdfdt1+B0JLETyyfh9eKpavzUcSc 61oErydCLCDctutlXU+NdzK8xsggRUoTGgUzg44+1O6Tbpb8KnLHPOnE+EnkS7xPTZ2UucwUq8Z5 f6tGt+7tQ4o6fRBe0GEbmAFlYSFC90hLhuwom2fq22Y1u9DtB8daubYtruJSeOG2GLNEbOaFPDYt hWFMGkUqEaUBKDh1oOIrCVJLKMYzhOj5kp04nV4Bv8ZoBwV4+Mvsvs2h231eHs9xD3WvPTwYiGUh 9iVEfRdaV6RMaB7wxLQgcwc0sWIBGBgxRHVwVEbfO7CKX4Z0Hu5AV4Sb2s/YeioYapxxc3/EP7Lf IOqguRUyq/vbNyb1fSevNEkyQ+HXTp023d9IQYO0CdcgdgCxGRkBFYKQWKqKQZFSSMhGEkZDY5cH OqPjwrjpQ0qEv2vQKSpqT1Uj6xQQvSsQX29U1nESkbO7qay69uIpw8vYV9SuKhZvGMODNVN53lab RgUCvSN8WurrdQQrKpJNiIosSsIpHRkIqtVOxYlOzVRJOzbV2rON9WJua3xrWnticmDAyjKTUesa M75nR+TQdSs4fKHhTCnKAKDqvVs6weDP1vR97yPMRzUlHFg37x48paAfyPKvISRAY/plHxtbstVu lMJfcujPY6XYuLobZIyxqqHPdbbbXKttttrTXPiyjsP9cC5A6VYqlncwg9qI3DcvR7sDPUXIZ+kN GAjedRxJme6cLRLqjpP/ZGdxtF7lNvmVZa1sRfPdkhh245mHhG7Hlg05+64DAU8HhibKLB1K9u7V ozGMg5TsY6W2l3VG+oao5milKgpde7y9IurHrsiHmDUHual6SF0hKu+zkbTwYSnLCH79IDlNHfVR lh502vKSrNfPwssJlPdxSj1oiijmwzWYmqrLoCRdStjpylWQ8mNdSmvwYJN9LhWyis92sFsSq7zs oxnbsxl6fUXRYY2zEEDKMEKZZD9QCv+bYtoMrGSuTcEnOZU8rRcdamgiCuspdm0NQUe3WXyVNUWY Tsn4Y3gKxVUOgdmzjpZiDvRvW/s6LlNlgqdq5ywKPVmCxQpMeRbO9iCFUplAiFjhWJGNZMPacVlz XAyu1aA03rgmVBMys9e8cctVoAppXFZaMD7H5TNOTBIykxAs9w+CBzMSjsWJolXt5tScQcFLbeTx RUpMlEnyd0fBsye5I0USTD5sR9zk1o6MeBZem+xX8grbGT6ZUto8e/yPHw84eaeMWj5NQM83m67l AYcVCdHccFzVXoJ7NVnDZvUS6K4W0xMXuQDvetwNe5vhWPv8PZ7J/b30V8o0Y4dPxNlHTM+GGpmw q01wmojRXRr1mLvvug7HEELqS1aKX2btmzNm25duG6+e4DimPa97wEnGUkhhkshRTq9lnrdl6Hs3 u2AH8BU1d6iofySqqqrCfuSF/6XDD6xDYwzHaJ3G7JYQtZiLrnC3l++cb03yXd3UwIjFMIWRHPD5 HZrThQVDzi1pbmZlmRyNFldOLD92MYqcRH4InbnNiQH7OYev3oSfevidJDGpJO8R8bD9PPn9x8RC F0Pv7dbTmYkc5Z2n0qJNHGak1bJ/XR87JQjfkoBfMg/QuhD5FS4PIugTUPmbDYYDyA9Q94O8mPzF oiRsn4xOqQsiPUj/EMfjNhIS4c/y+ow80LthQ8ol5kjiJ1r50bCYoGpDWdPVO3dB+eNcSGxNVRVa t8z1JeTSG6DgaKscglSQ008hNAhmikMwzgHwcSEgaSD54K+w35eTF7tVhw2y1t7WvclzYm7Hr77t NR6kFMinV747X2V49eFd0eTtFELoCKH6JQKDkI+8d4FB22R+YPLvB2G8i+WALoW21arvms9ctoEp N+vlXOVU54BCvX16NPDgDu47uW0tttLbbbbbbbbbbbbbbbbpN5NXlfziocHx4EzTzZ9YCODJARZK dhB1MJUsilosymgL0gH+GVoRgVCMVG5tygRL4l6M3e17Neu5Bv/KVB1Qy+1LoxNkkkioglZ8Pc2I 2cLMmNt3rRrxDajExRhxuzHWg+Q9pMaIhgTEHSwLDiFyd8lhaUuiBgZGyfSQij144nokEBFhQmdH FyuqyEa0gVNEAg/9h7nBp1HP2xMgXV759SxwbIJc2HixcEN3J4I5xckm5TXvdLdHLDZvYr7XAg57 EhMpDXmYMr8616NXFq1tJ1w3XBypEzkDx+fbuRtgo/9fyqdUKHHRWpU44tyDjI88pDHBUedYU8IE qmDStmr0A3QCcFk2SRXMdkD3AkkgqQYoIoICKyWWGXNU7uzMVpZtQh2pGSEctYlxa+DVyzQi8TK6 pUIMPZoviLSezeJTGMpOnX1YvTFOCbSkatvHtgwMpJJHbxftDNl3Vmi6cFpDoz1mrpiSTapITPxQ csX0wamk5yaognUYNrscyDPhy6+3fxqIgHHDsDrS+lb1QDlAMR5gYXat0B7j2geSmiLSFuLryQC9 uucG9Oo4nieq7acs3bCrcZXwvSD+oF6C1ogCkRnkDG+4zIG0AQCMLPzGA+OEsIRqIIlEKIIp2ITs +4g0qzWaAFzJ8YOuDc6NTbM9tbrbb8dt1+KKxSF6CYb0N1fBhGEpO0nbHfJEyMRsrhXRK5vyJltN hqYME9jm0wl8IlayNXBwoIolvNAbnkYT75zkZpnTeQVpqYSFdFIxK7VWamcZabOMFIRUGIntpk2O DNdTrevvx5o2zNt1q4JnzGueCq27JD3lclixiTY36ijeRUQmIQDzDyDwX1cvJVYVUwzLdotIFlCC uYihaJNFIOAP6Y58anZmaheWxC3Fui/zF7oNhGyFoRyRUhhbXuw2RtZ6NqW4CHzpUkkjDb2WmipA gCp7LDzY9RwyZcSvcSGJaB3o+TqKI70YA3NQaExBUQJOLJKg9LahJyBWs0MnBI16o6j84n6kfqV+ if0k0F36e86UX6qBIogVxs+xVOWN3C58zi8mJZRBxchi6ILCpTPQK0vl24V5KR2kihpDk3IDlELL EVgvrWp8zSEvRny6OLHRN55b/MQ20LCTkVl9DggVTbow+4x0OINaJ9GeUHuR4p3daYhA13Z1C++i ilh5Mp2XE/QgeEDQhVEDoQcRBPHKU3stIIw3QP4WAyvbUZuYaLE/fKUU9ycevREmgRsiiE7wQL0l 1X3ci9kpY2M4I2gGJRBySCpRA3vIHCEdORPqNfiDdJLQuiMlxJggEBVpEYYR9hl1jhBJ1dMQMlqW RtIMW89UjW3yQD6sT6hM6Qw7CF5oJxQm4hnJSWnGi5PZi5w8EuPJDZeiEIYakVze0kt13RTKtuTI 4o7E9KTL6GTehoPwlCpEXFXe4Hl+BziRgfFSxoUm1ZGsPiMXcWHTyoh60Ob0xiblhix7YfLDbt4b dit6nGJ88PjbtEfdE9yOT8SBc4ea9toCwTNnxENS6V5YrDzaNUQbedlp6mHEbthZFCsHQisQlgRp ykwp2s1VoWaES5oZAqBAQFKI8LEOyFNUwulKCh2Kbr9m5tIjJcx+U2QHJlUrDhwUPTeGuRCF9usI JWYIBgvZCRHviPSBS/yQCBDesBnR0Mwh0ZZ95ogxQ8ERMypmo1LWEN0FOGJHl8H5Eg03Fnuo586V 4Mzj06C53MVjaxbbI56ADroI9A083MmziHGd5Z+uMkAVAFQDCExBC27scv1veJfWTkwrNtqZJ1DR lxc1KR63eNYIPHy6ponsvW2Na0MWLyKQmSNJ+sglfoIfAQbY3ntP0O2lyNGUBIPkNGcyIkAZhntF RNqdj37vkIcknA485YRA8uqvzflO0xB+xvN4uVMaO6wv7mnKFjYtveQhxfkdtPKVm2B1Nh/ndAqI au+E8RECt0EwRYEtAQgm6zzj+REonexxEEgJxxGgjmGxRSrVTNeDyI4tVkM7sG/WadrYTDRFWc9/ SGLFWLNzH6hcNu5GXqDb9G+YEDuuDUKag5sDsuYTChIVRis8HN4q+F5qIXiH3IBtAVR1CGsJoXBn 4IJVxJcFN9mU3kOc55u+RYdIUV0WJQ9PN+vtCCzPa7YaocYcInWnRvk+EgqOBxactd1NER4OeOVw zerZsWq/VKDkC1jM98oCBGwmtY7JueWQg8oXQyVYRwt+C6jz0RGVBVBYLFgoKCxYoKCgoLFiZETX pMR1RgGgO4u4wpBA+YmMbvKooqXsIc3oJH6r+lni1nX7OfDuyjDvV+eODLblOzDlXYXnqoxSrubz HnbHUfJ01BeA2JsKXj2gQImCUcjyZgf8AiJCBxHYfBYC9Zx5oB0IIdbkI8ktnkiJuOsPJEi1zNKh zWRyPObqQCQ4wQ0F5DzLESUIDjvMfWNtHUnS1jh5bBR4+RsaLnmJ+mCTEPSy1EujbrkeOEct3wX1 6VULoIqnVey14HrvdFhe55DyKTkMpy88HYstPSL9DrlbeHljBw0TcTYo9UEyVwVy4e7lONenlqdD PVc2j0+cJ1i4uRK0yiTxCeJ0OkdDa2+la7put2CI09qFDPB0Un6IBkQRJGwPKD1dOndtjfxql53T jnIxpAvzkrYtuxrOCBvTBbg1ptpXaUCFZcTBAPigXEGigRjXYcGHd4Z8JEKISntHSpvR4UJgiI4l owVHhNxfeZYLHlp1JX5lkgEdhSpsj2hyPrzoiTMHF5C2pOAsuHTiCOm6Yj5qZFxMagJgwVeuJDtX GQFtiVwsZISH6KjkmopEaHmM/ZeQW2xuO1ok48dQw+M/kIZgWEKkk6lAfl5U8xBjMkAh5oA2zxlO BSeJeO8cZiWeNtwOlgiPoLzV2JkkaEMnCWJ0hlzrMMeBhTiZdiFWiTSHIZSdWkhvJC8kLERlEWoX EVoejkhZe7nB19T6/COVU0Ba5CAfhuJ5s3YSGCAxZiEGkIQp5D3JzyUNuooge8Q97bAgFsuMvlOy 6McrJEZ0m/x90h5cHHHa3SotRnZWqQe+Yhl34lqYRJBg83SdsgdsZd8TzmZachHJ0S22Sg2iXb4i FUeogLfuqSxEnduWDDoXFuo4aC6MfgBU702vJBHy3ENMwlhQSf1oC4wKVhqZsNs4jPbe9VzeJ3uK L1J+lml1RDUhoPduix2d8BALSO2NyDyW6jYfWo84LsbC0yaK3xIiWKy8XBIrBMOJVG0o0Ls5rkub DkD5gjhC7rQsjxqHPy5n6/R+6urC8/uYzR6e2T11SRaDzRjCTWOIL82c1aNWqG7F4tPJNJAOhJkB M4d35fRP1MmYmg3QDV0AxXvcvSUFVVLSA8kFfjnnnnsg2IRvN8F41wjVlVaQYoS22srWQERVaqtI DjH37Yut0COlIS4ql0oLwcIP0fD+jo9FI9enC87qwp4+N82DzrXQw+yu5rN9VUappR+sYmtsy2S1 LWgQwC+phL4sbsqArKyCCCyIJBh4gGkpGMYMLBE3hUUUVRVVVVVVVYEzmR4hVV+kTWtB8UxRpKlQ 6HKP1XSZHCAg04MhGEIfcfOeSJ936kX2h/Qx69VGSw3gQSEFgLamcm74wKICf8D6jPND8REnMBzN Gm1A54/ERSuTg/U/9/oIfLye3kv1Xk/ulHa03mxLy7POTscDlxWynVtL/sotFbHZyh0Y/QG0Tf2X HgsaUQ/KgFb/5H50G9+wzwkEwGzMbQTKfRQlBIWHwypfE1E0iomppUapy6/RIu8NhNnSORvJlixO B+FlLZS0pbKWylsgiCQoqXUL/1i9xHZ4crQw550HjHIfW0Q+7uXsZirnpBTHarcJIm8EK/LvvY9S Kod/1HD9CsuNDcxbfrSMpKcKihNJKNPvmLVtW6l+KUj8/yh5evh+hqrIMm1LqC+B/VCaF3GmQSCn 49BfKK88gPcoigEG4fPQp2GCBFaItw3eiXKLAuBT2Di4CFsZJJIQspRFMB+0YA0in2ZgSrwB+tc8 2L0h1zIijPo+nusew3G6phwwkT8zmn8v6IHAgiOif3HRb8zyICTJFiTfq5DBYu6Qs8n9hXMCnXtS ho3MF97lN0CqUSjzelS2RDaUtEFJbFTY098pGksNO4sRv4kQJF+F/xEMjTJZP9OaDKTvNniZV9Xh mI0YbNFFLJmEyYEau/SjSTGvLdnnRcZRLeYoBo9Zn+AlXE6Z6r2QI+yCzmjPraM51vs9e3Fxdj2o eUiS0R2x+/lE7knmfyR4OPfU/r4x+dP0mGJgmCaI1g+qoQrg98H7uet/GSNJZVVK8hCdWqDvwkdQ 2LqRhBDUFxYPdrlCYmzwFligP+a0ED6Go6tc0EshtOMYRjjhUHA200LocAllQ9mECMkG2srMRHs3 nVDw9K7DshEwO/UNRScnPo052+4+04mUcLjnJnLFLVH1KErt9osp3XHRC1MG76yNFLMOFIG2HCzN rPorDC6c+ZHlBHV3IlXq8nc3IDn7MblsmClSlCxnfHG8h5sRybUNGctgi86PxqgbFBY0pADZBHDI 1fUnLiTL2ScHkSE8yTxj8In1OxuI+nugrz481PosL1VXJJRUgfMpIP3J8ZBgm6H0PheY4GKSBQdD Qw1vD0JaRdhQIcmYiGlT0HV0G35lzMk/UOdc0/Xx5HXIhzhPgkE5MWLiV9OMrKy5dM3UhZ9tykDg lB4w4x2IfQS3NQsXRnGTdWrIdo6LkXVBU44Y4ixFGoO28fADL4EHYNB4io+U4GffsgkcXLswzFT4 ZS15ues2mrNcQjYkOwgFBGCwAUYD572bMYqZE5GtORsz80FvW0QSHpaSCGiik7lC/MYEyJbg/GcH 14T7kAVO6fsnjKUqVOhfppfKDbD2ez+IYnmUNb1wVPF6WdSpxbR/nPi4RxaE8aTNKKlcWpYTHYGz CDHAIVT1Rh+hykZO22RjAyiVFAXwbbibQ2uAxAmwJAlPD6g9/HvKmi/1kvReEAqanMqlD6yB8yxe TfFZn01LM1nIt+kIVH0xQs/LHq4Yu/6bZHIxmJORYkeyASOxBCpwQiQw/oQRL2IGPj1AsUldAODg hU+PY2TZxVL8HKHKAB9PN95mUuXKPPBsp9/KBzA5uDDSZ9r1fluSLKJBiR31IVHWfkFbYBc/ABmR IkxRssZTypl5ZMJFPhrb5CEOanJMyZSQ6GRaX4Oy2ccRucP40S59dJxMSkqNpVuC1jsXiISRC4lJ jjCI0ySKkZ0epWQ3d/S36uDGt0cg8+vp8rfk+tGjuwfJE3/JCOL+daFx4o7uQ1x5Jaf80dbYjtbb ddSlVXpBbnEA4gDz8aoc3yXrmRkLB97K5T7sYPAm0TR2OxUetsblESg2SkeA+Mdy6mdGKBhX5BzJ 08wFKlKNETFoCzHtUSWB6cJMY0z3qm3imEKwjhit0BVllhY9hovIbsVsDMpHHfwZBRMjQuToJEYp EGAjEZMISQwlNAiyZMxkAW3x5ctRz7TiaVCXc22NOSzL7KtUPHTu3Zq6tWRjwe8zFu0mEaD1eiYp rO0yHC9oTxFdMws7zqnViw1nPrLRe+ctWvc+L/Bpenjbqvikd/T04crrmJXp6OStWk+e9vU8epx7 G4zzkn7Ej0iqxykyZLxeFh3dPAvsui3saItjlEHiges4LOmnkqMTlzzJG3SA7QHSqYBnAON3SoA0 EIDFWuTwyJsTWJhIkuknRt3WcODt7vaG5p+uA6MDTtqpuMlmvAulTF9haFuoMzhkA3CXbDiKFIUe 06+o/fkiu/St4nn8/gtle7q9yYDYpbUy9RKzsdvY7e9bsLNu49ueTPI9TZYg22YMPFnb0AN7ajQU HTfUVAgOCA6YdXX18NOQ32w2Q09OVdqBtg6TsefX178/LrePAkJeT2zuPOqpUpCPagMwdoaw8hC1 ow045J908Mc+O7dbjV6OSAxw5X2Qq5OPPzmHmkgORTiQlLPNTkdnss+KApEBuOAJA7aDxAoPCJqO YA3Kdu7jU2S5DLBU59d6rv8TEQmt9aer5TTks20loKoSjyEcWk0XCLV/fLKLpSIDa046aqNFQORJ 1LzlLvtcvdNQo4LoVJCGKPTKAkNwoE75tsJg6rIcukNSc1mRvdSQNsCeRilKkDSVzNPhl/ovg0qD fZp2dWUFW1JZrUWEJlAGUmM08vDgSX2DQD/AJDQnmDE5Q0JLSIfqa43I9hLGUTr7HZUo9Flqqyor HD9bKAzG6DqDZI3Ow7aqGGQN9h5aLeFPYVE/pJuzx7kg8Id1B2k0VOVFJ59hZZ9gVxkobbffsPUu 7WVNsVPvfoyOjZLwzPgsSfPiQ4iMXeY8AkZRqYG5M4IsaIYfsCAfY4YwT1E2IRHlmSoNUHDFIE/J N62H/FBj7Q3EN4kjc7Wl4j5GiSbbiu3FHkeXFy0kiXLcICHDIg3sCQmGxm48Nr1QjpziW/gJ9gnk q6EYn9ovdqQ8FkA6ED3/kLB4hNV6B2UPz3gZsjkoVgFbS1QSwBubaizdgzBviSCUARRcCksRVFzO EFU3IcYPQMgZm33YHKTQG7ITMNwbBUFGRYbl/Y7vkUqVZa0FsobIeo1otDdD8yM+ggm5Ck3I4ry/ vBuUKDinR30bO+IEIEiyDIi+4681aAnq48EMeENaPxh6RMHRE4xNRHHVhdeven4HMiMPxvP/KTkS EzgEQ3iVrE6kDap7UM//A6cZ7ngO2N3Nl6xGMFKdaLSN81/dHGDWMoPlgKg931khNNWUq1oOM9KN 8Iv3yXxie/aUUr7NBDw0E7jYg9mjQPhjkn38iSpEmGWu1WBpyCzfJgqEZAJOJdx4YTU9BPGzrKRf fH1QcYOEGyThQqoqlQUqClQiipu7EdJsQ39yOROciH7Zmikbul2oKQWJENf55/KGf4RLMaNgQw1l +yDOJzzPCJyN0Mk4dBNC3pUfQj3w4CXo5geBGw9x6UgawIUwoYUwpIWJSJRoJYlIlGwSjYJRoJRo JRsEo2CUbBKNglGglJQQolbFDO9CsOkSWCjrEyQ9B1keUIbBN9yB8dyaECcQWB1odKiwDvxkxTua I+9NcTwfSV0orHwFzbfC9WqYJjGPjTLAmN7RRjMrkHrbJEMoLwd8KiDmzEmYV2C7kKzBgZ09KHkS wKDm7EmywnhQmuTfIVe4n25xwxWJCVNw7vHq6BL6nMjgJ1NLoOAS6qylHdNaBKIDySUdIKrENXCI wD72SUuVGULQYI7Nxe1WdShM9aKlUX4yH6jBc/A4CfRIM9r/AjxRvSTAVIh8zYTlM4trLsXwQXgs +rD81j4T+GBlBnHel/nlbYNE3SF+HvOYhL8INkIrTO3JGqflizew5Q4TWeq8o13rlJTSwCzEkOsl mDEyLgh3GDhTQXBXgdyPxu1yrxCTEy4OmhLxSxiIS0GcPSFkTAQmQtBkms0OxRPur1UtSQuiL2aI a2kLIUyOaiKiWJQHsd54h4gyYHEgYHGqGsdbxQkiQoyyBTCBEAiALpCUXJCfPDwg1H9jJuKiZIbU xnexsizOOpNjp+CTiQb00/0lI286lpqNUb5SiQmTAiNmTBQKCMgTmES5WQA7vdNucM2QJbOPI8W8 ChBT14yKwKd6D3PrsQc4n1RMk3KM/lswD1z0CxjhlF52epDeARmIeFDtQ0h8CPnU4Y5alobGo6qJ O1G6KRUlRxVJIeEH2Yxc5ylmmh65SQN6u4GiMsbkyDIScjLaUO/Kb/D/GwdypAEHhUD3uEEeW7gV MiG6t2NOdPcu71VIYs6J4vBc6lS8XSllVV7lp6njKVPPctek3wfBEtE1z44KEpElTVqyhHdD4Nfy 6CND8nWqqVStOjjRLaE1zzEXe1b15xLYE7cep3ZuCcSdROyQ6S8FYKiV9WbywhtqHaiHwQuj4EcJ CTgbCMibiWUxOSPaliKigoxFBEBd6QsYoqwWCKCEJxB5nKDSB80vixgDFFwMUDwuCF5tU5xZxgip M8aLUrxDfOcpiK93lSxhVcYCkUYwGPECYDDOb7aGaeAek6JAJTBkzSSxBFwe+4AjIhIejTsH+m5s 2JpFJNcGcFoRwjlKYbYLac3tEqRdVZSCTxqQe0lxUMZH78nUasEh0g2TNqfdSTyRRUxRYjSkNiFS QmcvBUL0lkFCVeZurueeCu60uvjqox16lqMZutK/OoWfNsh23DW0vSybKE8xaFSBosQaa32pu8yS McFJprJ7gQCS3mFu7G7qixwEUyBewReI+cR2hRZSVqpJkmF0TCC/LSC/56JLo3oUlqSuZRe3BV1U JTq8z0ZPNHwVLbZJQiliUjUfPGGFG4sfHkGMYkOjXaTPt2Z5BtVUEYjFFGMFiMirDMCfBCZ6p4uU pp3GdMhAZoBOk70DkkUFigooLFiiixYsWKKOgbTZtITnJqGk+IIyBkk4+dWaqaYF2mgLoiuIEfGF 6COhRYnrEcZ8yB3ig4OSExRqdINKgGNotOcNB85fXkauefYnR4CzZmVFBhwzkZXNOg0aRk8Yo06W LLDMX1RBwnpobkTQFkndbUBgPLxF3ia2rbBn3ribCRollwl4MlC+LZmZQeBbzbraqpqmaLUlEk5w UJepKilQrW/GH2xOQTdBqay5HvqQfNSOONSpbWRZbKDC9ociN/cg3ZY2iVvIZhWUViJWvTr1DJmq SHLicNZCTOQJf2EKE2BlJKIRHhALUz3WYgp0VElsIN8RixgzrJjHvILWZQ2I8XCHxeCNs89OzWql SpDYUsqy0+OSIu2E+Lsj3IbI3VucHujFO6FQ4dHhESPYVIc4PLB1Cje0tunjEdzl+2qKqp7crS6i kqAqpUoRnFlhDCiTCT21NboYJZ1e2T61vTjqhzQyIOUh7M144ETpJCYHfIhzif1I93kcIU4skqrL JXbqiXTgwimKKi8liY3PNHuTXDJInUQWie8fhDWeBBvPRH3I74+SJga5D6fJx6GkkOiNln8qP32k D6UexHzPXK650UosgcV0LrIXN1UXI2bEjCVEDZED0IbgfGYgmN8kkkklD0CbQD6iHTHShl1FzkL+ o8onPnDxRrIdpXUfemyDCCgwQbexiYA0JeGDpEZmOc5eDI5J3GNKogdr8YtRT8dv/i7kinChIQ6Q 52I=