708 2006-07-20 09:34:14 +0000 GIOPConnection is not safe against malicious or malfunctioned peers 2011-10-06 15:36:46 +0000 1 1 1 Unclassified JacORB ORB 2.3.0 beta 2 All All RESOLVED FIXED P2 normal --- 1 marc.heide spiegel asi crotwell kent.au Richard_Ridgway rnc oldest_to_newest 1873 0 marc.heide 2006-07-20 09:34:14 +0000 Problem affects getMessage() and sendMessage() (read and write direction) getMessage(): if a malfunctioned or malicious peer writes garbage to socket which is not a valid GIOP header, the ORB does a permanent read() which may result in very high CPU load. Even if this is not an attack but a wrong protocol or anything else, it makes no sense to keep this connection opened, since the chance to get in synch with peer is minimal once a not valid header (12 bytes) was read. This was already discussed and submitted to Andre Spiegel (including a test case) sendMessage(): occuring IOExceptions during send are ignored at the moment, this may lead to hanging resources or extremly slow processing of requests in overload situations. Instead the connection should be closed in these situations since the peer obviously is not able to get the response messages properly. scenario: - peer gets in overload - peer doesnt read data in time from its socket - system buffers fill up with written data - if system buffers are full, write() operation blocks (possibly forever since this operation is not secured by SO_TIMEOUT parameter!) - even by providing own sockets which enable timeouts during write(), request processing is extremly slow, since every thread responding to a request runs into timeout situation a patch is attached (against 2.2.3) 1874 1 243 marc.heide 2006-07-20 09:36:16 +0000 Created attachment 243 patches getMessage() and sendMessage() to close connection in described situations 1915 2 spiegel 2006-08-01 11:35:01 +0000 Applied both parts of the patch on CVS HEAD. Thanks. 1974 3 marc.heide 2006-10-26 14:09:52 +0000 There was an error introduced in promoted and applied patch for GIOPConnection. This error may lead to deadlocks between reader and writer threads which might try to close this socket concurrently. This is because 2 sync Objects are relevant for closing the socket: connect_sync write_sync they get allocated by implementation of streamClosed of ClientGIOPConnection in order: connect_sync -> write_sync (reader thread) but while sending a message via sendMessage they get allocated in order: write_sync -> connect_sync (writer thread already has write_lock if he calls streamClosed) solution: call releaseWriteLock() before calling streamClosed() in sendMessage() in error situations. applied patch is against 2.3 beta2 1975 4 253 marc.heide 2006-10-26 14:12:30 +0000 Created attachment 253 patch for deadlock problem introduced by former patches (against 2.3 beta2) 1977 5 spiegel 2006-10-31 17:37:59 +0000 Second patch is installed. Thanks, Marc. 1998 6 crotwell 2006-12-01 20:46:49 +0000 *** Bug 701 has been marked as a duplicate of this bug. *** 1999 7 crotwell 2006-12-01 21:59:56 +0000 I believe that there is still a deadlock situation caused by this code. Here is the test I did. First, in StreamConnectionBase.java, about line 126, I changed it to be this, so that every so often it throws a IOException that looks like the one we were seeing in our clients. Unfortnantly, the real sockect exception has proven hard to reproduce, but I believe this test is a good first test. I only did this in the client's jacorb.jar. Next I ran a simple "hello world" client and server (attached). The client orb sees the IOException, marks the socket as bad, and creates a new socket to the server successfully. However, the local call that triggered the IOException doesn't return with the COMM_FAILURE and the client hangs until the client timeout is reached. Subsequent calls to the same server also timeout. The output of both the client and server is in client.out and server.out in the tarball, as well as a thread dump on the client showing the deadlocked threads. It is not clear to me how to resolve this, but at least there is a test case to demonstrate it. StreamConnectionBase.java, line 126: int USC_count = 0; public void write (boolean is_first, boolean is_last, byte[] data, int offset, int length, long time_out ) { try { if (USC_count++ % 10 == 9) { java.net.SocketException s = new java.net.SocketException("Broken pipe"); java.io.IOException io = new java.io.IOException(); io.initCause(s); System.out.println("Fake 'Broken pipe' "+io.getMessage()); throw io; } 2001 8 256 crotwell 2006-12-01 22:02:40 +0000 Created attachment 256 test client/server for deadlock/timeout 2004 9 marc.heide 2006-12-04 14:57:13 +0000 Yes you are right, at least the client locks up, but this is not caused by this code, its caused by wrong behavior in Delegate.java. The Delegate simply ignores the COMM_FAILURE exception and on next call the Delegate is still in state: bound=true, which means simply send the request (including opening a new transport). BUT: the previous close() has forced the MessageReceptor (which reads answers from socket) to quit and so there is no Reader any more, thats why your ReplyReceivers hangs forever. Possible Solutions Delegate should be adapted to handle COMM_FAILURE exceptions like TRANSIENT exceptions (try_rebind), would be best solution. As a workaround you could throw away a narrowed object reference (to garbage collection) once you got a COMM_FAILURE exception in client code, but this cannot be the final solution. 2008 10 crotwell 2006-12-06 17:20:11 +0000 I tried the idea of making the Delegate treat COMM_FAILUREs in the same way as TRANSIENTs, ie try_rebind(), but it did not seem to help. I addition, I tried creating a new ref by reloading each corba object from the ior via string_to_object, and this seemed to work occassionally but not always. I expect there is a race condition with the garbage collector such that if the gc cleans the old object in time, then there will be a new Delegate, but if not then you are still dealing with the old one. Since you can never force an object to be garbage collected, this doesn't seem like a good solution. Here is the client side logging with debug messages, starting at the point when the fake 'Broken pipe' is generated, till it hit the timeout. [jacorb.orb.giop] INFO : ClientConnectionManager: found ClientGIOPConnection to 129.252.35.30:9876 (3da850) Fake 'Broken pipe' null [jacorb.orb.iiop] DEBUG : Caught exception java.io.IOException at org.jacorb.orb.etf.StreamConnectionBase.write(StreamConnectionBase.java:139) at org.jacorb.orb.giop.GIOPConnection.write(GIOPConnection.java:887) at org.jacorb.orb.CDROutputStream.write(CDROutputStream.java:438) at org.jacorb.orb.giop.ServiceContextTransportingOutputStream.write_to(ServiceContextTransportingOutputStream.java:148) at org.jacorb.orb.giop.RequestOutputStream.write_to(RequestOutputStream.java:251) at org.jacorb.orb.giop.GIOPConnection.sendMessage(GIOPConnection.java:971) at org.jacorb.orb.giop.GIOPConnection.sendRequest(GIOPConnection.java:923) at org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:323) at org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:304) at org.jacorb.orb.Delegate.invoke_internal(Delegate.java:1024) at org.jacorb.orb.Delegate.invoke(Delegate.java:939) at org.omg.CORBA.portable.ObjectImpl._invoke(ObjectImpl.java:457) at demo.hello._GoodDayStub.hello_simple(_GoodDayStub.java:32) at demo.hello.Client$1.run(Client.java:26) at java.lang.Thread.run(Thread.java:613) Caused by: java.net.SocketException: Broken pipe at org.jacorb.orb.etf.StreamConnectionBase.write(StreamConnectionBase.java:138) ... 14 more [jacorb.giop.conn] ERROR : Failed to write GIOP message due to COMM_FAILURE org.omg.CORBA.COMM_FAILURE: IOException: java.io.IOException vmcid: 0x0 minor code: 0 completed: No at org.jacorb.orb.etf.ConnectionBase.to_COMM_FAILURE(ConnectionBase.java:143) at org.jacorb.orb.etf.StreamConnectionBase.write(StreamConnectionBase.java:153) at org.jacorb.orb.giop.GIOPConnection.write(GIOPConnection.java:887) at org.jacorb.orb.CDROutputStream.write(CDROutputStream.java:438) at org.jacorb.orb.giop.ServiceContextTransportingOutputStream.write_to(ServiceContextTransportingOutputStream.java:148) at org.jacorb.orb.giop.RequestOutputStream.write_to(RequestOutputStream.java:251) at org.jacorb.orb.giop.GIOPConnection.sendMessage(GIOPConnection.java:971) at org.jacorb.orb.giop.GIOPConnection.sendRequest(GIOPConnection.java:923) at org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:323) at org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:304) at org.jacorb.orb.Delegate.invoke_internal(Delegate.java:1024) at org.jacorb.orb.Delegate.invoke(Delegate.java:939) at org.omg.CORBA.portable.ObjectImpl._invoke(ObjectImpl.java:457) at demo.hello._GoodDayStub.hello_simple(_GoodDayStub.java:32) at demo.hello.Client$1.run(Client.java:26) at java.lang.Thread.run(Thread.java:613) [jacorb.giop.conn] ERROR : GIOP connection closed due to errors during sendMessage [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): close() [jacorb.giop.conn] WARN : Abnormal connection termination. Lost 1 outstanding replie(s)! [jacorb.orb.iiop] INFO : Client-side TCP transport to 129.252.35.30:9876 closed. [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): streamClosed() [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): closeAllowReopen() [jacorb.orb.delegate] DEBUG : invoke: SystemException [jacorb.orb.delegate] DEBUG : Delegate.try_rebind Caught exception in 18th loopIOException: java.io.IOException [jacorb.orb.iiop] DEBUG : Transport to 129.252.35.30:9876: stream closed Socket closed [jacorb.orb.iiop] DEBUG : Caught exception java.net.SocketException: Socket closed at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.read(SocketInputStream.java:129) at org.jacorb.orb.etf.StreamConnectionBase.read(StreamConnectionBase.java:81) at org.jacorb.orb.giop.GIOPConnection.getMessage(GIOPConnection.java:393) at org.jacorb.orb.giop.GIOPConnection.receiveMessages(GIOPConnection.java:517) at org.jacorb.orb.giop.MessageReceptor.doWork(MessageReceptor.java:71) at org.jacorb.util.threadpool.ConsumerTie.run(ConsumerTie.java:61) at java.lang.Thread.run(Thread.java:613) [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): getMessage() -- COMM_FAILURE [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): streamClosed() [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): closeAllowReopen() [jacorb.util.tpool] DEBUG : [1/1] job queue empty [jacorb.orb.delegate] DEBUG : Delegate.getReference with POA < empty> [jacorb.orb.delegate] DEBUG : Delegate.getReference with POA < empty> [jacorb.orb.giop] INFO : ClientConnectionManager: found ClientGIOPConnection to 129.252.35.30:9876 (3da850) [jacorb.giop.conn] DEBUG : ClientGIOPConnection to 129.252.35.30:9876 (3da850): sendMessage() -- opening transport [jacorb.orb.iiop] DEBUG : Trying to connect to 129.252.35.30:9876 with timeout=90000. [jacorb.orb.giop] DEBUG : ClientConnectionManager: cannot release ClientGIOPConnection to 129.252.35.30:9876 (3da850) (still has 4 client(s)) [jacorb.orb.delegate] DEBUG : Delegate released! [jacorb.orb.giop] DEBUG : ClientConnectionManager: cannot release ClientGIOPConnection to 129.252.35.30:9876 (3da850) (still has 3 client(s)) [jacorb.orb.delegate] DEBUG : Delegate released! [jacorb.orb.giop] DEBUG : ClientConnectionManager: cannot release ClientGIOPConnection to 129.252.35.30:9876 (3da850) (still has 2 client(s)) [jacorb.orb.delegate] DEBUG : Delegate released! [jacorb.orb.iiop] INFO : Connected to 129.252.35.30:9876 from local port 54778 Caught exception in 19th loopclient timeout reached [jacorb.orb.delegate] DEBUG : Delegate.getReference with POA < empty> [jacorb.orb.delegate] DEBUG : Delegate.getReference with POA < empty> [jacorb.orb.giop] INFO : ClientConnectionManager: found ClientGIOPConnection to 129.252.35.30:9876 (3da850) 2011 11 marc.heide 2006-12-11 15:41:25 +0000 well, after some testing with your client and mine, i think i found the root cause of this behavior. The GIOPConnection and the ClientConnection on top of it, are designed as lets say "outliving" objects, so calling close() on GIOPConnection should not be done from lower layers or GIOPConnection itself. Instead to indicate a problem with underlaying transport it is quite sufficient just to call streamClosed() operation and leave the real close() for outer objects (Delegates or GIOPConnectionManagers). Calling close() before all Delegates have finished their work with this Connection leads to error situations where a new transport connection is opened but no MessageReceiver is created to read the answers. So i simply removed all calls to close()introduced by my patches from GIOPConnection and now it seems to work fine. See my attachement. 2012 12 257 marc.heide 2006-12-11 15:44:09 +0000 Created attachment 257 patch against 2.3 beta to remove all calls to close() operation 2244 13 christian.sarow 2007-11-14 14:28:53 +0000 are these patches included in the 2.3 - release? couldn't find it in the release notes... maybe someone could tell me... regards... christian 2245 14 christian.sarow 2007-11-14 16:35:38 +0000 in addition to my previous entry... i compared 2.3 beta (unpatched) to the patched 2.3 beta and to 2.3 final and found a mix of both old and patched code... so i'm a little bit confused about this... are there any comments to the patch from 12/11/06 and/or 2.3 ? regards chris 2246 15 marc.heide 2007-11-15 08:46:38 +0000 The latest patch from 12/11/06 is not part of 2.3.0 But with this patch it now works very stable here. Regards Marc 2302 16 spiegel 2008-05-05 15:40:07 +0000 I have installed the final patch from 2006-12-11 into the main code base now. Sorry for the delay in getting this sorted out. It will be part of the next release. 2368 17 kent.au 2009-06-01 04:42:01 +0000 Dear all, A deadlock is found in my environment. JacORB 2.3 with la patched (removed all calls to close() from GIOPConnection). Here is the log message. Name: RMI TCP Connection(103)-10.0.10.101 Status: WAITING at java.lang.Object@20d65 Stack: java.lang.Object.wait(Native Method) java.lang.Object.wait(Object.java:474) org.jacorb.orb.giop.GIOPConnection.getWriteLock(GIOPConnection.java:812) org.jacorb.orb.giop.ClientGIOPConnection.closeAllowReopen(ClientGIOPConnection.java:130) org.jacorb.orb.giop.ClientGIOPConnection.streamClosed(ClientGIOPConnection.java:106) org.jacorb.orb.giop.GIOPConnection.sendMessage(GIOPConnection.java:989) org.jacorb.orb.giop.GIOPConnection.sendRequest(GIOPConnection.java:900) org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:323) org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:304) org.jacorb.orb.Delegate.invoke_internal(Delegate.java:1024) org.jacorb.orb.Delegate.invoke(Delegate.java:939) org.omg.CORBA.portable.ObjectImpl._invoke(ObjectImpl.java:457) CustomerModule._CustomerStub.getProvisioning(_CustomerStub.java:485) ... Name: RMI TCP Connection(91)-10.0.10.101 Status: BLOCKED at java.lang.Object@5e320f ,Owner: RMI TCP Connection(103)-10.0.10.101 Stack: org.jacorb.orb.giop.GIOPConnection.sendMessage(GIOPConnection.java:930) org.jacorb.orb.giop.GIOPConnection.sendRequest(GIOPConnection.java:900) org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:323) org.jacorb.orb.giop.ClientConnection.sendRequest(ClientConnection.java:304) org.jacorb.orb.Delegate.invoke_internal(Delegate.java:1024) org.jacorb.orb.Delegate.invoke(Delegate.java:939) org.omg.CORBA.portable.ObjectImpl._invoke(ObjectImpl.java:457) CustomerModule._CustomerStub.getProvisioning(_CustomerStub.java:485) ... My workaround solution is 1) removed all calls to close() as it is 2) create a new method streamClosedWithoutWriteLock() {just remove the call to getWriteLock()} It works. Kent 2369 18 asi 2009-06-01 07:10:21 +0000 Hi All, Please let me know if this issue is similar to http://www.jacorb.org/cgi-bin/bugzilla/show_bug.cgi?id=858 and the same solution can be applied here. Kent, can you explain where to implement the method streamClosedWithoutWriteLock() ? 2370 19 363 kent.au 2009-06-02 08:47:40 +0000 Created attachment 363 Solve potential deadlock in GIOPConnection. My test env. is a client on Windows XP along with TcpView + a server on Linux. Test step: 1) start up client, server and TcpView 2) triger a request from client, that will create a connection 3) close the connection with TcpView Expect result: a new connection will be created and system still function. 2371 20 kent.au 2009-06-02 08:59:32 +0000 Dear Abhishek Singh, I'm not 100% sure it is as same as #858. I've got COMM_FAILURE (broken pipe) in my software only when there is high stress. But I don't know why. My solution is using TcpView to close conection to mock one, and try to fix it. I've test my patch yesterday and have some minor turning. See attachment. Hope it can work. Kent 2372 21 364 kent.au 2009-06-08 09:01:33 +0000 Created attachment 364 Solve potential deadlock in GIOPConnection. Last update 08 Jun 2009. A bad mews is the pervious patch does not survive during a weekend's stability test. There is still a deadlock withing write_lock and connect_sync. Thus I made another patch. This time, my strategy is getting write_lock before sync connect_sync when we need both of them. See the attachment for details. 2374 22 kent.au 2009-06-12 03:54:07 +0000 FYI, the patch on 8 Jun works perfectly so far. Cheers! 2580 23 spiegel 2010-04-22 16:02:26 +0000 Reopen to make sure we get Kent's final patch into main code base. 2604 24 spiegel 2010-09-06 20:25:42 +0000 Final part of patch is now committed (only the synchronization part in ClientGIOPConnection, as the other changes had already been applied). 2621 25 mesnierp 2010-09-24 18:44:34 +0000 (In reply to comment #24) > Final part of patch is now committed (only the synchronization part in > ClientGIOPConnection, as the other changes had already been applied). > Andre, I think there is still a problem here. I've been working with a customer who has a heavily threaded client, which happens to do quite a lot of Name Service resolving. They ran into a race condition that your fix ought to remedy, but I have thought of another possible problem. They have many, perhaps a dozen, threads all waiting to send a request to the same name service. This means a whole bunch of threads in GIOPConnection.getWriteLock(), called from GIOPConnectoin.sendMessage(). Something happens and causes a COMM_FAILURE to be thrown to the thread that got the write lock and tried to send. This thread then calls releaseWriteLock() on its way to calling ClientGIOPConnection.closeAllowReopen(). A new thread gets to return from getWriteLock() and proceeds to try to send its message. However the transport is corrupt and unclosed, since the first thread hasn't had a chance to close the transport as it is blocked in getWriteLock(). So a second COMM_FAILURE is thrown, and another thread enters closeAllowReopen() and blocks. Since there are many threads waiting for the write lock, this scenario can occur many times before a thread in closeAllowReopen() actually gets the write lock and proceeds to close the transport. Now at this point, you've got at least one thread waiting in closeAllowReopen(). It is entirely possible that you also have threads waiting from sendMessage(). Lets say one of those gets a chance to go, it successfully opens a new transport, sends its request, and releases the write lock. Now, one of the threads waiting to close gets the write lock and closes the transport, which by this time will be the new one just opened. Oops! Now you have a client thread that successfully sent a message waiting forever (or timeout) for a reply it will never receive because another thread closed the transport out from under it. 2677 26 mesnierp 2011-01-14 21:41:37 +0000 I've finally had a chance to test my theory about an additional deadlock scenario. I now believe this is not a problem, as sendMessage() calls ClientGIOPConnection.streamClosed() which calls ConnectionListener.streamClosed() after closeAllowReopen(). This ensures that even if a race as I hypothesized occurs, the result will be a COMMFAIL exception rather than a deadlock. Now, I have observed that it is possible to have multiple threads waiting in closeAllowReopen(), and even for a thread to close the stream and have another reopen, to have a third previously blocked in closeAllowReopen() to then close the stream again. It might be possible to do something a little more efficient here to ensure a "reclose" doesn't happen but I think the conditions leading to this are fairly rare so I won't propose any change now. 2687 27 rnc 2011-01-19 14:40:37 +0000 *** Bug 759 has been marked as a duplicate of this bug. *** 2773 28 jacorb 2011-10-06 15:36:46 +0000 *** Bug 858 has been marked as a duplicate of this bug. *** 243 2006-07-20 09:36:16 +0000 2006-07-20 09:36:16 +0000 patches getMessage() and sendMessage() to close connection in described situations GIOPConnection.java.patch text/plain 2594 marc.heide KioqIEdJT1BDb25uZWN0aW9uLmphdmFAQC9tYWluLzEJTW9uIE9jdCAzMSAxMjozMDo0MiAyMDA1 Ci0tLSBHSU9QQ29ubmVjdGlvbi5qYXZhQEAvbWFpbi8zCVdlZCBKdWwgMTkgMTE6Mzg6MTEgMjAw NgoqKioqKioqKioqKioqKioKKioqIDI5LDM0ICoqKioKLS0tIDI5LDM1IC0tLS0KICBpbXBvcnQg b3JnLm9tZy5HSU9QLio7DQogIGltcG9ydCBvcmcub21nLkNPUkJBLk5PX0lNUExFTUVOVDsNCiAg aW1wb3J0IG9yZy5vbWcuQ09SQkEuQ29tcGxldGlvblN0YXR1czsNCisgaW1wb3J0IG9yZy5vbWcu Q09SQkEuQ09NTV9GQUlMVVJFOw0KICBpbXBvcnQgb3JnLm9tZy5FVEYuKjsNCiAgDQogIGltcG9y dCBvcmcuamFjb3JiLm9yYi5TeXN0ZW1FeGNlcHRpb25IZWxwZXI7DQoqKioqKioqKioqKioqKioK KioqIDM3NywzOTIgKioqKgogICAgICAgICAgfQ0KICAgICAgICAgIGVsc2UNCiAgICAgICAgICB7 DQohICAgICAgICAgICAgIGlmIChsb2dnZXIuaXNFcnJvckVuYWJsZWQoKSkNCiAgICAgICAgICAg ICAgew0KISAgICAgICAgICAgICAgICAgbG9nZ2VyLmVycm9yKCAiRmFpbGVkIHRvIHJlYWQgR0lP UCBtZXNzYWdlLCBpbmNvcnJlY3QgbWFnaWMgbnVtYmVyIiApOw0KICAgICAgICAgICAgICB9DQog IA0KISAgICAgICAgICAgICBpZiAobG9nZ2VyLmlzRGVidWdFbmFibGVkKCkpDQogICAgICAgICAg ICAgIHsNCiEgICAgICAgICAgICAgICAgIGxvZ2dlci5kZWJ1ZygiR0lPUENvbm5lY3Rpb24uZ2V0 TWVzc2FnZSgpIiArIG1zZ19oZWFkZXIudmFsdWUgKTsNCiAgICAgICAgICAgICAgfQ0KISANCiAg ICAgICAgICAgICAgcmV0dXJuIG51bGw7DQogICAgICAgICAgfQ0KICAgICAgfQ0KLS0tIDM3OCwz OTcgLS0tLQogICAgICAgICAgfQ0KICAgICAgICAgIGVsc2UNCiAgICAgICAgICB7DQohICAgICAg ICAgICAgIGlmIChsb2dnZXIuaXNEZWJ1Z0VuYWJsZWQoKSkNCiAgICAgICAgICAgICAgew0KISAg ICAgICAgICAgICAgICAgbG9nZ2VyLmRlYnVnKCJHSU9QQ29ubmVjdGlvbi5nZXRNZXNzYWdlKCk6 IGludmFsaWQgaGVhZGVyIHJlYWQ6ICIgKyBtc2dfaGVhZGVyLnZhbHVlICk7DQogICAgICAgICAg ICAgIH0NCiAgDQohICAgICAgICAgICAgIGlmIChsb2dnZXIuaXNFcnJvckVuYWJsZWQoKSkNCiAg ICAgICAgICAgICAgew0KISAgICAgICAgICAgICAgICAgbG9nZ2VyLmVycm9yKCAiRmFpbGVkIHRv IHJlYWQgR0lPUCBtZXNzYWdlLCBpbmNvcnJlY3QgbWFnaWMgbnVtYmVyIC0tPiBjb25uZWN0aW9u IGNsb3NlZCIgKTsNCiAgICAgICAgICAgICAgfQ0KISAgICAgICAgICAgICAvL2Nsb3NlIHRyYW5z cG9ydCBjb25uZWN0aW9uLCB0aGVyZSBpcyBuZWFybHkgbm8gY2hhbmNlIHRvIHN5bmMgd2l0aA0K ISAgICAgICAgICAgICAvL3BlZXIgb24gdGhpcyBjb25uZWN0aW9uIGFnYWluDQohICAgICAgICAg ICAgIGNsb3NlKCk7DQohICAgICAgICAgICAgIC8vc2lnbmFsIEdJT1BDb25uZWN0aW9uTWFuYWdl ciB0byB0aHJvdyB0aGlzIGNvbm5lY3Rpb24gYXdheQ0KISAgICAgICAgICAgICB0aGlzLnN0cmVh bUNsb3NlZCgpOw0KICAgICAgICAgICAgICByZXR1cm4gbnVsbDsNCiAgICAgICAgICB9DQogICAg ICB9DQoqKioqKioqKioqKioqKioKKioqIDg1Nyw4NjIgKioqKgotLS0gODYyLDg4NyAtLS0tCiAg ICAgICAgICAgICAgICAgIGdldFN0YXRpc3RpY3NQcm92aWRlcigpLmZsdXNoZWQoKTsNCiAgICAg ICAgICAgICAgfQ0KICAgICAgICAgIH0NCisgICAgICAgICBjYXRjaCAoIENPTU1fRkFJTFVSRSBl ICkNCisgICAgICAgICB7DQorICAgICAgICAgICAgIGlmIChsb2dnZXIuaXNFcnJvckVuYWJsZWQo KSkNCisgICAgICAgICAgICAgew0KKyAgICAgICAgICAgICAgICAgbG9nZ2VyLmVycm9yKCAiRmFp bGVkIHRvIHdyaXRlIEdJT1AgbWVzc2FnZSBkdWUgdG8gQ09NTV9GQUlMVVJFIiwgZSApOw0KKyAg ICAgICAgICAgICB9DQorICAgICAgICAgICAgIGlmKCAhZG9fY2xvc2UgKQ0KKyAgICAgICAgICAg ICB7DQorICAgICAgICAgICAgICAgICBpZiAobG9nZ2VyLmlzRXJyb3JFbmFibGVkKCkpDQorICAg ICAgICAgICAgICAgICB7DQorICAgICAgICAgICAgICAgICAgICAgbG9nZ2VyLmVycm9yKCAiR0lP UCBjb25uZWN0aW9uIGNsb3NlZCBkdWUgdG8gZXJyb3JzIGR1cmluZyBzZW5kTWVzc2FnZSIpOw0K KyAgICAgICAgICAgICAgICAgfQ0KKyAgICAgICAgICAgICAgICAgLy9jbG9zZSB0cmFuc3BvcnQg Y29ubmVjdGlvbiwgdGhlcmUgaXMgbmVhcmx5IG5vIGNoYW5jZSB0byBzeW5jIHdpdGgNCisgICAg ICAgICAgICAgICAgIC8vcGVlciBvbiB0aGlzIGNvbm5lY3Rpb24gYWdhaW4NCisgICAgICAgICAg ICAgICAgIGNsb3NlKCk7DQorICAgICAgICAgICAgICAgICAvL3NpZ25hbCBHSU9QQ29ubmVjdGlv bk1hbmFnZXIgdG8gdGhyb3cgdGhpcyBjb25uZWN0aW9uIGF3YXkNCisgICAgICAgICAgICAgICAg IHRoaXMuc3RyZWFtQ2xvc2VkKCk7DQorICAgICAgICAgICAgIH0NCisgICAgICAgICAgICAgdGhy b3cgZTsNCisgICAgICAgICB9DQogICAgICAgICAgZmluYWxseQ0KICAgICAgICAgIHsNCiAgICAg ICAgICAgICAgZGVjUGVuZGluZ1dyaXRlKCk7DQo= 253 2006-10-26 14:12:30 +0000 2006-10-26 14:12:30 +0000 patch for deadlock problem introduced by former patches (against 2.3 beta2) GIOPConnection.java.patch text/plain 736 marc.heide KioqIEdJT1BDb25uZWN0aW9uLmphdmEub3JpZwlUaHUgT2N0IDI2IDEzOjQ4OjI3IDIwMDYKLS0t IEdJT1BDb25uZWN0aW9uLmphdmEJVGh1IE9jdCAyNiAxNDowMDo0MSAyMDA2CioqKioqKioqKioq KioqKgoqKiogOTg5LDk5NCAqKioqCi0tLSA5ODksOTk4IC0tLS0KICAgICAgICAgICAgICAgICAg ew0KICAgICAgICAgICAgICAgICAgICAgIGxvZ2dlci5lcnJvciggIkdJT1AgY29ubmVjdGlvbiBj bG9zZWQgZHVlIHRvIGVycm9ycyBkdXJpbmcgc2VuZE1lc3NhZ2UiKTsNCiAgICAgICAgICAgICAg ICAgIH0NCisgICAgICAgICAgICAgICAgIC8vcmVsZWFzZSB3cml0ZSBsb2NrIHRvIHByZXZlbnQg ZGVhZCBsb2NrcyB0byANCisgICAgICAgICAgICAgICAgIC8vcmVhZGVyIHRocmVhZCB3aGljaCBt aWdodCB0cnkgdG8gY2xvc2UgdGhpcyBzb2NrZXQgdG9vDQorICAgICAgICAgICAgICAgICAvL2Nv bmN1cnJlbnRseSAodW5mb3J0dW5hdGVseSB3cml0ZSBsb2NrIGlzIHJlcXVlc3RlZCBkdXJpbmcg c3RyZWFtQ2xvc2VkKCkpDQorICAgICAgICAgICAgICAgICByZWxlYXNlV3JpdGVMb2NrKCk7DQog ICAgICAgICAgICAgICAgICAvL2Nsb3NlIHRyYW5zcG9ydCBjb25uZWN0aW9uLCB0aGVyZSBpcyBu ZWFybHkgbm8gY2hhbmNlIHRvIHN5bmMgd2l0aA0KICAgICAgICAgICAgICAgICAgLy9wZWVyIG9u IHRoaXMgY29ubmVjdGlvbiBhZ2Fpbg0KICAgICAgICAgICAgICAgICAgY2xvc2UoKTsNCg== 256 2006-12-01 22:02:40 +0000 2006-12-01 22:02:40 +0000 test client/server for deadlock/timeout JacORBTest.tgz application/x-gzip 14760 crotwell H4sIAHuXcEUAA+w9XXMcx3FzFkkQp6MkU5IVyYo9PJLyHj72vgGFACiBJCRBAgEYgChTjHTZu9sD llzsnnb3AMIs+NlOlZOUU3lwKi95SEl5kz9CJVElykvKVflBzluU7pnZ22/cQQBPgnjDIvZ2dqa7 p6e7p3tmdvZtpbGydm1DtZ08eVSpAGm6WsVrqVgMXN1EioVquVIslivVEikUK5VqhdDqI6PIlzq2 o1iUkoZlOruqrieV6/XcbYh7PSHpba//bavxaGSg3/4vF4ulqakp6P9qqVoY9v8gUqj/bdXaUS1Z aya28ysk5MdUpZLY/2WQDdH/xekq9v90CcwAHQgTH/P+3zabHV2lTXXbPJd+cC5NIYm8LWitSSGP 52LSDEe1WkpDpW+aZvOGskcfeA8xBe9sx9KMTQ6oZmvbbV2VcjMH1dgNVNnVmqoESLvZ2/Ymzc3E V98PAe4+xAfn0vj362b2NzCF9B/l4NgHgUPZ/xKO/1PFqeH4P5AU1/9M+Y5RCg4//k+XpqeH/T+I lNz/wsLLd5Ud5Wg4eo3/lcpUUP9LxQrq/3D8f/SprTTuKZvcAZBZx8+k0/mxsTQdo2+qhmopjtqk Lcvcpos3lnwOQFbIR1aGolj6daXjbJkW5RLFSjfM7bamqxa9RUtyebKuOspkaYIWK5MrDWeyBFLB KoLHaWumQTe7+BSHLps7tPTqBMVStHylULxSKtHVm1Ahn063O3Vda0TdkfSoet9RjabtZqy0ESIA tyeoaW3K5vamfB3Im5dX6nfVhhPObZuWo9R1VQbyFwxHc/bSD9L732LHoaf+exz8ypagl/5Xy6Hx v1Sulob+/0BSrP6fXAPgSSvo7Wh+DCgwoIMNx8ZqmGF2S1CWhUIt64qxKa/HRiuJJVhwEnkGEQrU OTkWo6f+v6XqwLEjeQE99L9cLZZC+g+X4lD/B5FOtv63NEPRaUNX7O6Iz+UVtV+Ugf514LJjak2g 3lYth0q8XnDonzf2qGLsTQigHkNkd67DzqVHAe7oKBSTOagadyMkGw3FfhhnDAzwTywFKhxAgcBi qU7HMqihWJa5KyFKUdfFmcvROKRBmBt7bfW62VSpAz+kIOiQQ7R2DRqlAVy5YanQC7VuX9echpSF /rwSNQ9XinIhO+EJQywfhG3UmiECDoIZB8dlIpDXjOWg574Z7Y4DaFVlGzo9lqOaISMcl5u+vqoJ POtOpy4z4crFNouJ1K6lOerBxKx0HI+amtlx+pAxLCYz2IcWMdG+OJI4KGrW7wo0WotKcEfn5qjR 0XXI5RLusgryACuiHVV1W6VueY2Nqg3VbMVQEIYixRQBIHGA5Zpm15QDhS3XBZ/QZcCaTh2Bj+IP Ci1Td2lCWTbA84JyzVadWlPV1U0QfkmSknqT8XAR3ANsRE6ubfqr5ThA0XKXEreZLuXOFvQQoyuI 5Nr8jdrq/Nr8TSm7zHqRthSwn02mVgiln/7vGI0ttXFPbdZOoiScyM7dP0EeXzD19v9Mvflo/b9i qVqM+H/weOj/DSCd6PmfOPePiesoi962VYz7EjSdD8f4E8wNFQBdE7qj6B11pmtrA7CFD7Mf/9T1 LV1I6FFpii6MLIMLRkvkBgb0BL+tFuO4BUMzXiAAi3kmNXRv4n3dg/0kl8ogGg4NCsVgYo5KD1QR L0hgC2IRkJiXxOjg6E6qef3Gp2T7H/CCj7QI0MP+VwvT5bD9r0wN5/8Gkk52/M9Nv19SvRWAnh5e 2j9KRB1TNoVgaTtAjwhg73wAIawNhvHBQfHJvjdudKvVoF7IhkMOs2zdwtx4Crfem1e8zptotm3+ ay6GVN8cPeOIR0GP2U1O0e4W9JHkWGBshfettaQL1NnSbBaP6WZD0SUv7upjLIFqdK4bNIw61h5e WO2k6qHxAevDCPZRB0yTRLN+urMTlBHLQI9yVDXN2DHvqTBw2CI/0nSAZnd0hxW2eezPt5WIOMHt GVGO5WFUMtpQnMaWlCRQa+q2Ytlbir5wv6G2sRcAwn2ae9BH3fl2G3qJdZ2vtgK1PXa51MM4O4fP ZAhJFpsuzV4kudYxHG1b7cKRsu8a6v02CDvok9qFnqXjDFbOax+TPN3XQ7znLQh7FFtdU9v6ngQs 82qEY7UkF0u1dhTDEaFmzTaxATbPrLUtVXRZpHM9YecoQRp5bS5RnDmJMfS7y+8sr7y3LGWZ2FJE 0hAT/obpULvTRgLV5gUeVI9GdIhygRfUA81SpEgOyJFFSxiQJGGLSr9PCv1o5MiyQ1LneBw0bceV etv0VYnKMZoZ9sdnbw69rHHSjAW2JGQqTFvMqYkNZRJfrjmqGdkd2pFvkB0R/f4YWxGmw13RfjRm ZBiRfStSz/m/1ZX5o24B67X+C4FfOP4rlArD+G8Q6WTHf0rdZkuiwTlAENloGLgqRpN1/oaDMJjp PmYKF5lxfEsxmtCSiQPDL4wZRQTnho48rGOWveNouvyWYm8xuHQbRyi8FasYMWXY6MwBcu+rW0cG 94dGXecuHDaKLEJnbaqWVOALFwmVxXgZX7XYXfo8Wigcs05VQ/cgFBVHi4l5QbGUxerUTHcBPDAV mYgiss4NPV0/Al6sHUTdl5cqBlnXo1ZBWZrJ+w8D/jHeJBZdU+02yJ4roXSLX9G/Yd5NWLDX92xH 3e76d5wP/U7a+hz1fJ42TWqb2BJoEc/5qKM17lHdNO912tRsedut0n73RkgXPLUXjaZ6H92jyNOc J6/gqoK8cpZxdw6XH7kfB/5cF0yu1+LqyurC2vzG4sqyJICNgyOLDl3L7BhimdXe1cDXBvAuWBmM 3i2ci5ZytBvXNMClpYUrFNrs10Gfg8W5JXpD7KngTnA3HOmu8YsAIhgEimJ1qHnPH0UA4qIPMeqv hzbqQyrWZmGOy1BsuHIoQncDlDJHkyGIJ3bf0zCEEZzw8mbHwDP1Npt4+hoy2WDWadtUJmh9z1Gh GmgjBCDxs2pD77TP1I//t6Gpj3L9twTuXmT+vzo19P8GkWL9P7A/oHpJrhNIxAlaIw57hiDMkbcE 0GH0zfbHxPLuFpCZtFcM7RFEz0pknZhjicb71IXi7vFy79mkvosgurLcE94EFbbxYMCjSC1kcZr7 cJy+Fb7ZAb0ZamAtthP4Cne3ytF7lclNU20pHd2pwY1LBbo0rIcuxG/BErLmH1TtDvIhCCyAq6/1 n3Dzo3PRR582TsDhn6kaTip9DSl5/L+uaxAVH8Prf73G/8pUtcLP/yhMV0rVMr7/V54e7v8fSIoZ //FteeEBMIXWTHlsJpjFZilWLQzuHE21vadBcz7GYAUGYi5V3qkCMTuqtxXNcKNkCC3sOx/kqAhk vcUN37kDWkvCYrKuGpvOFlrPYi58LgGPeWWMY2D4NhwdlzVsaPgVaFDD9I8xgsJZzbRqLfBMrmbD RxYIYOp9zZGK/of73k+PObQNP20xx+NlBw5CYEVk3VSaEpa61mm1VEtt+iYBWP4bQI4/LwujnYx1 s7mcHxyEhmKHmfZTFXinUtzc7z0XwyzQ1N30jxyc4HT4IQU3s90FZcFtbosYL0JMLvJZ5TuFDybY 2J1Ye1Nc+6q6scX2mzlFwTh+L4kFKoNPjgUPp/CJE5Mjq2NIEUFgZJmWBDJANYBdmIHLLC2CysKv 8fHYCpgcK3LYhT8xluP8DmN3d9aDQlBNmcSxfL6UkgwlTkxdtmXHxS85PEtwOHi+TsyOezd9Qt2n fCXS00T1fiLPkki4rnQ2txzfYqJmAC3aeBbUVzdBnMdVtjx5U7VRRw+g5iv1FZcl2dZVtS1B7NCr rTgfZVmdNkQdvmYf2GoQh42VGyt0vuOYk17MwuDRum427iXXVTmj1h0wzRsWxFGRM1MOaH4oy3e7 74fiFGUc9xwpaDYgm2mNyNx31Sv0/o1Pf4WdRkNpKNsQibguvGuyF1dijTaaMtoSyo03kgsiZMjY uwz4tgE+B5HRbMcO2P4LLZnn4gtRfZh9hhlXr12EbA6waap8ZZfBkg+0+ZNJRt9PrjBsEGxpuLbg mFShTc2CGMW09gINaMmafcN9cqRGaLYfyVdshDv4rIGOQFhet0QnBfO745G4bYUHIJyy5TEZWD2s aDRUPkcAEf82mMVJXTNUZFMHV19YQzwASS+rAC045vFJyJpjumFfne9PXgKQQWsBDxq6aashQWd2 mcePVHOwd95C8/eeaelNN8oMjqcttsWFvY8DA6VCu6/q0F1N12ld5QJveLWi415s+IrvmfhoE4GS qOQp4v6jOb6o5/wf7pQ8YhDQ6/2Piuf/F0uVIs7/lYvD9d+BpAT/3xcD9HTpfYIiTtyKTq91zxYL LiNSXeyqmQnFAz6YUrgszQk0PjvJdhp1C8z54Qr9CYCPnQyJgRr1IwK+A3qNASt6OIfhsE7CwY7B vn9QoVLD7OC2ozlaDeMFtP1EMO47uswwUmYZJ7gBx3HHZfB4loLrxpCNj/fDbTbjI3Lwdw1nf6Ks jxv0NsCD3uYuIQx1VxgdLggaY0Nd0v/okf5HWqQlWqYFOvbKh5cvXXz9wutZj2q88L/osAsOQojA zo/7dh4fl2z/xWz/AOZ/ytPTYv2nVJ4qsvmfyvD9v8GkRz7/E/sA/qxyxLi7RtG15jL4sNHSoZWn GHjRtSkX8HxTAQNszetosPcWWIhwmPqCsFUTTNhesKICXNtSZeCEbhpyywLad03rHgxAm5sAZIld ogMlx9Hv3NedD1gMkXuEU12CoCNOdcWMkoeb/WK8ON4ZMDHOHTgLhqn/mTAfRMocmkB7+fIbgOG7 J3AhJjShxRppKjLQges0NxVDwf1VOVlpOMwlirAEo0kGDaINN5bg4U6wnN//2vT95jz3e1LZdRMk dQsYG+loDxmbvwoFbtFmuFSLAAyGdWerpjWhQzoWo6KJy74QBF7bc7C7J/ykhZEfEO0hLnenMoR7 XYqkA8Ctoti/h9tVLNre7cpeN7MrSeJWhOpxAsSn7ni4qbU08M4iMS3EjsHYlbFot6t8KKGCSdAA sX0Gg76IdOzKLb1jb0V1YzcmhhUE7ioabl6yqHj7wQ5zth6Y0cEUM4XXjxFRw9j7ckfDvqAwdqgw nqpE5oy8MWGCxtnxiSAlAVPtbwqisUzTwesc3oVCb+SOapv6Dh52w0yFJ2G2lF3jVbOBrvKUF6w1 v865SCLaHXVK3ZLijB1sfraNmxvwlDIU92yocfFJoO6rrGA0444k8HeblNRBrDSMQYHK7jYDP4/d A0JQx9xKD1BtRQt1raXabcWotTmMJXHPC7N9dfLqwtr64vrGwvJGrleLfJC1Zg2GVW3TwAkkF/xi c76b50fx7vrCWm3xRm7fa/e31KU/VAr5/1pTl+2tY8bRw/8vlAu+/f8VPP93qlwZnv86kHTxQr6u GXl7K51Gz55ONto0vwVuQt5tcH7hPphfQ9HzKCtWvYbludjUSnJZLtRwz1Ypr2t1Jj53FevKV4cA LvQ9zZksyiUExF0DdFvBUiPwtmKBN0C9zxQMNfhoyaf/6Eejm3LsOHrpf3Wqq//FaqXMzn8vlYf6 P4g0+9r9bZ2K3ZVzWXxrg4L3YzbBS53LvrvxxuSr2deupmeFbNxQ7YalMa/xanp0FleernKlRhGa zbMMeIBrPDAAX53Nu78gU8Cw8Xfef1PvaHpzva024EbcXeeLRJgh0KAlUBu61rZV+W7TkcEm8G3J rLxqdZFDBXdVyea3+cD9bD6EQWQIAgAbODQqL8p/J+PmzxE1K4ewutW7bQww7evu8FDy6z+bpWgr zoDH/2K1OuXN/7Hz/6cq1eH830BSv/rflQ2m3e4NqJS1R+9pRnMuC+5jlmIm/5lPLNgwDbdgWK90 BQ8vBNTy22sLtesryxvzi8sLawcAA5/BBZYXa0v5HcXKKx3H3MYJ/INckZ7+xwAR71pKG+LAybIM fTBg3HWI4HFycxLndSehfxody+KbPwdJBp9PnezOp05WgBfVARPR1homcMBRNAN6o7ccmOwNOZcE sCWbqpNnJVUbq83mfarzdWt7NPnsv6D9+HGgPezz+y/lQrmI33+bLpeG338ZRIr2//F/Aq5n/B/9 /tt0dbj/eyBp+P23xztF9f/4pwAPP/83XagM4/+BpOH83+OdovovfNev5ft/GP9Po/5XCsPv/w0k Jff/8fmBh/b/SsVKYfj+/0DS0P97vFOy/h+fH3ho/69UqBaG+/8Hkob+3+OdkvX/+D4Ffmj/r4Rn Qg79v0GkHv1/LJ8CP3z/FyvlqWH/DyL11f/RD+IdCkeP8X9qqlQO9X8VQsDh+D+I9D//9+//CReZ /HqEfCdFXkjo9RFyKkUuwGCcN7c382yfdt49JDLvfVJjhJxJkfPRl0hT5AmtaafIs3eW0MvI4xlB ef6aw0yKjHaP6k6R7/oKsCx4PsJE7lIBSq7vGc6W6miNFDk729Bx0+5VAC7lbqXIKfxe0igBGBny JEmfJc+myMsHntZKnicvjJDvpcjTIaQZ8ifkRUDcMi3chJwil6Uo4bkIqSPk+ynyAy932WT5N9TW G3i85IJlmVaa/Cn54Qj5ATDDK7iB+56RlxlCyYUUSXuHH6TIc1IuijxNXiIXM+QSuZwiZ2YFH56P o/IWsuRHGTJK0iMklyI0RPWy6XDq3O3gwA58j3q5s11XrQ2kCvp0CU8Zv6VYGt6zzDR5gkwiBU+N kHyKPBPGfJYUU+Sl5NNhkaxyhoyQs9B1+P5miry4lCB+IASnakyCnpdysTKUCRzCCaCvZMgMmUXh cj9KwOTk/bPkVXz8Woa8TuZBitzPBkCNGO69n1tKEnrfyagzCPF6htwgCyA04qDXFHlH6qtyIgrf iy6A4U2yOELeSpFs79IZ8jZK0ZO+b5ykyRJZHiE3U2Q8oX7cNwQyZAUBnWafChghP4YO9VgU/lDA CFlPke+FWcjf5DlL3oW+i/2QQJqskYv45ycZcpu8D+KMGyGMZopM9FA6P4IZhPDnGfIB0nvWMddF q1cRdor8RYYopJ4i5wJfIwC9SOwiP/NztxBGM0NU0gJdiH57gPV1hNaIfUjs6cAXDsCMbAGzgkXF 9wjOkrugwb2+SZAmm+TiKNkm5ggBdb7UD9YMaZOPQHpF21DlPfK7hNnCpAbV2TOpTxKLdDLkVXIB ObabIfcJcPnZmI8NpEgukfdBduRujZAHUDyhcPS7GaDoNTQnl/rpWyxsQuHLfekqqjc/xCfIoK4d eqKm3E+RySRgcUrGamlN/GubKfJKf1xBWfZ/+gEGnqWDegYqpL1ZNUDTl3LNnCW/SJNfkr8eIX+V Ihf7YFGG/A2OSecCxwWj9fpVhvwtKmfGfwYxysvfZcgvyF9C87ftTSBy3exYDRVfz4KRPPoRugsg V0/A/9Pw9zs4eoD38iIObnA9i+M+PMsw1+Y03J8jT8H903C3CuUxXfoteeb2H8jL750//6/kudu/ I898TJ7+nLz0fu0hefkzkv3id+SV30AdrPsckQDHGNRKw5WAu3ARMIzDL7xL4dgnoN8AbCm4nh/7 jEyMnfoPIt9+4nxh/V9I6TesNMJ4ilHwJDkFNb4r4GR4LVIhVQZxikwLiHm44rPTY78npU+7QM6I Cl7l093KrzLmQOXUf0PuCOT949hD8md/D0Z1aez83KmH5OrNsYmH5NrS+EPyxvLklTOfkMKLZz69 +TEp3YT8d5Y/J6u3Pydrt89vfEZuTT4k7z0kdz4jH35x5fQn5MyLp7+4cmoMqtb++dQnX/7vx1/+ EwD9LXnlIWksjf+BnPucbN4+r31G7n0x/nui/xexbk78GwG5XP6YPBcEsMMATH768Zd1IHOUZMll 8lN2zcEwhdc3gfjL8BevPyF32PVn5Ofwj5Bfk39gV84Qg3wf/r4EcF6Gmj8EzlLyAjDiZQb1EkC8 DOV+BPyUAMo4wJ+EQW2c/JhMkFvw+0NSJFukRHRSJjvAyp8BG38OrsMvyRxI8gz5FZn9f/au/DmO 4zp/e2EWixFALACSC/AALxBYAMTNA+AhniJIkJB4yFpSJAiS4C3wAilR962SJfmOLcmyHSlOaCtx QlPWAgxiS06q4lT5j0hVfvIfkarke90zs7O7M7sLmKRTFQyrsMOZ6dev+/V0v+PrN/gRzz/BZvyU aqF0/Bk12j61Or4ch/EiXhLFkyPmZbxCzoSXV/EaJZ6kvvc63uC1DpZ+U107Rzm/hbdZ4mVy+w7r C/L/IavEJ/yfPgvIi2GJ9D/VeAZ+pUV6KrAvGX9PRLq/nT36fpLS2iZC/G5/OBHuN36B7oRxh13f u5939vaHs0SbCLtkWyaiKaOMZWyM/DKiZPsJqWvZ7mvLkm2bli1rvYcfBNEfFulmkbipSCTCFO+T Srwt7Orn1W+nEm8LX0bw2uPqdxSn1e87nB6+z9+f47b61eK9xq4EBklnL0vuZxcPYz6fX0QBLueS 34ZDpHqYQvwGX52neOco/3dMDZojeBojPD/LOq7iJG7gFIVzmjWdYw0X8SFXyB/z9ycU/mc8v83B 9LkaJOBiWCGdbYlYzn5IkVCd5IARYQfJSYMSdoh8xJTAwuRiqRJ2iLwklLDDrHmDEnaQ9a5Qwg5x YIWsEredswCHmbT6w/to3RU/SrL/rc3xM7f89VHE/l/X5fj/bfu/R+H/5uz/B3849v+/Kfu/Ok/q yvKfl6sKuoxOl/EtJmG5yYmqrEQb0rH8aobyKhabT9Ih0KZo9jD5xK6tRo2BeLbtqTYum5yI68ja 5RvktE4XPn+543G9X1lpclEsCKC51MQIMb7ODQbqbas9m5jJ6WgxVUNrq7SfIR4jw0stCz8sKRX4 0zwo6u0KWvmqgACwOzJpEmKcW8oNNAXQYFfrkRnBQHMAC+wHclIkRJGkMmOnSYhxJWwTCS2OcV1c I2e03Rc2O12Ua/YsR5fJ1ZEPhSU5Q4wT4loDfRwp2bog/5ic9NbzORkXAWz2EtqQVyPzzCL+Gcgy 4Z2d4gF05RoN8nCGQHY6jw5JVV/BhftRA1tou/o/ZWIrtgVQmb1/W/w+hWhbj7GKHdhliPG/rOjD JhcYvh5RO4GCgUGOcO+8a1HsFZ+XnbQhht1oi2I/LXtXlgWxcQ8o2zzPBWPiIA6xLjsNg4y3lqPb pEeeNLlgPsVh45PIQZp+dJtf2y2bgyNEaB0xudg+zSHslaiBamlzUTK5MrXNzeO575vO2GDgBKcT 94DX12Nc7ttiXPFPycBmG2oyA1s/ocZ0L86YVApoZM/LTcwQQDJvgFlWqJcP7hga5M9FkxoEhRpR +RvkyriJy+qKStwgVV41qcvwSujajXGZTSZk0riRM1U4Fm8Mz+KWgeeyvIQut8zzaorNyb9A8Uoq Cz83a0TlNOFg834LZbq8dlKm4vwXjPeuXB6l7V/oReOwdCXl4KziYY/KHVXTyQvCiGdPBxC88mze tG3Jj0bRmHMvu1fEwnX+c93AB3mej0zaoQ5XigkD36bh5d8wu4hXIgoD3w2go3jZrAwVUXyfi4WV XELGBi3gH+JHnKD8k1GogelhsHv2YIw20o8NfBxAoz9rOhWGSXPjJ1zNdUaMAHp9h38ByUfxM1r8 WVksZP7+1KRa/Tc0x905JALo850PhFbL0RwGrARMMtH8rYm/w22KOZM8I4ALXp634nO2TzUF20mp WekzePaMvUasKKE2A//A+dGrxnL8I+4Y+CcK2IeMR8IME7/GXfZDJm9GAG1+bHiUV735GxNfIs3X 0DtRRwCHfQXlRdK357IfHijHFP7ZwL0A1vgU8EnhYWIa/8KOtzJ5BNDpV6MPAdXq35n4Cl9ToSqQ RCSAY75N96Pt2/z8AgM5Xq4Kd6o97d+SI6y8XOLwEVdOxh80iah2KokTQvuDTGWt2v4gE49A3BKV qNKFA2f4nBD5LPm78M9QdRfz4vPTWBiewpJpLE9NYuVQ6zRWpaaxOhVvmUTrJNrT6Ey2TqFnX9sU Nuxvv4dNAdzD9gClsDsV3zOJof5we3xfGsOJ8D0cDqFdflNB9EemcYykRlLJUPckRidxsr8sUdaW iKQxlsb5RFkaF+TPM21pXLlNS4H8tKZxXTxD4nqL43v4Ky6AuoUHqMuDLSnDPLaomndrUY86miwL OHUmaF3XU/1ahGEsob2/FGeoYN+i3vomre13sRLfQhOpreYM20xLvwWf0r6vUHTFnfIZXqA9Lw6k F2jVv8zaezFKq/5V1r6B9F6jPR8i7V206t+kSM5QEGLNR1jHImXNl5FyheWoKReFlSXfgzgjQ3if tX9H9fxVlhWxLk3Gv5fGD6bw4VCr6tJ9rfGftrGf//oefh7GHUew9SQsUo+hk43uYqO72egeNrhL sd+oySlWxT9Zh1+QVfFBVeKX+JxUymX2tUbPsOWfXBz5Lf4+FUrexa/u4YsgDqbCPJ+8h9/yPFO5 dlWuY1+vZyvXuUbXYtUj4m38vXr6Xx+odTp3POijJP9P9qfgZuwGKuL/6enJw//0dXbN7f97KIfj /9mi/D8L/aSu3EB1nnclxm5/1qmEKFR4pBRTwnEvLWsuTDDL+fSIwBwqtU9K8AXzZuWMqveoUfcC GYtmmrqpCGsF1VzF30IL/6Ctq8iIrn9+c4sHYeUSWWxylVtKldr90TNx4PhaAsuwwsByT8naFoAG kdgWQJuvBeDBk0cUVztkfPhvFv5bAmgt7MbJsQcLGaaNnp2VNeJM9wfSOEIL+nQGZBx1mmjHmhxU iQ8Sp8JxiRWMjJtct7tnF4OVGvot75oOknqGnrN0yrjH5ztt1TLIfxGlXtgB1HKlu4iAZKXfpZ6g UkFV00y2fokqrW9Ww9YM4tRmalmijmfAfP00apSmppWRMqWulvOeppniM1KyyqGZbPsSCzKEhaSQ CmMhiyVYUb0irvWcKod4lUVczhJkPsjzejRY1XRbWnI0mcaiKTTeceiXWeqL0NSqTNSiKeWbrPKb rKaXS5hytQeBZa4WlztMlSNJrTKgFPY2i5Q7gFuVS2aVi4+Iw0fEEcFmi4+ynO7XcegWPpl0MVLm MFLmdD3Hr0Vru8VINRlZ8O/sGv7coRg6MkxpqbZzNHRABmqGuWqHuS7VuUKw1yIYk5bdQ08Auc3r c1GIORQ4gC0KW6zmVQgF6sEbgnkk+l3tq3DaV6EUbKl+k3p+c+kr3dzhdcxQ/5tVDLCI/tfX150b /+vtmfv+78M5HP3v20r/89bwlPK3pLATX0F//ZBmgwryZX2gXmk8BddKLhzOt98dZ6/yV8sVRXKg MKTYGxxsoNp2qGdTi2EeaiRoWOlonrIkzleo2SgW5mgCKhBYnanW+mC9uPUXCZXFVmBPyNoBv9AV iUWu9/D2e/j/8y9FJUaYpTyUDNKtUfFBD3xusig+t00cS6ajGC/wVowHSlJdu030oHcmqutarDew rqDqugH9D0t13ST8b76fqmsGKfxWIR92AfCi3zMHxq5f4Xtkv3H+wNMccGNW/GQnzY3sYjq47jwj w/sxE7slghni0pGj0PoPZkPimg3ZtOV7WsOP7zyw9dDgsAYq+0CJJYQ9bOJxiXgaN8X3OnymeM1O yG4IB+UVPeQXpI+Cs0VMAWrPCCxeSvy5yOQhjUw+7kIm+8L69+CgzCOjJk5CdjmcH59QDmY1kQ1W YAxnDUEhN5UmehPncJ5Kl/Z2O6jn0mHtF2UvxPGYAyYuDQN6RTrY1BhQGwJ6DRMKQFwSgP2G9FYW VNQCFK+QoGiJhpNw/byJF4SZbEAqZfnM2MS5y6d9bKkyvppqwi4RQ2yc091NC7fUd1I8IQqfUiry OMoVcXD89JgEhYfyFh81CVOD6+TKMDJ66dKIs1efXd5TMOR2dJv3noqSYr5lnMgVXiB4dFuODVrl 0huFfFgboEEFTg3S6tKo3aCsMRC9343XTfEpOdqnMS81ifgXqLuLuviCaSRSoUk0pLHkG3JhuVwI Wxe0obQStjlZxQriNA5raJVV0Oiygbu1nsDdJgHurk6F4i0Hv0RrhlYGuFungLtCxwbuipklFDvQ aVF0m6BdU+i749DRhs1CV/moq/yAVT7LBN3oQWCRImCboJqAnG3Bo6rqrdjGe9uhI0g7FHq00gIE vxjoD7PXBP/7NRL9kUTkDxIC2pOaxlCqdQr7J3EgftgGh458JTGbE59rVXGnpTLqRgBt7fcEYyF4 Uzb1QhqXbmNRWxpX+8tcdyTQczONW4lwph3dSt7L2K0ryd0qiqOJHbCa82QrDlFUx9iqEzQ4z/DJ ca66t2g6Spt36zY4bX7Rwt3KmcbdypnGzoZYSqCYgrZ+Bm/iLfbAGQ6Et1lC+lFCN7rDt1tuETHU W3M7e6OqWDshIk7FESveI2fv4X3lhPhAlfzWbBXxv9AxE/svo6DPzAwsYv919vR159h/azv75vZ/ PpTDsf8qlP1X0Czzg4KW4iWdneczZ0GZnz8QpUhZwImZB8M6Zi6catemOCHtsObckXfM5P1Xn4Kd hQOoyPvf3dvVmfP919613XPxv4dyOO//fvX++wBRC0b/ova3QH106Yj6kCbf0cGiW5ULh/L4QstZ fFZBvQJoxFLmL62MIvSnGPWvJYa4eFwzof4qrImlaGR71cdhxQW0RyOoVyqA95JslT33+7AmFY3K fEyngdUFNtW2sM3532eNUZ1qVa4rOWs3Kd2O2Rqvahd3sFHR7BFKvbTcmwcLGLtNWCuxqoVZxq6A NhuHCvfALNeIcmrMWwzxzHhsA1B7vAtvA9jOgrlflo1R2X3MwC4/uP9uxDJw/yj20KS2xPDHtzNy +OPb+V+bZa/Yn6zNWdzm5X1wOz9eB2tRC2XF64Yti0HH1kISW2v9EtXagKmBbQyZ/LtKwcIEGCbx FG1DSERtviJeZeHNAlhADV8Tf4nX5Km+WiSm0HAbUdk9uGwaTal48ySSVJqr02iLd/JPMvUbVB0J nyAHaXSnxXQRHblMbelzs6JjhzFWU8nXKcNKn8VKjE+txwbFSr+yjISVJ3hVnkrcxUZV/zbWT2Zo c/SlsSM+eMdpsY6TLSOx5S7yCaelCey1Wjqkyux7gFPs/+ljJuv/7svynZX7jv/p7u7M1f/7unrn vv/xUA5n/e/ww/9oqXvr/iro45cWRk+WehGO3NQ+zFpvT7zfZjKlBMTuB35Ht4JVLfAC7VhwnFoL jmNY+HsV17h1hZTr8zymh3hd2BzIbA0rEKdYJLvNwppWZESUhZnknkig0eRktpwkdNH+0op6d3ZQ 9tSV6NcsG1Fu0wCaS8xlorhtNtEi0aWIVXhjaYW9BTNjP6knDsaau9S62gU7hUAAtpkYyVpRe1xg a1Ovo5WwVxVZRyuV58jGb8xTuAUhEPeD0NRkqFRaiJYwS0kJoWRDaDQlDaGJKibmc5HUNNdYTIWn sPCOQ027qepc/IQdfhZjiVV2a8apOIWlWezErKUxinoXK+UOK+VYgZWq6lUOTMYh18rlv2YKq3PJ LSa5JT7kWhVERhAqUmbNfZ/S5o4ZHDNa//XHc+/3+t+Xyf+cWf/XzuX/fyiHs/6/4bv+K6n7+f4y udm8Mre587X5rfGmybmi/L6s8YpTWbXOj18fuzbhsZlz6/gtn2UmRjthviG7xqvziphiDwXwiCY7 Yrc94Qc3YPNCo+O38uP+Uj2nvuu+ipAx9twEzf4JD3CClPUBJ9Q6+kGlVd7hsQC8gkqAOB2aZg+g CJegHCXRZqDVe7+4wtha+8Xr8hk9sI3meWdBkEpUMLWGdUEq6zVpRK5lz9vbu+wo6MjEKdmUXjBL l8+uSqc1ojud9nVw//m6meigG5V3Kyr+jAWujATuREgxPIpthng28vMWbseO2eQt3FVC3sLd2KM2 q3vnLdwr6GRX3kJxoeyTV3u/fzoEe+N6SYgAtZVdp7SzB3dLc15TfLeSP1lS5sOZ6Mb3RbuN4Wkc N3CsVGDFiAKjaSyD3Q0z0o8NQZV4pOjMIEtqvXrQwpFEJJviqI9Ejxi46J9CNIYLMBWEpHgeUQFu XDFxFdckzRkHlWuDyQp/8MoO66EBqWtCQCQ3pfz1rPIrfcXlFJeUHM+xJfkIpce3Hti6L4rnSXa/ mjMbz4zSzjgt+/X3Fd3XHr7Ofiic5nKefABz7NTFsdMj9qTsbc9oXcxlz4jCH3VtGNWo/qj6K8Ev 9wbSCq2vyzZRbT9UKN3dtmeqqK1L8Wplz0hhFx49bRsPUjpmeRAjanNmBo+eoDEBddZA21csI22L CC03QGLpFFbcyeGlxsVL1KJUjtVotsq3WrG+iim0xDviXWn05JJYoEhow0OjzqXgCnUPCMU7cgs0 uApsQL9V4IgyE4Hm5F0M6KRxm6awJfUFBlTSuJ2SNO6xSQx9lcawaklA+VfrcDiL+lJXi5ol74aq J0X6Hr17NLd3V7B3V2b17gmM5vSuNs2E1ncUwgbYmPwDIoE7yd/j5Efs6q9x8k4y3nEPp4P4CAun cSE1iUtDrbzxTBqXZfftnWk8m4rfmsQLXzkcNKno6WralC2srZXX2jkmOijNbtbZg0708my9i7uN CpMhOxweUZiMgMqEZnN33Wrp6nzuPFlyGFmixvQmMrKFjGzlte1kZDcHxyCr2uNiYLXFQL3DQACv KTqvz1A3/v9wzMT+m20CsKL4j+5c/29vZ9fc9z8eyuHYf48o+89DMSjg+S2CFon66BKGuHQb/XSs HUM7xyfOT9zKWfhMexC6EB8hhWorVw3Rjqmglftz7ijxKOn9337p/Nj4xMquWU4AxeI/a63vv/d2 ruvt7utV73/PHP7roRzO+39Mvf81HlIvMAHEs7KBj2sPTcXN0Usrz9qJ/30cHW7PUKUUuEBBiJN+ 0J1bsNUzWOMbJ7BdSlWybWVeBjsSd7AjtSbVkOhMnU11Qx7dMqBzeZVTB1tsYJEn/EDt1S4EPzBk a5AvvGOF5G6zPrQWQyNWSbua/OzpCuqWSZXi32MWN8XtXhrURWpaYwqiefY7Hhr1dp+2rFzsfVhn KN+MJ6ZivbQsg6no50DKjInGqCQCrN0+euPsuQlX8vjz46pjNgu7WwojU6LiMDEmzjVeuix5ELdj pyG+Eu/8aruEdZc3w4L/4D9kg8aQ2r/iAf/ZJ86OHPiP7eMoCv85KCM2P6Vb4LxGTgUF9++X96xU eE1W1iE9kNV6yoExOD4+dm27nvsVll1HyILUsg0VitLLbFzeH+d/enOuGDaio29y7fGuVBAU2eNt WYt1sO2ZWoVLFxyGtoiqFNpEVvAErUhN6r+tdDmvhjbexs27qJ9GYyq+fBIrBW9yT0BRaUlRROOv 1767Qd+tyb57G0377CcG+ERDGpvij/K2JMJ2nqrFY1MYvI2opFAefjMQaKgO/enT/3n31wp6sxU7 OF7OilOC8tRtSSp7ZgHv1tNCa1ApiHbSLjrL4XgFy3CVV2/w/iu0fear5wX48qrV1iBNlEO0EgMs sxxP0iYMqhRBT6mN8kFahvLMUTytei1gGa7x+z//z2D9f1D5f3vXdffmrP896+b0/4dzOOv/x3n5 f7XU/wL5f3XFRfP/5mxXjHvP5eVOXMdjfVZhncLwwHr/LMGaz6wswTY21HuJU/DQ4lmCa7Fc9rmt zM0S3OSbJXiVZAluKZYluLVQluD2rCzBSXSIHLm4NksC4IiEWQpkCV6l4y7dTpbgddhgSEDAK+rT j4H7mSV4k4nNsvbLau18bmqg+IZa382+KrKSt7obAhT1Uo9j2Iad0kW7ZqavShRnt5QbVKCkfE3a emaviSGVSlYmqokHmeM15tbB/QKUjmIfnOjKBnzrfmL3pVzjf3DY9X2go9Qz3AMwxnWuQ/4cl8DG CU4qYyqrqv5SkyEf7PHVjamTRoQGh+ioEBnFWStGMVug80VKvfH05TH9NR3FyRqhyxd3HJdL2bt7 RGf5ZUMqzl/fcf4aJ8rL125F5SMY8xrPX28cbTxtX1xjSGxifu77eoA9KMH253LyG+vrEmV4XobM C3yzMm+jPKAGyw28JHdfzkp8rIta91818Zpqi4hKZmh5Vd8wZX8cedR7YyUbsr07f0ZJZ2/gHVMS ImbSHn8T7xt4ryAy7gP5sMxsA9BRmXbHVaTTc+tB4Ayty+x+4sA9eU22A3h3ffHkxCUr0ZlMnlqV LimTp+GbyTOogjKiOlcrMv/FEoIJP27n9KyJJ9JoCE8JOHtVahKrJadnc2oayVS8bRJrJtGZRo8A wNbuS4a626awcb/1K58HeZRPbkslwu2T2DGJx2RvaBp7MvytUZzFWKcEi0wqo5UKMbaG/PTyfxtR Q2W2lipsM45xAdFpjBSHYhgBKk/nMBVoybGZxBM4QMobqf4epCocYtkEFeJDSgkuUyqxfPBks8oV ZLf8KZXNNGKh4V+axpEUO/FpUdqPfYzl7INpjKbipyYxlkzjTPwC/6Rxid0SZLdIutGPPJ66nvXU NG6kJBLCLrs1iRf3t9JEeCWN1/vDPHk7wf59V/omkyxT72Ztp5g6yGgnDe0unvViLVfEJ/j3ME3b sf9t71ibGkeO/qxfMcdSdabqLI/elhOnAgYnXMHCsXubD5uNS5YEKNiWIwsDe7X3Fy6Pu6vKv033 zFge2ZYxXi9XKdQLizSPnld3T3drHjDrxZXfVcbQoI/QpFnnfKr8VPkno5JPrEvQtEor/6r8G7CH YCv8p/IzdE4Mnf1L5VfohI/wht2Eptn0wpD/VriVcMDwPMlKkPR/UGPU9D7dRItcDY/5/02Nr/8y NWobOoRrNqWl/+9Z4PjsoklzoB2YrmmabWPfNm3LPrQ7esduwFMb/sGz6dgd+AdJbM1xjX1D04+M HII8PstkYXoWcGRohm64kEs3LEOHv4Zhsf+ZM9g1hVtYt00Hy9fNI1uDv5becahtObpj2K4DpdtH YC9SCOvYGtSx40CcTm1RP5vVr7hetJHR376pmVD4S9wiKvH/VPvfehmP8b9hm9Pvf6bF+b/c//FM oCho1cLI9+MrVRyTqU7CpBePo/ShZSiKcraPB3+03IZjK8orTjAEjYrxNC96k1ELawVg7+PCs2mE H4NC5KPyr/pcUULNHHXMBE+i6eL9oWB9tzQmHRTQuFTQuFSmcanw3xtI2g/TeMh0qhbGC8z4KydY zFuURXmJbF4IEv+LERpfb7sMHNtV97/bFs3mf5DfyP+6U+7/fhZ49VW9Fw3r42tg9JPjg1b9Oh6E 9Wlj60f3aZgMvX6d00ltGF1dp/2Hej/q1ZVXj2fo6qqh0m4vTD197Uw1XdVVkydX2uet3R8gzydv mPYTiHIg8u9e0hShE68fD2uXCUiduzi5qZmqplpSgp7n3+Dighr6QmogkPzbJOEm2zRJFPSlNy4t ut+/aWeeCykWxORNlNa0XCVGkR8D5tQDgzqZi7tL0B2R1AyoF2XheT87CuCJR2r+iOz+0D7/tMTB uPvHLyezJP4f81sofgP+N3RJ/zeQ/43y/IfnAYn/S/afsf9vxfHi4sEvyfF5WOR/0Me2XMYj+j/Y Xo7gfzAMkYU00AhK+/9ZQEm8Xi9Kmz/Wg3BSn1EDmbZ3l6izmYEIHxFR3ktKNfug1YUUH8jx684Z aRKFCPjxsyBDI4yOdwTkSQ2lSU3/htzd3c1U+6ssbbW9R/A8D5EHLFp03BLNrJ35aQ3oy95W7aQ+ yFouPrY8kB0ReT09Y7jL2H8HvwOMw5SkcZPtR1FRMKl4EvGpN8pQjmIvQxlHAfSo3SGORRyd6JTY DoFX/DHZj0Ycl6wA+bZI7tlnXyPEzY/B0oZg3+FVhfJAR1E8miUAUy4MyDC8I5w+auMoCMnb9nn9 +JykiTcco+CFhhJNd1XdgrGzVIM2LXTTFONt46eDIIdzc2SfVUnjBZiKi/bfc8t/DRd9ZPLftHSU /6ZjlvL/OWAt+Z95Bkr5/0zyH3+v8lIRh6Cd+dPExZJNwve5chHHE/3p+Ox8lnBRtKEjj1SB6RzT 2FshhzkKQL0cAzviCo9+6xMmQrkkni5XXTyVLLvGmBC6QTvZYdwbtVBaRbqyVtp6ldfXRmish9Bc G6G1HkJ7bYSO0vFuQvL1QRLfhEMyikbh12R42+9nA4SDw9y4H8jRxcXZBQxRh+14xF5n21AJjkZ2 elpwG2JM++z0tNvZPz75/uJozjUrRzWJtD5E8EMUq1IgIZOBjwoQvaeEDKJhnBA/DkIIIPCAy5iB RJvkdZxxtZeSOa9vmF6qM3o58MahmsZduSLVuWisSVND6lmNla+BmsvMuqW6NIrjtfRVeFmX50lc oJwLZMgaDWcVsvbhhbz9VyCaD2WYTKPxaLXQPo38ECqRhvfp26n+FA2vFkvppnF1zfSiux8v/yL8 xy3MTssLWxbJMOuW9tQOH4fDQKz9XtrtrrMRSlHF5Sj1leTGUM6LxxzShUiG1vhCaKm5Cu10L7XK r7jg5zAMvX41i+BjTvWnoJnL7RruQuaZoJluKVNn+8pVceNGVQritG/luajg5AVV3j5RzcWIvi7C km2hApuqKi0aaup2LgsTgbiISeXL6Vh68cjS25o0aS+Rzkwaz767EZ+bU0Iuh3iUwxjecIEUkYh8 Gcq/7F+8Boz7PRC6A5jmJawwmCCL2UY/lZzEoC9qYGWmoEuzz3sEP+9FYXW899UqQw97ITPIVllj bELnLVGVZZtATLGv47HpZLvqjqH87a8dmC1JygYIunUwAr1z4pE/x+mbUZxW357uiXaSd6ekir5J 2qV2Daz2QXQPhQ1gLvuGjK89HJC9pqLs8ORiWC5CrHic0B0SeEBNMEcnUdyySBoFLZgSqaXppkPJ kL1qDdv0KMUO4QSu3nlRWt0j7+n9JQ0oxFFVFc9ej35YTnly3tcwxpOQnLLLMmaUWiMYiyMNVfo9 vddtP3SpRf9Aqp7Mw0y55b0ziuO+IOpzeCygerls8cwZ1CmUE8VlqFdh+m3cq0ohXOpoltwUGNUb GIrPb8aKHEBe49tBmOBljEwESO+sThbdQA4oO4cgoZP4AYnu3enOAnVQTb+cUQc1G0Ad0sgBRwcR 46H3mJwDpxBIqV0ChSg7vNSavohd0wJvhl3z9ELa8xtuhhmet0x7VuA6foMN2jymNTSKUf/hvO/5 4TU/IhBoRlreXl2IFxRkFFHQhpVh5SC7RxNeCRZQzQfzGcMppF4s212g3gX0W5m4ixmynLhXMOxJ fAcUPYiTB3IIpgsuBi+U7dSzfIm/GjbwVyJ2B8xz7PQZObYNdhHYaAkvfm7ucCX8ri/NHZrtry0d etQ2rAaW9Sa6Auogh9F45KU+mJUrSoMGSKWtK4vklnVA6ehHH+dLaUilNC7lPqPFMsmjZtYeeN72 fOiZ/uW8GEjCS+BEXG4+9MPvbsPbcPcE2LeAkBZTQ9AgnoTVuVAhkuzCSe3Z6zLHT3k82SDuZk8S z2RhU2PZRbbJSiHi/qw8AWhUpoBeIM15l8UU4DaMjALgefsUEDgre31Vh6+rCBWhzp5Ef7G+zQLX IZn1Kq/sgGLLh29nkeUbhqx+GL4swHjW8xDyBJFP3nrjm2JEvZykanhFsgOQznxHbS6R8lhzpKJZ kkiC91z9lhkaljA0uEuciAWMYO94UFKwNIv99CzO07M0np7FfXoWjW6QR9sgj746T+m2LN2Wpduy dFuWbsv/J+tnqaQ31nXdLc1tbjC3PDKHv4BVHyWUUEIJJZRQQgkllFDCS4T/ASwkZGEAQAEA 257 2006-12-11 15:44:09 +0000 2006-12-11 15:44:09 +0000 patch against 2.3 beta to remove all calls to close() operation GIOPConnection.java.patch.2 text/plain 2346 marc.heide KioqIEdJT1BDb25uZWN0aW9uLmphdmEub3JpZwlUaHUgT2N0IDI2IDEzOjQ4OjI3IDIwMDYKLS0t IEdJT1BDb25uZWN0aW9uLmphdmEJTW9uIERlYyAxMSAxNToyNDozNCAyMDA2CioqKioqKioqKioq KioqKgoqKiogNDk5LDUwOSAqKioqCiAgICAgICAgICAgICAgICAgICAgICAgICAgICArICJpbmNv cnJlY3QgbWFnaWMgbnVtYmVyIC0tPiBjb25uZWN0aW9uIGNsb3NlZCIgKTsNCiAgICAgICAgICB9 DQogICAgICAgICAgDQohICAgICAgICAgLy8gY2xvc2UgdHJhbnNwb3J0IGNvbm5lY3Rpb24sIHRo ZXJlIGlzIG5lYXJseSBubyBjaGFuY2UgdG8gc3luYw0KISAgICAgICAgIC8vIHdpdGggcGVlciBv biB0aGlzIGNvbm5lY3Rpb24gYWdhaW4NCiEgICAgICAgICBjbG9zZSgpOw0KISAgICAgICAgIA0K ISAgICAgICAgIC8vIG5vdGlmeSBHSU9QQ29ubmVjdGlvbk1hbmFnZXIgb2YgY2xvc2UNCiAgICAg ICAgICB0aGlzLnN0cmVhbUNsb3NlZCgpOw0KICAgDQogICAgICAgICAgcmV0dXJuIG51bGw7DQot LS0gNDk5LDUwNiAtLS0tCiAgICAgICAgICAgICAgICAgICAgICAgICAgICArICJpbmNvcnJlY3Qg bWFnaWMgbnVtYmVyIC0tPiBjb25uZWN0aW9uIGNsb3NlZCIgKTsNCiAgICAgICAgICB9DQogICAg ICAgICAgDQohICAgICAgICAgLy9jbG9zZSB0cmFuc3BvcnQgY29ubmVjdGlvbiwgdGhlcmUgaXMg bmVhcmx5IG5vIGNoYW5jZSB0byBzeW5jIHdpdGgNCiEgICAgICAgICAvL3BlZXIgb24gdGhpcyBj b25uZWN0aW9uIGFnYWluDQogICAgICAgICAgdGhpcy5zdHJlYW1DbG9zZWQoKTsNCiAgDQogICAg ICAgICAgcmV0dXJuIG51bGw7DQoqKioqKioqKioqKioqKioKKioqIDk4Nyw5OTggKioqKgogICAg ICAgICAgICAgIHsNCiAgICAgICAgICAgICAgICAgIGlmIChsb2dnZXIuaXNFcnJvckVuYWJsZWQo KSkNCiAgICAgICAgICAgICAgICAgIHsNCiEgICAgICAgICAgICAgICAgICAgICBsb2dnZXIuZXJy b3IoICJHSU9QIGNvbm5lY3Rpb24gY2xvc2VkIGR1ZSB0byBlcnJvcnMgZHVyaW5nIHNlbmRNZXNz YWdlIik7DQogICAgICAgICAgICAgICAgICB9DQohICAgICAgICAgICAgICAgICAvL2Nsb3NlIHRy YW5zcG9ydCBjb25uZWN0aW9uLCB0aGVyZSBpcyBuZWFybHkgbm8gY2hhbmNlIHRvIHN5bmMgd2l0 aA0KISAgICAgICAgICAgICAgICAgLy9wZWVyIG9uIHRoaXMgY29ubmVjdGlvbiBhZ2Fpbg0KISAg ICAgICAgICAgICAgICAgY2xvc2UoKTsNCiEgICAgICAgICAgICAgICAgIC8vc2lnbmFsIEdJT1BD b25uZWN0aW9uTWFuYWdlciB0byB0aHJvdyB0aGlzIGNvbm5lY3Rpb24gYXdheQ0KICAgICAgICAg ICAgICAgICAgdGhpcy5zdHJlYW1DbG9zZWQoKTsNCiAgICAgICAgICAgICAgfQ0KICAgICAgICAg ICAgICB0aHJvdyBlOw0KLS0tIDk4NCwxMDAwIC0tLS0KICAgICAgICAgICAgICB7DQogICAgICAg ICAgICAgICAgICBpZiAobG9nZ2VyLmlzRXJyb3JFbmFibGVkKCkpDQogICAgICAgICAgICAgICAg ICB7DQohICAgICAgICAgICAgICAgICAgICAgbG9nZ2VyLmVycm9yKCAiVW5kZXJseWluZyB0cmFu c3BvcnQgY29ubmVjdGlvbiBjbG9zZWQgZHVlIHRvIGVycm9ycyBkdXJpbmcgc2VuZE1lc3NhZ2Ui KTsNCiAgICAgICAgICAgICAgICAgIH0NCiEgICAgICAgICAgICAgICAgIC8vcmVsZWFzZSB3cml0 ZSBsb2NrIHRvIHByZXZlbnQgZGVhZCBsb2NrcyB0bw0KISAgICAgICAgICAgICAgICAgLy9yZWFk ZXIgdGhyZWFkIHdoaWNoIG1pZ2h0IHRyeSB0byBjbG9zZSB0aGlzIHNvY2tldCB0b28NCiEgICAg ICAgICAgICAgICAgIC8vY29uY3VycmVudGx5ICh1bmZvcnR1bmF0ZWx5IHdyaXRlIGxvY2sgaXMg cmVxdWVzdGVkIGR1cmluZyBzdHJlYW1DbG9zZWQoKSkNCiEgICAgICAgICAgICAgICAgIHJlbGVh c2VXcml0ZUxvY2soKTsNCiEgICAgICAgICAgICAgICAgIC8vY2xvc2UgdHJhbnNwb3J0IGNvbm5l Y3Rpb24sDQohICAgICAgICAgICAgICAgICAvL2Vycm9yIGR1cmluZyB3cml0ZSBpbmRpY2F0ZSBo ZWF2eSBwcm9ibGVtcyB3aXRoIGN1cnJlbnQgY29ubmVjdGlvbiwNCiEgICAgICAgICAgICAgICAg IC8vaXQgbWFrZXMgbm8gc2Vuc2UgdG8gdXNlIHRoaXMgdHJhbnNwb3J0IGFueSBsb25nZXINCiEg ICAgICAgICAgICAgICAgIC8vZXhhbXBsZXM6IGZpcmV3YWxsIGRyb3BwZWQgY29ubmVjdGlvbiBz aWxlbnRseSwNCiEgICAgICAgICAgICAgICAgIC8vICAgICAgICAgIHNvY2tldCBzeXN0ZW0gYnVm ZmVycyBmdWxsIChwZWVyIGRpZG50IHJlYWQgZGF0YSBpbiB0aW1lKQ0KICAgICAgICAgICAgICAg ICAgdGhpcy5zdHJlYW1DbG9zZWQoKTsNCiAgICAgICAgICAgICAgfQ0KICAgICAgICAgICAgICB0 aHJvdyBlOw0K 363 2009-06-02 08:47:40 +0000 2009-06-08 09:01:33 +0000 Solve potential deadlock in GIOPConnection. GIOPConnection.patch text/plain 4216 kent.au SW5kZXg6IFNlcnZlckdJT1BDb25uZWN0aW9uLmphdmENCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NClJDUyBmaWxlOiAv d2ViL3d3dy5qYWNvcmIub3JnL2N2cy9qYWNvcmIvSmFjT1JCL3NyYy9vcmcvamFjb3JiL29yYi9n aW9wL1NlcnZlckdJT1BDb25uZWN0aW9uLmphdmEsdg0KcmV0cmlldmluZyByZXZpc2lvbiAxLjI0 DQpkaWZmIC1yMS4yNCBTZXJ2ZXJHSU9QQ29ubmVjdGlvbi5qYXZhDQoyMzJhMjMzLDI0Mw0KPiAg ICAgICogSW4gb3JkZXIgdG8gZml4IENPTU1fRkFJTFVSRSBkZWFkbG9jayBieSBLZW50IDIwMDkt MDYtMDENCj4gICAgICAqLw0KPiAJcHJvdGVjdGVkIHZvaWQgc3RyZWFtQ2xvc2VkV2l0aG91dFdy aXRlTG9jaygpIHsNCj4gCQlpZiAobG9nZ2VyLmlzRGVidWdFbmFibGVkKCkpDQo+ICAgICAgICAg ew0KPiAgICAgICAgICAgICBsb2dnZXIuZGVidWcgKHRoaXMudG9TdHJpbmcoKSArICI6IHN0cmVh bUNsb3NlZFdpdGhvdXRXcml0ZUxvY2soKSIpOw0KPiAgICAgICAgIH0NCj4gCQl0aGlzLnN0cmVh bUNsb3NlZCgpOw0KPiAJfQ0KPiAgICAgDQo+ICAgICAvKioNCkluZGV4OiBDbGllbnRHSU9QQ29u bmVjdGlvbi5qYXZhDQo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09DQpSQ1MgZmlsZTogL3dlYi93d3cuamFjb3JiLm9yZy9j dnMvamFjb3JiL0phY09SQi9zcmMvb3JnL2phY29yYi9vcmIvZ2lvcC9DbGllbnRHSU9QQ29ubmVj dGlvbi5qYXZhLHYNCnJldHJpZXZpbmcgcmV2aXNpb24gMS4xNw0KZGlmZiAtcjEuMTcgQ2xpZW50 R0lPUENvbm5lY3Rpb24uamF2YQ0KMTE0YTExNSwxMzUNCj4gICAgICAqIEFkZCB0aGlzIG1ldGhv ZCBpbiBvcmRlciB0byBmaXggQ09NTV9GQUlMVVJFIGRlYWRsb2NrIGJ5IEtlbnQgMjAwOS0wNS0z MQ0KPiAgICAgICogQ2xpZW50LXNpZGUgaW1wbGVtZW50YXRpb24gd2hhdCB0byBkbyB3aGVuIHRo ZSB1bmRlcmx5aW5nIHRyYW5zcG9ydA0KPiAgICAgICogaXMgY2xvc2VkIGR1cmluZyBhIHJlYWQg b3BlcmF0aW9uLiAgV2UgbWFyayB0aGUgdHJhbnNwb3J0IGFzIGNsb3NlZA0KPiAgICAgICogYW5k IGFsbG93IGl0IHRvIGJlIHJlb3BlbmVkIGxhdGVyLCB3aGVuIHRoZSBjbGllbnQgcmV0cmllcy4N Cj4gICAgICAqLw0KPiAgICAgcHJvdGVjdGVkIHZvaWQgc3RyZWFtQ2xvc2VkV2l0aG91dFdyaXRl TG9jaygpDQo+ICAgICB7DQo+ICAgICAgICAgaWYgKGxvZ2dlci5pc0RlYnVnRW5hYmxlZCgpKQ0K PiAgICAgICAgIHsNCj4gICAgICAgICAgICAgbG9nZ2VyLmRlYnVnICh0aGlzLnRvU3RyaW5nKCkg KyAiOiBzdHJlYW1DbG9zZWRXaXRob3V0V3JpdGVMb2NrKCkiKTsNCj4gICAgICAgICB9DQo+IA0K PiAgICAgICAgIGNsb3NlQWxsb3dSZW9wZW5XaXRob3V0V3JpdGVMb2NrKCk7DQo+IA0KPiAgICAg ICAgIGlmKCBjb25uZWN0aW9uX2xpc3RlbmVyICE9IG51bGwgKQ0KPiAgICAgICAgIHsNCj4gICAg ICAgICAgICAgY29ubmVjdGlvbl9saXN0ZW5lci5zdHJlYW1DbG9zZWQoKTsNCj4gICAgICAgICB9 DQo+ICAgICB9DQo+ICAgICANCj4gICAgIC8qKg0KMTQyYTE2NCwxOTMNCj4gICAgIC8qKg0KPiAg ICAgICogQWRkIHRoaXMgbWV0aG9kIGluIG9yZGVyIHRvIGZpeCBDT01NX0ZBSUxVUkUgZGVhZGxv Y2sgYnkgS2VudCAyMDA5LTA1LTMxDQo+ICAgICAgKiBDbG9zZXMgdGhlIHVuZGVybHlpbmcgdHJh bnNwb3J0LCBidXQga2VlcHMgdGhpcyBDbGllbnRHSU9QQ29ubmVjdGlvbg0KPiAgICAgICogYWxp dmUuICBJZiwgc3Vic2VxdWVudGx5LCBhbm90aGVyIHJlcXVlc3QgaXMgc2VudCB0byB0aGlzIGNv bm5lY3Rpb24sDQo+ICAgICAgKiBpdCB3aWxsIHRyeSB0byByZW9wZW4gdGhlIHRyYW5zcG9ydC4N Cj4gICAgICAqLw0KPiAgICAgcHJpdmF0ZSB2b2lkIGNsb3NlQWxsb3dSZW9wZW5XaXRob3V0V3Jp dGVMb2NrKCkNCj4gICAgIHsNCj4gICAgICAgICBpZiAobG9nZ2VyLmlzRGVidWdFbmFibGVkKCkp DQo+ICAgICAgICAgew0KPiAgICAgICAgICAgICBsb2dnZXIuZGVidWcgKHRoaXMudG9TdHJpbmco KSArICI6IGNsb3NlQWxsb3dSZW9wZW5XaXRob3V0V3JpdGVMb2NrKCkiKTsNCj4gICAgICAgICB9 DQo+IA0KPiAgICAgICAgIC8vdHJ5DQo+ICAgICAgICAgLy97DQo+ICAgICAgICAgICAgIHN5bmNo cm9uaXplZCAoY29ubmVjdF9zeW5jKQ0KPiAgICAgICAgICAgICB7DQo+ICAgICAgICAgICAgICAg ICAvL2dldFdyaXRlTG9jaygpOw0KPiAgICAgICAgICAgICAgICAgdHJhbnNwb3J0LmNsb3NlKCk7 DQo+ICAgICAgICAgICAgICAgICAvLyBXZSBleHBlY3QgdGhhdCB0aGUgc2FtZSB0cmFuc3BvcnQg Y2FuIGJlIHJlY29ubmVjdGVkDQo+ICAgICAgICAgICAgICAgICAvLyBhZnRlciBhIGNsb3NlLCBz b21ldGhpbmcgdGhhdCB0aGUgRVRGIGRyYWZ0IGlzbid0DQo+ICAgICAgICAgICAgICAgICAvLyBw YXJ0aWN1bGFybHkgY2xlYXIgYWJvdXQuDQo+ICAgICAgICAgICAgIH0NCj4gICAgICAgICAvL30N Cj4gICAgICAgICAvL2ZpbmFsbHkNCj4gICAgICAgICAvL3sNCj4gICAgICAgICAgICAgLy9yZWxl YXNlV3JpdGVMb2NrKCk7DQo+ICAgICAgICAgLy99DQo+ICAgICB9DQo+IA0KSW5kZXg6IEdJT1BD b25uZWN0aW9uLmphdmENCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0NClJDUyBmaWxlOiAvd2ViL3d3dy5qYWNvcmIub3Jn L2N2cy9qYWNvcmIvSmFjT1JCL3NyYy9vcmcvamFjb3JiL29yYi9naW9wL0dJT1BDb25uZWN0aW9u LmphdmEsdg0KcmV0cmlldmluZyByZXZpc2lvbiAxLjY2DQpkaWZmIC1yMS42NiBHSU9QQ29ubmVj dGlvbi5qYXZhDQozMDBhMzAxLDMwNQ0KPiAgICAgDQo+ICAgICAvKioNCj4gICAgICAqIEFkZCB0 aGlzIG1ldGhvZCBpbiBvcmRlciB0byBmaXggQ09NTV9GQUlMVVJFIGRlYWRsb2NrIGJ5IEtlbnQg MjAwOS0wNS0zMQ0KPiAgICAgICovDQo+ICAgICBwcm90ZWN0ZWQgYWJzdHJhY3Qgdm9pZCBzdHJl YW1DbG9zZWRXaXRob3V0V3JpdGVMb2NrKCk7DQozNDBjMzQ1LDM0Nw0KPCAgICAgICAgICAgICB0 aGlzLnN0cmVhbUNsb3NlZCgpOw0KLS0tDQo+ICAgICAgICAgICAgIC8vRklYTUUganVzdCByZW1v dmUgZ2V0V3JpdGVMb2NrKCksIHVua25vdyBpbXBhY3QuCWJ5IEtlbnQNCj4gICAgICAgICAgICAg Ly90aGlzLnN0cmVhbUNsb3NlZCgpOw0KPiAgICAgICAgICAgICB0aGlzLnN0cmVhbUNsb3NlZFdp dGhvdXRXcml0ZUxvY2soKTsNCjQ1MWM0NTgsNDU5DQo8ICAgICAgICAgY2xvc2UoKTsNCi0tLQ0K PiAgICAgICAgIC8vIFJlbW92ZWQuIFNlZSBKYWNPUkIgQnVnIDcwOCANCj4gICAgICAgICAvL2Ns b3NlKCk7DQo0NTNjNDYxDQo8ICAgICAgICAgLy8gbm90aWZ5IEdJT1BDb25uZWN0aW9uTWFuYWdl ciBvZiBjbG9zZQ0KLS0tDQo+ICAgICAgICAgLy8gbm90aWZ5IEdJT1BDb25uZWN0aW9uTWFuYWdl ciBvZiBjbG9zZQkvL0ZJWE1FIHNob3VsZCBjYWxsIHN0cmVhbUNsb3NlZFdpdGhvdXRXcml0ZUxv Y2soKQ0KOTg0Yzk5Miw5OTMNCjwgICAgICAgICAgICAgICAgIHJlbGVhc2VXcml0ZUxvY2soKTsN Ci0tLQ0KPiAgICAgICAgICAgICAgICAgLy9SZW1vdmUgdGhlIGZvbGxvd2luZyBsaW5lIGluIG9y ZGVyIHRvIGZpeCBDT01NX0ZBSUxVUkUgZGVhZGxvY2sgYnkgS2VudCAyMDA5LTA1LTMxDQo+ICAg ICAgICAgICAgICAgICAvL3JlbGVhc2VXcml0ZUxvY2soKTsNCjk4N2M5OTYsOTk3DQo8ICAgICAg ICAgICAgICAgICBjbG9zZSgpOw0KLS0tDQo+ICAgICAgICAgICAgICAgICAvLyBSZW1vdmVkLiBT ZWUgSmFjT1JCIEJ1ZyA3MDggDQo+ICAgICAgICAgICAgICAgICAvL2Nsb3NlKCk7DQo5ODljOTk5 LDEwMDINCjwgICAgICAgICAgICAgICAgIHRoaXMuc3RyZWFtQ2xvc2VkKCk7DQotLS0NCj4gICAg ICAgICAgICAgICAgIC8vQ2FsbCBhbm90aGVyIHN0cmVhbUNsb3NlZCgpIG1ldGhvZCBpbiBvcmRl ciB0byBmaXggQ09NTV9GQUlMVVJFIGRlYWRsb2NrIGJ5IEtlbnQgMjAwOS0wNS0zMQ0KPiAgICAg ICAgICAgICAgICAgLy90aGlzLnN0cmVhbUNsb3NlZCgpOw0KPiAgICAgICAgICAgICAgICAgdGhp cy5zdHJlYW1DbG9zZWRXaXRob3V0V3JpdGVMb2NrKCk7DQo+ICAgICAgICAgICAgICAgICANCg== 364 2009-06-08 09:01:33 +0000 2009-06-08 09:01:33 +0000 Solve potential deadlock in GIOPConnection. Last update 08 Jun 2009. GIOPConnection_20090608.patch text/plain 1076 kent.au SW5kZXg6IENsaWVudEdJT1BDb25uZWN0aW9uLmphdmENCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0NClJDUyBmaWxlOiAv d2ViL3d3dy5qYWNvcmIub3JnL2N2cy9qYWNvcmIvSmFjT1JCL3NyYy9vcmcvamFjb3JiL29yYi9n aW9wL0NsaWVudEdJT1BDb25uZWN0aW9uLmphdmEsdg0KcmV0cmlldmluZyByZXZpc2lvbiAxLjE3 DQpkaWZmIC1yMS4xNyBDbGllbnRHSU9QQ29ubmVjdGlvbi5qYXZhDQoxMjdhMTI4LDEzMA0KPiAg ICAgICAgIAkvL1NvbHZlIHBvdGVudGlhbCBkZWFkbG9jayBjYXVzZWQgYnkgQ09NTV9GQUlMVVJF Lg0KPiAgICAgICAgIAkvL1RoZSBzdHJhdGVneSBpcyBnZXR0aW5nIHdyaXRlX2xvY2sgYmVmb3Jl IHN5bmMgY29ubmVjdF9zeW5jIHdoZW4geW91IG5lZWQgYm90aCBvZiB0aGVtLg0KPiAgICAgICAg IAlnZXRXcml0ZUxvY2soKTsNCjEzMGMxMzMsMTM0DQo8ICAgICAgICAgICAgICAgICBnZXRXcml0 ZUxvY2soKTsNCi0tLQ0KPiAgICAgICAgICAgICAJLy9SZW1vdmVkLiBTZWUgYWJvdmUuDQo+ICAg ICAgICAgICAgICAgICAvL2dldFdyaXRlTG9jaygpOw0KSW5kZXg6IEdJT1BDb25uZWN0aW9uLmph dmENCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0NClJDUyBmaWxlOiAvd2ViL3d3dy5qYWNvcmIub3JnL2N2cy9qYWNvcmIv SmFjT1JCL3NyYy9vcmcvamFjb3JiL29yYi9naW9wL0dJT1BDb25uZWN0aW9uLmphdmEsdg0KcmV0 cmlldmluZyByZXZpc2lvbiAxLjY2DQpkaWZmIC1yMS42NiBHSU9QQ29ubmVjdGlvbi5qYXZhDQo0 NTFjNDUxLDQ1Mg0KPCAgICAgICAgIGNsb3NlKCk7DQotLS0NCj4gICAgICAgICAvL1JlbW92ZWQu IFNlZSBpc3N1ZSBJRCA3MDgNCj4gICAgICAgICAvL2Nsb3NlKCk7DQo5ODdjOTg4LDk4OQ0KPCAg ICAgICAgICAgICAgICAgY2xvc2UoKTsNCi0tLQ0KPiAgICAgICAgICAgICAgICAgLy9SZW1vdmVk LiBTZWUgaXNzdWUgSUQgNzA4DQo+ICAgICAgICAgICAgICAgICAvL2Nsb3NlKCk7DQo=