From ff0d4c4550026cce44eb4043a14aafa6602385ac Mon Sep 17 00:00:00 2001 From: Cesare Rocchi Date: Mon, 22 Aug 2011 19:09:53 +0200 Subject: [PATCH] aa --- Classes/JabberClientAppDelegate.h | 47 + Classes/JabberClientAppDelegate.m | 191 + Classes/SMBuddyListViewController.h | 38 + Classes/SMBuddyListViewController.m | 158 + Classes/SMChatDelegate.h | 20 + Classes/SMChatViewController.h | 31 + Classes/SMChatViewController.m | 179 + Classes/SMChatViewController.xib | 639 ++ Classes/SMLoginViewController.h | 26 + Classes/SMLoginViewController.m | 63 + Classes/SMLoginViewController.xib | 632 ++ Classes/SMMessageDelegate.h | 16 + JabberClient-Info.plist | 30 + JabberClient.xcodeproj/cesarerocchi.mode1v3 | 1422 ++++ JabberClient.xcodeproj/cesarerocchi.pbxuser | 313 + JabberClient.xcodeproj/project.pbxproj | 1033 +++ JabberClientViewController.xib | 559 ++ JabberClient_Prefix.pch | 8 + MainWindow.xib | 443 ++ main.m | 17 + xmpp/Categories/NSData+XMPP.h | 14 + xmpp/Categories/NSData+XMPP.m | 158 + xmpp/Categories/NSNumber+XMPP.h | 21 + xmpp/Categories/NSNumber+XMPP.m | 140 + xmpp/Categories/NSXMLElement+XMPP.h | 47 + xmpp/Categories/NSXMLElement+XMPP.m | 231 + xmpp/Core/XMPP.h | 9 + xmpp/Core/XMPPElement.h | 28 + xmpp/Core/XMPPElement.m | 80 + xmpp/Core/XMPPIQ.h | 75 + xmpp/Core/XMPPIQ.m | 154 + xmpp/Core/XMPPInternal.h | 49 + xmpp/Core/XMPPJID.h | 33 + xmpp/Core/XMPPJID.m | 390 + xmpp/Core/XMPPLogging.h | 174 + xmpp/Core/XMPPMessage.h | 35 + xmpp/Core/XMPPMessage.m | 141 + xmpp/Core/XMPPModule.h | 39 + xmpp/Core/XMPPModule.m | 238 + xmpp/Core/XMPPParser.h | 47 + xmpp/Core/XMPPParser.m | 749 ++ xmpp/Core/XMPPPresence.h | 36 + xmpp/Core/XMPPPresence.m | 122 + xmpp/Core/XMPPStream.h | 804 ++ xmpp/Core/XMPPStream.m | 4227 +++++++++++ .../CoreDataStorage/XMPPCoreDataStorage.h | 97 + .../CoreDataStorage/XMPPCoreDataStorage.m | 656 ++ .../XMPPCoreDataStorageProtected.h | 237 + xmpp/Extensions/Reconnect/XMPPReconnect.h | 170 + xmpp/Extensions/Reconnect/XMPPReconnect.m | 645 ++ .../XMPPGroupCoreDataStorageObject.h | 26 + .../XMPPGroupCoreDataStorageObject.m | 94 + .../XMPPResourceCoreDataStorageObject.h | 40 + .../XMPPResourceCoreDataStorageObject.m | 214 + .../XMPPRoster.xcdatamodel/elements | Bin 0 -> 107911 bytes .../XMPPRoster.xcdatamodel/layout | Bin 0 -> 12498 bytes .../XMPPRosterCoreDataStorage.h | 38 + .../XMPPRosterCoreDataStorage.m | 463 ++ .../XMPPUserCoreDataStorageObject.h | 64 + .../XMPPUserCoreDataStorageObject.m | 451 ++ .../MemoryStorage/XMPPResourceMemoryStorage.h | 19 + .../MemoryStorage/XMPPResourceMemoryStorage.m | 193 + .../MemoryStorage/XMPPRosterMemoryStorage.h | 67 + .../MemoryStorage/XMPPRosterMemoryStorage.m | 731 ++ .../XMPPRosterMemoryStoragePrivate.h | 36 + .../MemoryStorage/XMPPUserMemoryStorage.h | 32 + .../MemoryStorage/XMPPUserMemoryStorage.m | 428 ++ xmpp/Extensions/Roster/XMPPResource.h | 17 + xmpp/Extensions/Roster/XMPPRoster.h | 148 + xmpp/Extensions/Roster/XMPPRoster.m | 606 ++ xmpp/Extensions/Roster/XMPPRosterPrivate.h | 16 + xmpp/Extensions/Roster/XMPPUser.h | 45 + xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.h | 77 + xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.m | 216 + .../XEP-0009/XMPPIQ+JabberRPCResonse.h | 66 + .../XEP-0009/XMPPIQ+JabberRPCResonse.m | 291 + .../Extensions/XEP-0009/XMPPJabberRPCModule.h | 48 + .../Extensions/XEP-0009/XMPPJabberRPCModule.m | 349 + .../Extensions/XEP-0045/XMPPMessage+XEP0045.h | 10 + .../Extensions/XEP-0045/XMPPMessage+XEP0045.m | 24 + xmpp/Extensions/XEP-0045/XMPPRoom.h | 58 + xmpp/Extensions/XEP-0045/XMPPRoom.m | 710 ++ xmpp/Extensions/XEP-0045/XMPPRoomOccupant.h | 25 + xmpp/Extensions/XEP-0045/XMPPRoomOccupant.m | 58 + .../XMPPvCard.xcdatamodeld/.xccurrentversion | 8 + .../XMPPvCard.xcdatamodel/elements | Bin 0 -> 36011 bytes .../XMPPvCard.xcdatamodel/layout | Bin 0 -> 10268 bytes .../XMPPvCardAvatarCoreDataStorageObject.h | 20 + .../XMPPvCardAvatarCoreDataStorageObject.m | 17 + .../XMPPvCardCoreDataStorage.h | 47 + .../XMPPvCardCoreDataStorage.m | 235 + .../XMPPvCardCoreDataStorageObject.h | 73 + .../XMPPvCardCoreDataStorageObject.m | 177 + .../XMPPvCardTempCoreDataStorageObject.h | 23 + .../XMPPvCardTempCoreDataStorageObject.m | 17 + xmpp/Extensions/XEP-0054/XMPPvCardTemp.h | 120 + xmpp/Extensions/XEP-0054/XMPPvCardTemp.m | 932 +++ xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.h | 31 + xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.m | 132 + .../XEP-0054/XMPPvCardTempAdrTypes.h | 28 + .../XEP-0054/XMPPvCardTempAdrTypes.m | 99 + xmpp/Extensions/XEP-0054/XMPPvCardTempBase.h | 68 + xmpp/Extensions/XEP-0054/XMPPvCardTempBase.m | 65 + xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.h | 30 + xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.m | 121 + xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.h | 25 + xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.m | 90 + .../Extensions/XEP-0054/XMPPvCardTempModule.h | 91 + .../Extensions/XEP-0054/XMPPvCardTempModule.m | 207 + xmpp/Extensions/XEP-0054/XMPPvCardTempTel.h | 38 + xmpp/Extensions/XEP-0054/XMPPvCardTempTel.m | 200 + xmpp/Extensions/XEP-0060/XMPPPubSub.h | 43 + xmpp/Extensions/XEP-0060/XMPPPubSub.m | 374 + xmpp/Extensions/XEP-0065/TURNSocket.h | 78 + xmpp/Extensions/XEP-0065/TURNSocket.m | 1550 ++++ .../XEP-0082/NSDate+XMPPDateTimeProfiles.h | 26 + .../XEP-0082/NSDate+XMPPDateTimeProfiles.m | 79 + .../XEP-0082/XMPPDateTimeProfiles.h | 17 + .../XEP-0082/XMPPDateTimeProfiles.m | 293 + xmpp/Extensions/XEP-0100/XMPPTransports.h | 21 + xmpp/Extensions/XEP-0100/XMPPTransports.m | 149 + .../XMPPCapabilities.xcdatamodel/elements | Bin 0 -> 45046 bytes .../XMPPCapabilities.xcdatamodel/layout | Bin 0 -> 7630 bytes .../XMPPCapabilitiesCoreDataStorage.h | 35 + .../XMPPCapabilitiesCoreDataStorage.m | 603 ++ .../XMPPCapsCoreDataStorageObject.h | 30 + .../XMPPCapsCoreDataStorageObject.m | 26 + .../XMPPCapsResourceCoreDataStorageObject.h | 23 + .../XMPPCapsResourceCoreDataStorageObject.m | 32 + xmpp/Extensions/XEP-0115/XMPPCapabilities.h | 349 + xmpp/Extensions/XEP-0115/XMPPCapabilities.m | 1695 +++++ .../XEP-0153/XMPPvCardAvatarModule.h | 80 + .../XEP-0153/XMPPvCardAvatarModule.m | 257 + xmpp/Extensions/XEP-0199/XMPPAutoPing.h | 87 + xmpp/Extensions/XEP-0199/XMPPAutoPing.m | 406 ++ xmpp/Extensions/XEP-0199/XMPPPing.h | 52 + xmpp/Extensions/XEP-0199/XMPPPing.m | 403 + xmpp/Extensions/XEP-0202/XMPPTime.h | 94 + xmpp/Extensions/XEP-0202/XMPPTime.m | 595 ++ xmpp/Extensions/XEP-0203/XMPPElement+Delay.h | 10 + xmpp/Extensions/XEP-0203/XMPPElement+Delay.m | 81 + xmpp/Utilities/DDList.h | 58 + xmpp/Utilities/DDList.m | 252 + xmpp/Utilities/GCDMulticastDelegate.h | 70 + xmpp/Utilities/GCDMulticastDelegate.m | 577 ++ xmpp/Utilities/LibIDN.h | 32 + xmpp/Utilities/LibIDN.m | 52 + xmpp/Utilities/RFImageToDataTransformer.h | 19 + xmpp/Utilities/RFImageToDataTransformer.m | 48 + xmpp/Utilities/XMPPSRVResolver.h | 85 + xmpp/Utilities/XMPPSRVResolver.m | 692 ++ xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.h | 928 +++ xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.m | 6492 +++++++++++++++++ xmpp/Vendor/CocoaLumberjack/DDASLLogger.h | 41 + xmpp/Vendor/CocoaLumberjack/DDASLLogger.m | 86 + .../DDAbstractDatabaseLogger.h | 102 + .../DDAbstractDatabaseLogger.m | 608 ++ xmpp/Vendor/CocoaLumberjack/DDFileLogger.h | 293 + xmpp/Vendor/CocoaLumberjack/DDFileLogger.m | 1498 ++++ xmpp/Vendor/CocoaLumberjack/DDLog.h | 615 ++ xmpp/Vendor/CocoaLumberjack/DDLog.m | 1491 ++++ xmpp/Vendor/CocoaLumberjack/DDTTYLogger.h | 49 + xmpp/Vendor/CocoaLumberjack/DDTTYLogger.m | 173 + .../KissXML/Categories/NSString+DDXML.h | 14 + .../KissXML/Categories/NSString+DDXML.m | 29 + xmpp/Vendor/KissXML/DDXML.h | 91 + xmpp/Vendor/KissXML/DDXMLDocument.h | 67 + xmpp/Vendor/KissXML/DDXMLDocument.m | 122 + xmpp/Vendor/KissXML/DDXMLElement.h | 49 + xmpp/Vendor/KissXML/DDXMLElement.m | 774 ++ xmpp/Vendor/KissXML/DDXMLNode.h | 136 + xmpp/Vendor/KissXML/DDXMLNode.m | 2331 ++++++ xmpp/Vendor/KissXML/Private/DDXMLPrivate.h | 200 + xmpp/Vendor/libidn/idn-int.h | 524 ++ xmpp/Vendor/libidn/libidn-1.15.tar.gz | Bin 0 -> 2635155 bytes xmpp/Vendor/libidn/libidn.a | Bin 0 -> 1295932 bytes xmpp/Vendor/libidn/stringprep.h | 223 + 177 files changed, 50574 insertions(+) create mode 100644 Classes/JabberClientAppDelegate.h create mode 100644 Classes/JabberClientAppDelegate.m create mode 100644 Classes/SMBuddyListViewController.h create mode 100644 Classes/SMBuddyListViewController.m create mode 100644 Classes/SMChatDelegate.h create mode 100644 Classes/SMChatViewController.h create mode 100644 Classes/SMChatViewController.m create mode 100644 Classes/SMChatViewController.xib create mode 100644 Classes/SMLoginViewController.h create mode 100644 Classes/SMLoginViewController.m create mode 100644 Classes/SMLoginViewController.xib create mode 100644 Classes/SMMessageDelegate.h create mode 100644 JabberClient-Info.plist create mode 100644 JabberClient.xcodeproj/cesarerocchi.mode1v3 create mode 100644 JabberClient.xcodeproj/cesarerocchi.pbxuser create mode 100755 JabberClient.xcodeproj/project.pbxproj create mode 100644 JabberClientViewController.xib create mode 100644 JabberClient_Prefix.pch create mode 100644 MainWindow.xib create mode 100644 main.m create mode 100644 xmpp/Categories/NSData+XMPP.h create mode 100644 xmpp/Categories/NSData+XMPP.m create mode 100644 xmpp/Categories/NSNumber+XMPP.h create mode 100644 xmpp/Categories/NSNumber+XMPP.m create mode 100644 xmpp/Categories/NSXMLElement+XMPP.h create mode 100644 xmpp/Categories/NSXMLElement+XMPP.m create mode 100644 xmpp/Core/XMPP.h create mode 100644 xmpp/Core/XMPPElement.h create mode 100644 xmpp/Core/XMPPElement.m create mode 100644 xmpp/Core/XMPPIQ.h create mode 100644 xmpp/Core/XMPPIQ.m create mode 100644 xmpp/Core/XMPPInternal.h create mode 100644 xmpp/Core/XMPPJID.h create mode 100644 xmpp/Core/XMPPJID.m create mode 100644 xmpp/Core/XMPPLogging.h create mode 100644 xmpp/Core/XMPPMessage.h create mode 100644 xmpp/Core/XMPPMessage.m create mode 100644 xmpp/Core/XMPPModule.h create mode 100644 xmpp/Core/XMPPModule.m create mode 100644 xmpp/Core/XMPPParser.h create mode 100644 xmpp/Core/XMPPParser.m create mode 100644 xmpp/Core/XMPPPresence.h create mode 100644 xmpp/Core/XMPPPresence.m create mode 100644 xmpp/Core/XMPPStream.h create mode 100644 xmpp/Core/XMPPStream.m create mode 100644 xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.h create mode 100644 xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.m create mode 100644 xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorageProtected.h create mode 100755 xmpp/Extensions/Reconnect/XMPPReconnect.h create mode 100755 xmpp/Extensions/Reconnect/XMPPReconnect.m create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.h create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.m create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.h create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.m create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/elements create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/layout create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.h create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.m create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.h create mode 100644 xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.m create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.h create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.m create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.h create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.m create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStoragePrivate.h create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.h create mode 100644 xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.m create mode 100644 xmpp/Extensions/Roster/XMPPResource.h create mode 100644 xmpp/Extensions/Roster/XMPPRoster.h create mode 100644 xmpp/Extensions/Roster/XMPPRoster.m create mode 100644 xmpp/Extensions/Roster/XMPPRosterPrivate.h create mode 100644 xmpp/Extensions/Roster/XMPPUser.h create mode 100644 xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.h create mode 100644 xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.m create mode 100644 xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.h create mode 100644 xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.m create mode 100644 xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.h create mode 100644 xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.m create mode 100644 xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.h create mode 100644 xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.m create mode 100644 xmpp/Extensions/XEP-0045/XMPPRoom.h create mode 100644 xmpp/Extensions/XEP-0045/XMPPRoom.m create mode 100644 xmpp/Extensions/XEP-0045/XMPPRoomOccupant.h create mode 100644 xmpp/Extensions/XEP-0045/XMPPRoomOccupant.m create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/.xccurrentversion create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/elements create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/layout create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.h create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.m create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.h create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.m create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.h create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.m create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.h create mode 100644 xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTemp.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTemp.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempBase.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempBase.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempModule.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempModule.m create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempTel.h create mode 100644 xmpp/Extensions/XEP-0054/XMPPvCardTempTel.m create mode 100644 xmpp/Extensions/XEP-0060/XMPPPubSub.h create mode 100644 xmpp/Extensions/XEP-0060/XMPPPubSub.m create mode 100644 xmpp/Extensions/XEP-0065/TURNSocket.h create mode 100644 xmpp/Extensions/XEP-0065/TURNSocket.m create mode 100644 xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.h create mode 100644 xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.m create mode 100644 xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.h create mode 100644 xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.m create mode 100644 xmpp/Extensions/XEP-0100/XMPPTransports.h create mode 100644 xmpp/Extensions/XEP-0100/XMPPTransports.m create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/elements create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/layout create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.h create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.m create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.h create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.m create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.h create mode 100644 xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.m create mode 100644 xmpp/Extensions/XEP-0115/XMPPCapabilities.h create mode 100644 xmpp/Extensions/XEP-0115/XMPPCapabilities.m create mode 100644 xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.h create mode 100644 xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.m create mode 100644 xmpp/Extensions/XEP-0199/XMPPAutoPing.h create mode 100644 xmpp/Extensions/XEP-0199/XMPPAutoPing.m create mode 100644 xmpp/Extensions/XEP-0199/XMPPPing.h create mode 100644 xmpp/Extensions/XEP-0199/XMPPPing.m create mode 100644 xmpp/Extensions/XEP-0202/XMPPTime.h create mode 100644 xmpp/Extensions/XEP-0202/XMPPTime.m create mode 100644 xmpp/Extensions/XEP-0203/XMPPElement+Delay.h create mode 100644 xmpp/Extensions/XEP-0203/XMPPElement+Delay.m create mode 100644 xmpp/Utilities/DDList.h create mode 100644 xmpp/Utilities/DDList.m create mode 100644 xmpp/Utilities/GCDMulticastDelegate.h create mode 100644 xmpp/Utilities/GCDMulticastDelegate.m create mode 100644 xmpp/Utilities/LibIDN.h create mode 100644 xmpp/Utilities/LibIDN.m create mode 100644 xmpp/Utilities/RFImageToDataTransformer.h create mode 100644 xmpp/Utilities/RFImageToDataTransformer.m create mode 100644 xmpp/Utilities/XMPPSRVResolver.h create mode 100644 xmpp/Utilities/XMPPSRVResolver.m create mode 100644 xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.h create mode 100644 xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.m create mode 100755 xmpp/Vendor/CocoaLumberjack/DDASLLogger.h create mode 100755 xmpp/Vendor/CocoaLumberjack/DDASLLogger.m create mode 100644 xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.h create mode 100644 xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.m create mode 100644 xmpp/Vendor/CocoaLumberjack/DDFileLogger.h create mode 100644 xmpp/Vendor/CocoaLumberjack/DDFileLogger.m create mode 100755 xmpp/Vendor/CocoaLumberjack/DDLog.h create mode 100755 xmpp/Vendor/CocoaLumberjack/DDLog.m create mode 100755 xmpp/Vendor/CocoaLumberjack/DDTTYLogger.h create mode 100755 xmpp/Vendor/CocoaLumberjack/DDTTYLogger.m create mode 100644 xmpp/Vendor/KissXML/Categories/NSString+DDXML.h create mode 100644 xmpp/Vendor/KissXML/Categories/NSString+DDXML.m create mode 100644 xmpp/Vendor/KissXML/DDXML.h create mode 100644 xmpp/Vendor/KissXML/DDXMLDocument.h create mode 100644 xmpp/Vendor/KissXML/DDXMLDocument.m create mode 100644 xmpp/Vendor/KissXML/DDXMLElement.h create mode 100644 xmpp/Vendor/KissXML/DDXMLElement.m create mode 100644 xmpp/Vendor/KissXML/DDXMLNode.h create mode 100644 xmpp/Vendor/KissXML/DDXMLNode.m create mode 100644 xmpp/Vendor/KissXML/Private/DDXMLPrivate.h create mode 100644 xmpp/Vendor/libidn/idn-int.h create mode 100644 xmpp/Vendor/libidn/libidn-1.15.tar.gz create mode 100644 xmpp/Vendor/libidn/libidn.a create mode 100644 xmpp/Vendor/libidn/stringprep.h diff --git a/Classes/JabberClientAppDelegate.h b/Classes/JabberClientAppDelegate.h new file mode 100644 index 0000000..d96a594 --- /dev/null +++ b/Classes/JabberClientAppDelegate.h @@ -0,0 +1,47 @@ +// +// JabberClientAppDelegate.h +// JabberClient +// +// Created by cesarerocchi on 8/3/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import + +#import "XMPPRoster.h" +#import "XMPP.h" +#import "SMChatDelegate.h" +#import "SMMessageDelegate.h" + +@class SMBuddyListViewController; + +@interface JabberClientAppDelegate : NSObject { + UIWindow *window; + SMBuddyListViewController *viewController; + + XMPPStream *xmppStream; + XMPPRoster *xmppRoster; + + NSString *password; + + BOOL isOpen; + + __weak NSObject *_chatDelegate; + __weak NSObject *_messageDelegate; +} + +@property (nonatomic, retain) IBOutlet UIWindow *window; +@property (nonatomic, retain) IBOutlet SMBuddyListViewController *viewController; + + +@property (nonatomic, readonly) XMPPStream *xmppStream; +@property (nonatomic, readonly) XMPPRoster *xmppRoster; + +@property (nonatomic, assign) id _chatDelegate; +@property (nonatomic, assign) id _messageDelegate; + +- (BOOL)connect; +- (void)disconnect; + +@end + diff --git a/Classes/JabberClientAppDelegate.m b/Classes/JabberClientAppDelegate.m new file mode 100644 index 0000000..f52539d --- /dev/null +++ b/Classes/JabberClientAppDelegate.m @@ -0,0 +1,191 @@ +#import "SMBuddyListViewController.h" + + +@interface JabberClientAppDelegate() + +- (void)setupStream; + +- (void)goOnline; +- (void)goOffline; + +@end + + +@implementation JabberClientAppDelegate + +@synthesize xmppStream; +@synthesize xmppRoster; +@synthesize window; +@synthesize viewController; +@synthesize _chatDelegate; +@synthesize _messageDelegate; + + +- (void)applicationWillResignActive:(UIApplication *)application { + + [self disconnect]; + +} + +- (void)applicationDidBecomeActive:(UIApplication *)application { + + //[self setupStream]; + [self connect]; + +} + +- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { + + self.window.rootViewController = self.viewController; + [self.window makeKeyAndVisible]; + + return YES; +} + + +- (void)setupStream { + + xmppStream = [[XMPPStream alloc] init]; + [xmppStream addDelegate:self delegateQueue:dispatch_get_main_queue()]; + + +} + +- (void)goOnline { + XMPPPresence *presence = [XMPPPresence presence]; + [[self xmppStream] sendElement:presence]; +} + +- (void)goOffline { + XMPPPresence *presence = [XMPPPresence presenceWithType:@"unavailable"]; + [[self xmppStream] sendElement:presence]; +} + +- (BOOL)connect { + + [self setupStream]; + + NSString *jabberID = [[NSUserDefaults standardUserDefaults] stringForKey:@"userID"]; + NSString *myPassword = [[NSUserDefaults standardUserDefaults] stringForKey:@"userPassword"]; + + if (![xmppStream isDisconnected]) { + return YES; + } + + + if (jabberID == nil || myPassword == nil) { + + return NO; + } + + [xmppStream setMyJID:[XMPPJID jidWithString:jabberID]]; + password = myPassword; + + NSError *error = nil; + if (![xmppStream connect:&error]) + { + UIAlertView *alertView = [[UIAlertView alloc] initWithTitle:@"Error" + message:[NSString stringWithFormat:@"Can't connect to server %@", [error localizedDescription]] + delegate:nil + cancelButtonTitle:@"Ok" + otherButtonTitles:nil]; + [alertView show]; + [alertView release]; + + + return NO; + } + + return YES; +} + +- (void)disconnect { + + [self goOffline]; + [xmppStream disconnect]; + [_chatDelegate didDisconnect]; +} + + + +#pragma mark - +#pragma mark XMPP delegates + + +- (void)xmppStreamDidConnect:(XMPPStream *)sender { + + isOpen = YES; + NSError *error = nil; + [[self xmppStream] authenticateWithPassword:password error:&error]; + +} + +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender { + + [self goOnline]; + +} + + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq { + + return NO; + +} + +- (void)xmppStream:(XMPPStream *)sender didReceiveMessage:(XMPPMessage *)message { + + + NSString *msg = [[message elementForName:@"body"] stringValue]; + NSString *from = [[message attributeForName:@"from"] stringValue]; + + NSMutableDictionary *m = [[NSMutableDictionary alloc] init]; + [m setObject:msg forKey:@"msg"]; + [m setObject:from forKey:@"sender"]; + + [_messageDelegate newMessageReceived:m]; + [m release]; + +} + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence { + + NSString *presenceType = [presence type]; // online/offline + NSString *myUsername = [[sender myJID] user]; + NSString *presenceFromUser = [[presence from] user]; + + if (![presenceFromUser isEqualToString:myUsername]) { + + if ([presenceType isEqualToString:@"available"]) { + + [_chatDelegate newBuddyOnline:[NSString stringWithFormat:@"%@@%@", presenceFromUser, @"jerry.local"]]; + + } else if ([presenceType isEqualToString:@"unavailable"]) { + + [_chatDelegate buddyWentOffline:[NSString stringWithFormat:@"%@@%@", presenceFromUser, @"jerry.local"]]; + + } + + } + +} + + +- (void)dealloc { + + [xmppStream removeDelegate:self]; + [xmppRoster removeDelegate:self]; + + [xmppStream disconnect]; + [xmppStream release]; + [xmppRoster release]; + + [password release]; + + [viewController release]; + [window release]; + [super dealloc]; +} + + +@end diff --git a/Classes/SMBuddyListViewController.h b/Classes/SMBuddyListViewController.h new file mode 100644 index 0000000..a54254c --- /dev/null +++ b/Classes/SMBuddyListViewController.h @@ -0,0 +1,38 @@ +// +// jabberClientViewController.h +// jabberClient +// +// Created by cesarerocchi on 7/13/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import +#import "JabberClientAppDelegate.h" +#import "SMLoginViewController.h" +#import "SMChatViewController.h" +#import "SMChatDelegate.h" + +@interface SMBuddyListViewController : UIViewController { + + UITableView *tView; + NSMutableArray *onlineBuddies; + + UIView *addBuddyView; + UITextField *buddyField; + + +} + +@property (nonatomic,retain) IBOutlet UITableView *tView; + +@property (nonatomic,retain) IBOutlet UIView *addBuddyView; +@property (nonatomic,retain) IBOutlet UITextField *buddyField; + + + +- (IBAction) addBuddy; +- (IBAction) showLogin; + + +@end + diff --git a/Classes/SMBuddyListViewController.m b/Classes/SMBuddyListViewController.m new file mode 100644 index 0000000..4d8c01e --- /dev/null +++ b/Classes/SMBuddyListViewController.m @@ -0,0 +1,158 @@ +// +// jabberClientViewController.m +// jabberClient +// +// Created by cesarerocchi on 7/13/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import "SMBuddyListViewController.h" + +#import "XMPP.h" +#import "XMPPRoster.h" + +@implementation SMBuddyListViewController + +@synthesize tView, addBuddyView, buddyField; + + +- (JabberClientAppDelegate *)appDelegate { + return (JabberClientAppDelegate *)[[UIApplication sharedApplication] delegate]; +} + +- (XMPPStream *)xmppStream { + return [[self appDelegate] xmppStream]; +} + +- (XMPPRoster *)xmppRoster { + return [[self appDelegate] xmppRoster]; +} + + +- (void)viewDidLoad { + + [super viewDidLoad]; + self.tView.delegate = self; + self.tView.dataSource = self; + JabberClientAppDelegate *del = [self appDelegate]; + del._chatDelegate = self; + onlineBuddies = [[NSMutableArray alloc ] init]; + +} + + +- (void)viewDidAppear:(BOOL)animated { + + [super viewDidAppear:animated]; + + NSString *login = [[NSUserDefaults standardUserDefaults] objectForKey:@"userID"]; + + if (login) { + + if ([[self appDelegate] connect]) { + + NSLog(@"show buddy list"); + + } + + } else { + + [self showLogin]; + + } + +} + +- (IBAction) showLogin { + + SMLoginViewController *loginController = [[SMLoginViewController alloc] init]; + [self presentModalViewController:loginController animated:YES]; + +} + +#pragma mark - +#pragma mark Table view delegates + +- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { + + NSString *s = (NSString *) [onlineBuddies objectAtIndex:indexPath.row]; + + static NSString *CellIdentifier = @"UserCellIdentifier"; + + UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier]; + if (cell == nil) { + cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier] autorelease]; + } + + cell.textLabel.text = s; + cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator; + + return cell; + +} + +- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section { + + return [onlineBuddies count]; + +} + +- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView { + + return 1; + +} + + +- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { + + NSString *userName = (NSString *) [onlineBuddies objectAtIndex:indexPath.row]; + SMChatViewController *chatController = [[SMChatViewController alloc] initWithUser:userName]; + [self presentModalViewController:chatController animated:YES]; + +} + + +#pragma mark - +#pragma mark Chat delegate + +- (void)newBuddyOnline:(NSString *)buddyName { + + [onlineBuddies addObject:buddyName]; + [self.tView reloadData]; + +} + +- (void)buddyWentOffline:(NSString *)buddyName { + + [onlineBuddies removeObject:buddyName]; + [self.tView reloadData]; + +} + +- (void)didDisconnect { + + [onlineBuddies removeAllObjects]; + [self.tView reloadData]; + +} + +- (IBAction) addBuddy { + + // XMPPJID *newBuddy = [XMPPJID jidWithString:self.buddyField.text]; + // [self.xmppRoster addBuddy:newBuddy withNickname:@"ciao"]; + +} + + + +- (void)dealloc { + + [tView release]; + [addBuddyView dealloc]; + [buddyField dealloc]; + [super dealloc]; + +} + +@end diff --git a/Classes/SMChatDelegate.h b/Classes/SMChatDelegate.h new file mode 100644 index 0000000..e9f7818 --- /dev/null +++ b/Classes/SMChatDelegate.h @@ -0,0 +1,20 @@ +// +// SMChatDelegate.h +// jabberClient +// +// Created by cesarerocchi on 7/16/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import + + +@protocol SMChatDelegate + + +- (void)newBuddyOnline:(NSString *)buddyName; +- (void)buddyWentOffline:(NSString *)buddyName; +- (void)didDisconnect; + + +@end diff --git a/Classes/SMChatViewController.h b/Classes/SMChatViewController.h new file mode 100644 index 0000000..5a0cde4 --- /dev/null +++ b/Classes/SMChatViewController.h @@ -0,0 +1,31 @@ +// +// SMChatViewController.h +// jabberClient +// +// Created by cesarerocchi on 7/16/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import +#import "SMBuddyListViewController.h" +#import "XMPP.h" + + +@interface SMChatViewController : UIViewController { + + UITextField *messageField; + NSString *chatWithUser; + UITableView *tView; + NSMutableArray *messages; + +} + +@property (nonatomic,retain) IBOutlet UITextField *messageField; +@property (nonatomic,retain) NSString *chatWithUser; +@property (nonatomic,retain) IBOutlet UITableView *tView; + +- (id) initWithUser:(NSString *) userName; +- (IBAction) sendMessage; +- (IBAction) closeChat; + +@end diff --git a/Classes/SMChatViewController.m b/Classes/SMChatViewController.m new file mode 100644 index 0000000..227ae88 --- /dev/null +++ b/Classes/SMChatViewController.m @@ -0,0 +1,179 @@ +// +// SMChatViewController.m +// jabberClient +// +// Created by cesarerocchi on 7/16/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import "SMChatViewController.h" + +#import "XMPP.h" + + +@implementation SMChatViewController + +@synthesize messageField, chatWithUser, tView; + + +- (JabberClientAppDelegate *)appDelegate { + return (JabberClientAppDelegate *)[[UIApplication sharedApplication] delegate]; +} + +- (XMPPStream *)xmppStream { + return [[self appDelegate] xmppStream]; +} + +- (id) initWithUser:(NSString *) userName { + + if (self = [super init]) { + + chatWithUser = userName; // @ missing + + } + + return self; + +} + +- (void)viewDidLoad { + + [super viewDidLoad]; + self.tView.delegate = self; + self.tView.dataSource = self; + messages = [[NSMutableArray alloc ] init]; + + JabberClientAppDelegate *del = [self appDelegate]; + del._messageDelegate = self; + [self.messageField becomeFirstResponder]; + + +} + + + +#pragma mark - +#pragma mark Actions + +- (IBAction) closeChat { + + [self dismissModalViewControllerAnimated:YES]; +} + +- (IBAction)sendMessage { + + NSString *messageStr = self.messageField.text; + + if([messageStr length] > 0) { + + NSXMLElement *body = [NSXMLElement elementWithName:@"body"]; + [body setStringValue:messageStr]; + + NSXMLElement *message = [NSXMLElement elementWithName:@"message"]; + [message addAttributeWithName:@"type" stringValue:@"chat"]; + [message addAttributeWithName:@"to" stringValue:chatWithUser]; + [message addChild:body]; + + [self.xmppStream sendElement:message]; + + self.messageField.text = @""; + + + NSMutableDictionary *m = [[NSMutableDictionary alloc] init]; + [m setObject:messageStr forKey:@"msg"]; + [m setObject:@"you" forKey:@"sender"]; + + [messages addObject:m]; + [self.tView reloadData]; + [m release]; + + } + + NSIndexPath *topIndexPath = [NSIndexPath indexPathForRow:messages.count-1 + inSection:0]; + + [self.tView scrollToRowAtIndexPath:topIndexPath + atScrollPosition:UITableViewScrollPositionMiddle + animated:YES]; +} + + +#pragma mark - +#pragma mark Table view delegates + +- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { + + NSDictionary *s = (NSDictionary *) [messages objectAtIndex:indexPath.row]; + + static NSString *CellIdentifier = @"MessageCellIdentifier"; + + UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier]; + if (cell == nil) { + cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:CellIdentifier] autorelease]; + } + + + cell.textLabel.text = [s objectForKey:@"msg"]; + cell.detailTextLabel.text = [s objectForKey:@"sender"]; + cell.accessoryType = UITableViewCellAccessoryNone; + cell.userInteractionEnabled = NO; + + return cell; + +} + +- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section { + + return [messages count]; + +} + +- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView { + + return 1; + +} + + +#pragma mark - +#pragma mark Chat delegates + + +- (void)newMessageReceived:(NSString *)messageContent { + + [messages addObject:messageContent]; + [self.tView reloadData]; + + NSIndexPath *topIndexPath = [NSIndexPath indexPathForRow:messages.count-1 + inSection:0]; + + [self.tView scrollToRowAtIndexPath:topIndexPath + atScrollPosition:UITableViewScrollPositionMiddle + animated:YES]; +} + + +- (void)didReceiveMemoryWarning { + // Releases the view if it doesn't have a superview. + [super didReceiveMemoryWarning]; + + // Release any cached data, images, etc. that aren't in use. +} + +- (void)viewDidUnload { + [super viewDidUnload]; + // Release any retained subviews of the main view. + // e.g. self.myOutlet = nil; +} + + +- (void)dealloc { + + [messageField dealloc]; + [chatWithUser dealloc]; + [tView dealloc]; + [super dealloc]; +} + + +@end diff --git a/Classes/SMChatViewController.xib b/Classes/SMChatViewController.xib new file mode 100644 index 0000000..fc9f4be --- /dev/null +++ b/Classes/SMChatViewController.xib @@ -0,0 +1,639 @@ + + + + 1056 + 10K549 + 851 + 1038.36 + 461.00 + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + 141 + + + YES + + + + YES + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + YES + + YES + + + YES + + + + YES + + IBFilesOwner + IBCocoaTouchFramework + + + IBFirstResponder + IBCocoaTouchFramework + + + + 274 + + YES + + + 292 + {{253, 44}, {61, 31}} + + NO + IBCocoaTouchFramework + 0 + 0 + + Helvetica-Bold + 15 + 16 + + 1 + Send + + 3 + MQA + + + 1 + MC4xOTYwNzg0MzE0IDAuMzA5ODAzOTIxNiAwLjUyMTU2ODYyNzUAA + + + 3 + MC41AA + + + + + 292 + {{5, 45}, {240, 31}} + + NO + YES + IBCocoaTouchFramework + 0 + + 3 + + 3 + MAA + + 2 + + + YES + 17 + + IBCocoaTouchFramework + + + + + 266 + {320, 44} + + NO + NO + IBCocoaTouchFramework + + YES + + Close + IBCocoaTouchFramework + 1 + + + + + + + 274 + {{0, 77}, {320, 169}} + + + YES + IBCocoaTouchFramework + YES + 1 + 0 + YES + 44 + 22 + 22 + + + {320, 460} + + + 3 + MQA + + + + IBCocoaTouchFramework + + + + + YES + + + view + + + + 3 + + + + sendMessage + + + 7 + + 6 + + + + closeChat + + + + 10 + + + + messageField + + + + 11 + + + + tView + + + + 13 + + + + + YES + + 0 + + + + + + 1 + + + YES + + + + + + + + + -1 + + + File's Owner + + + -2 + + + + + 4 + + + + + 5 + + + + + 7 + + + YES + + + + + + 8 + + + + + 12 + + + + + + + YES + + YES + -1.CustomClassName + -2.CustomClassName + 1.IBEditorWindowLastContentRect + 1.IBPluginDependency + 12.IBPluginDependency + 12.IBViewBoundsToFrameTransform + 4.IBPluginDependency + 4.IBViewBoundsToFrameTransform + 5.IBPluginDependency + 5.IBViewBoundsToFrameTransform + 7.IBPluginDependency + 7.IBViewBoundsToFrameTransform + 8.IBPluginDependency + + + YES + SMChatViewController + UIResponder + {{556, 412}, {320, 480}} + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAAAAAAAAw40AAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABDfgAAwoAAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABAwAAAwoIAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABAwAAAwigAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + + YES + + + YES + + + + + YES + + + YES + + + + 13 + + + + YES + + SMChatViewController + UIViewController + + YES + + YES + closeChat + sendMessage + + + YES + id + id + + + + YES + + YES + closeChat + sendMessage + + + YES + + closeChat + id + + + sendMessage + id + + + + + YES + + YES + messageField + tView + + + YES + UITextField + UITableView + + + + YES + + YES + messageField + tView + + + YES + + messageField + UITextField + + + tView + UITableView + + + + + IBProjectSource + Classes/SMChatViewController.h + + + + + YES + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSError.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSFileManager.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueCoding.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueObserving.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyedArchiver.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSObject.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSRunLoop.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSThread.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURL.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURLConnection.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIAccessibility.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UINibLoading.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIResponder.h + + + + UIBarButtonItem + UIBarItem + + IBFrameworkSource + UIKit.framework/Headers/UIBarButtonItem.h + + + + UIBarItem + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIBarItem.h + + + + UIButton + UIControl + + IBFrameworkSource + UIKit.framework/Headers/UIButton.h + + + + UIControl + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIControl.h + + + + UIResponder + NSObject + + + + UIScrollView + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIScrollView.h + + + + UISearchBar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UISearchBar.h + + + + UISearchDisplayController + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UISearchDisplayController.h + + + + UITableView + UIScrollView + + IBFrameworkSource + UIKit.framework/Headers/UITableView.h + + + + UITextField + UIControl + + IBFrameworkSource + UIKit.framework/Headers/UITextField.h + + + + UIToolbar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIToolbar.h + + + + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIPrintFormatter.h + + + + UIView + + + + UIView + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIView.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UINavigationController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UIPopoverController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UISplitViewController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UITabBarController.h + + + + UIViewController + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIViewController.h + + + + + 0 + IBCocoaTouchFramework + + com.apple.InterfaceBuilder.CocoaTouchPlugin.iPhoneOS + + + + com.apple.InterfaceBuilder.CocoaTouchPlugin.InterfaceBuilder3 + + + YES + ../jabberClient.xcodeproj + 3 + 141 + + diff --git a/Classes/SMLoginViewController.h b/Classes/SMLoginViewController.h new file mode 100644 index 0000000..21b44cb --- /dev/null +++ b/Classes/SMLoginViewController.h @@ -0,0 +1,26 @@ +// +// SMLoginViewController.h +// jabberClient +// +// Created by cesarerocchi on 7/16/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import +#import "JabberClientAppDelegate.h" + + +@interface SMLoginViewController : UIViewController { + + UITextField *loginField; + UITextField *passwordField; + +} + +@property (nonatomic,retain) IBOutlet UITextField *loginField; +@property (nonatomic,retain) IBOutlet UITextField *passwordField; + +- (IBAction) login; +- (IBAction) hideLogin; + +@end diff --git a/Classes/SMLoginViewController.m b/Classes/SMLoginViewController.m new file mode 100644 index 0000000..4ae2154 --- /dev/null +++ b/Classes/SMLoginViewController.m @@ -0,0 +1,63 @@ +// +// SMLoginViewController.m +// jabberClient +// +// Created by cesarerocchi on 7/16/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import "SMLoginViewController.h" + + +@implementation SMLoginViewController + +@synthesize loginField, passwordField; + + +- (void) viewDidLoad { + + [super viewDidLoad]; + self.loginField.text = @"alterego@jerry.local"; + self.passwordField.text = @"ciao"; + +} + +- (IBAction) login { + + [[NSUserDefaults standardUserDefaults] setObject:self.loginField.text forKey:@"userID"]; + [[NSUserDefaults standardUserDefaults] setObject:self.passwordField.text forKey:@"userPassword"]; + [[NSUserDefaults standardUserDefaults] synchronize]; + + [self dismissModalViewControllerAnimated:YES]; + +} + +- (IBAction) hideLogin { + + [self dismissModalViewControllerAnimated:YES]; + +} + +- (void)didReceiveMemoryWarning { + // Releases the view if it doesn't have a superview. + [super didReceiveMemoryWarning]; + + // Release any cached data, images, etc. that aren't in use. +} + +- (void)viewDidUnload { + [super viewDidUnload]; + // Release any retained subviews of the main view. + // e.g. self.myOutlet = nil; +} + + +- (void)dealloc { + + [loginField dealloc]; + [passwordField dealloc]; + [super dealloc]; +} + + +@end diff --git a/Classes/SMLoginViewController.xib b/Classes/SMLoginViewController.xib new file mode 100644 index 0000000..21660cf --- /dev/null +++ b/Classes/SMLoginViewController.xib @@ -0,0 +1,632 @@ + + + + 1056 + 10K549 + 851 + 1038.36 + 461.00 + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + 141 + + + YES + + + + YES + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + YES + + YES + + + YES + + + + YES + + IBFilesOwner + IBCocoaTouchFramework + + + IBFirstResponder + IBCocoaTouchFramework + + + + 274 + + YES + + + 292 + {{228, 148}, {72, 37}} + + NO + IBCocoaTouchFramework + 0 + 0 + + Helvetica-Bold + 15 + 16 + + 1 + Login + + 3 + MQA + + + 1 + MC4xOTYwNzg0MzQ2IDAuMzA5ODAzOTMyOSAwLjUyMTU2ODY1NgA + + + 3 + MC41AA + + + + + 292 + {{20, 58}, {280, 31}} + + + NO + YES + IBCocoaTouchFramework + 0 + + 3 + + 3 + MAA + + 2 + + + YES + 17 + + IBCocoaTouchFramework + + + + + 266 + {320, 44} + + NO + NO + IBCocoaTouchFramework + + YES + + Close + IBCocoaTouchFramework + 1 + + + + + + + 292 + {{20, 103}, {280, 31}} + + + NO + YES + IBCocoaTouchFramework + 0 + + 3 + + 3 + MAA + + + YES + 17 + + YES + IBCocoaTouchFramework + + + + {320, 460} + + + 3 + MQA + + + + IBCocoaTouchFramework + + + + + YES + + + view + + + + 3 + + + + loginField + + + + 9 + + + + passwordField + + + + 10 + + + + hideLogin + + + + 11 + + + + login + + + 7 + + 12 + + + + + YES + + 0 + + + + + + 1 + + + YES + + + + + + + + + -1 + + + File's Owner + + + -2 + + + + + 4 + + + + + 5 + + + + + 6 + + + YES + + + + + + 8 + + + + + 7 + + + + + + + YES + + YES + -1.CustomClassName + -2.CustomClassName + 1.IBEditorWindowLastContentRect + 1.IBPluginDependency + 4.IBPluginDependency + 4.IBViewBoundsToFrameTransform + 5.IBPluginDependency + 5.IBViewBoundsToFrameTransform + 6.IBPluginDependency + 6.IBViewBoundsToFrameTransform + 7.IBPluginDependency + 7.IBViewBoundsToFrameTransform + 8.IBPluginDependency + + + YES + SMLoginViewController + UIResponder + {{1149, 507}, {320, 480}} + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABDZAAAwzEAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABBoAAAwtYAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAAAAAAAAw3oAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAABBoAAAwrAAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + + YES + + + YES + + + + + YES + + + YES + + + + 12 + + + + YES + + SMLoginViewController + UIViewController + + YES + + YES + hideLogin + login + + + YES + id + id + + + + YES + + YES + hideLogin + login + + + YES + + hideLogin + id + + + login + id + + + + + YES + + YES + loginField + passwordField + + + YES + UITextField + UITextField + + + + YES + + YES + loginField + passwordField + + + YES + + loginField + UITextField + + + passwordField + UITextField + + + + + IBProjectSource + Classes/SMLoginViewController.h + + + + + YES + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSError.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSFileManager.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueCoding.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueObserving.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyedArchiver.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSObject.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSRunLoop.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSThread.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURL.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURLConnection.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIAccessibility.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UINibLoading.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIResponder.h + + + + UIBarButtonItem + UIBarItem + + IBFrameworkSource + UIKit.framework/Headers/UIBarButtonItem.h + + + + UIBarItem + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIBarItem.h + + + + UIButton + UIControl + + IBFrameworkSource + UIKit.framework/Headers/UIButton.h + + + + UIControl + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIControl.h + + + + UIResponder + NSObject + + + + UISearchBar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UISearchBar.h + + + + UISearchDisplayController + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UISearchDisplayController.h + + + + UITextField + UIControl + + IBFrameworkSource + UIKit.framework/Headers/UITextField.h + + + + UIToolbar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIToolbar.h + + + + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIPrintFormatter.h + + + + UIView + + + + UIView + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIView.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UINavigationController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UIPopoverController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UISplitViewController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UITabBarController.h + + + + UIViewController + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIViewController.h + + + + + 0 + IBCocoaTouchFramework + + com.apple.InterfaceBuilder.CocoaTouchPlugin.iPhoneOS + + + + com.apple.InterfaceBuilder.CocoaTouchPlugin.InterfaceBuilder3 + + + YES + ../JabberClient.xcodeproj + 3 + 141 + + diff --git a/Classes/SMMessageDelegate.h b/Classes/SMMessageDelegate.h new file mode 100644 index 0000000..da22df2 --- /dev/null +++ b/Classes/SMMessageDelegate.h @@ -0,0 +1,16 @@ +// +// SMMessageDelegate.h +// jabberClient +// +// Created by cesarerocchi on 8/2/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import + + +@protocol SMMessageDelegate + +- (void)newMessageReceived:(NSDictionary *)messageContent; + +@end diff --git a/JabberClient-Info.plist b/JabberClient-Info.plist new file mode 100644 index 0000000..3289444 --- /dev/null +++ b/JabberClient-Info.plist @@ -0,0 +1,30 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleDisplayName + ${PRODUCT_NAME} + CFBundleExecutable + ${EXECUTABLE_NAME} + CFBundleIconFile + + CFBundleIdentifier + com.yourcompany.${PRODUCT_NAME:rfc1034identifier} + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + ${PRODUCT_NAME} + CFBundlePackageType + APPL + CFBundleSignature + ???? + CFBundleVersion + 1.0 + LSRequiresIPhoneOS + + NSMainNibFile + MainWindow + + diff --git a/JabberClient.xcodeproj/cesarerocchi.mode1v3 b/JabberClient.xcodeproj/cesarerocchi.mode1v3 new file mode 100644 index 0000000..6d0b48c --- /dev/null +++ b/JabberClient.xcodeproj/cesarerocchi.mode1v3 @@ -0,0 +1,1422 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCProjectFormatConflictsModule + Name + Project Format Conflicts List + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + BundleLoadPath + + MaxInstances + n + Module + XCSnapshotModule + Name + Snapshots Tool + + + BundlePath + /Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources + Description + DefaultDescriptionKey + DockingSystemVisible + + Extension + mode1v3 + FavBarConfig + + PBXProjectModuleGUID + BD622FD213E95B6F00F26E0B + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.mode1v3 + MajorVersion + 33 + MinorVersion + 0 + Name + Default + Notifications + + OpenEditors + + PerspectiveWidths + + -1 + -1 + + Perspectives + + + ChosenToolbarItems + + active-combo-popup + action + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + get-info + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProjectWithEditor + Identifier + perspective.project + IsVertical + + Layout + + + BecomeActive + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 336 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 29B97314FDCFA39411CA2CEA + 080E96DDFE201D6D7F000001 + 29B97317FDCFA39411CA2CEA + 1C37FBAC04509CD000000102 + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 6 + 2 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {336, 764}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {353, 782}} + GroupTreeTableConfiguration + + MainColumn + 336 + + RubberWindowFrame + 952 346 1437 823 0 0 2560 1418 + + Module + PBXSmartGroupTreeModule + Proportion + 353pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20306471E060097A5F4 + PBXProjectModuleLabel + SMBuddyListViewController.m + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CE0B20406471E060097A5F4 + PBXProjectModuleLabel + SMBuddyListViewController.m + _historyCapacity + 0 + bookmark + BD9909131402C38B0095E4EA + history + + BD62314113E9638300F26E0B + BD62314A13E9640900F26E0B + BDDB2F2E13EBEF1700B340BB + BDDB2F2F13EBEF1700B340BB + BDDB2F4613EBF19000B340BB + BDDB2F4B13EBF68400B340BB + BD1E3A8A13F40D94008DEF1E + BD9909101402C38B0095E4EA + BD9909111402C38B0095E4EA + BD9909121402C38B0095E4EA + + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {1079, 753}} + RubberWindowFrame + 952 346 1437 823 0 0 2560 1418 + + Module + PBXNavigatorGroup + Proportion + 753pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20506471E060097A5F4 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{0, 758}, {1079, 24}} + RubberWindowFrame + 952 346 1437 823 0 0 2560 1418 + + Module + XCDetailModule + Proportion + 24pt + + + Proportion + 1079pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDetailModule + + TableOfContents + + BD99090D1402C3830095E4EA + 1CE0B1FE06471DED0097A5F4 + BD99090E1402C3830095E4EA + 1CE0B20306471E060097A5F4 + 1CE0B20506471E060097A5F4 + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.defaultV3 + + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.morph + IsVertical + 0 + Layout + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 11E0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 29B97314FDCFA39411CA2CEA + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 337}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 1 + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 355}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 373 269 690 397 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 100% + + + Name + Morph + PreferredWidth + 300 + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + + TableOfContents + + 11E0B1FE06471DED0097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default.shortV3 + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec' + StatusbarIsVisible + + TimeStamp + 0.0 + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 1 + Type + Perspectives + UpdateMessage + The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature). You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature. Do you wish to update to the latest Workspace defaults for project '%@'? + WindowJustification + 5 + WindowOrderList + + BD622FD313E95B6F00F26E0B + /Users/cesarerocchi/Desktop/jabberClientTut/JabberClient/JabberClient.xcodeproj + + WindowString + 952 346 1437 823 0 0 2560 1418 + WindowToolsV3 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.build + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {876, 370}} + RubberWindowFrame + 164 751 876 652 0 0 2560 1418 + + Module + PBXNavigatorGroup + Proportion + 370pt + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + XCBuildResultsTrigger_Collapse + 1021 + XCBuildResultsTrigger_Open + 1011 + + GeometryConfiguration + + Frame + {{0, 375}, {876, 236}} + RubberWindowFrame + 164 751 876 652 0 0 2560 1418 + + Module + PBXBuildResultsModule + Proportion + 236pt + + + Proportion + 611pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + + TableOfContents + + BD622FD313E95B6F00F26E0B + BD99090F1402C3830095E4EA + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.buildV3 + WindowContentMinSize + 486 300 + WindowString + 164 751 876 652 0 0 2560 1418 + WindowToolGUID + BD622FD313E95B6F00F26E0B + WindowToolIsVisible + + + + FirstTimeWindowDisplayed + + Identifier + windowTool.debugger + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {316, 198}} + {{316, 0}, {378, 198}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 198}} + {{0, 198}, {694, 183}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 381}} + PBXDebugSessionStackFrameViewKey + + DebugVariablesTableConfiguration + + Name + 120 + Value + 85 + Summary + 148 + + Frame + {{316, 0}, {378, 198}} + RubberWindowFrame + 330 213 694 422 0 0 2560 1418 + + RubberWindowFrame + 330 213 694 422 0 0 2560 1418 + + Module + PBXDebugSessionModule + Proportion + 381pt + + + Proportion + 381pt + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + + TableOfContents + + 1CD10A99069EF8BA00B06720 + BD2F668713F2B4970004F2F8 + 1C162984064C10D400B95A72 + BD2F668813F2B4970004F2F8 + BD2F668913F2B4970004F2F8 + BD2F668A13F2B4970004F2F8 + BD2F668B13F2B4970004F2F8 + BD2F668C13F2B4970004F2F8 + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + WindowString + 330 213 694 422 0 0 2560 1418 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + MENUSEPARATOR + + + FirstTimeWindowDisplayed + + Identifier + windowTool.debuggerConsole + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {844, 399}} + RubberWindowFrame + 1864 254 844 440 0 0 2560 1418 + + Module + PBXDebugCLIModule + Proportion + 399pt + + + Proportion + 399pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + + TableOfContents + + 1C78EAAD065D492600B07095 + BD2F668D13F2B4970004F2F8 + 1C78EAAC065D492600B07095 + + ToolbarConfiguration + xcode.toolbar.config.consoleV3 + WindowString + 1864 254 844 440 0 0 2560 1418 + WindowToolGUID + 1C78EAAD065D492600B07095 + WindowToolIsVisible + + + + Identifier + windowTool.snapshots + Layout + + + Dock + + + Module + XCSnapshotModule + Proportion + 100% + + + Proportion + 100% + + + Name + Snapshots + ServiceClasses + + XCSnapshotModule + + StatusbarIsVisible + Yes + ToolbarConfiguration + xcode.toolbar.config.snapshots + WindowString + 315 824 300 550 0 0 1440 878 + WindowToolIsVisible + Yes + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.0950012207031 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scm + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 3 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpointsV3 + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + Identifier + windowTool.debugAnimator + Layout + + + Dock + + + Module + PBXNavigatorGroup + Proportion + 100% + + + Proportion + 100% + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + 1 + ToolbarConfiguration + xcode.toolbar.config.debugAnimatorV3 + WindowString + 100 100 700 500 0 0 1280 1002 + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 100% + + + Proportion + 100% + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + Identifier + windowTool.projectFormatConflicts + Layout + + + Dock + + + Module + XCProjectFormatConflictsModule + Proportion + 100% + + + Proportion + 100% + + + Name + Project Format Conflicts + ServiceClasses + + XCProjectFormatConflictsModule + + StatusbarIsVisible + 0 + WindowContentMinSize + 450 300 + WindowString + 50 850 472 307 0 0 1440 877 + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {374, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {630, 331}} + MembersFrame + {{0, 105}, {374, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 97 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + 1 + RubberWindowFrame + 385 179 630 352 0 0 1440 878 + + Module + PBXClassBrowserModule + Proportion + 332pt + + + Proportion + 332pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + 0 + TableOfContents + + 1C0AD2AF069F1E9B00FABCE6 + 1C0AD2B0069F1E9B00FABCE6 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 385 179 630 352 0 0 1440 878 + WindowToolGUID + 1C0AD2AF069F1E9B00FABCE6 + WindowToolIsVisible + 0 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.refactoring + IncludeInToolsMenu + 0 + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + BD62311513E962A200F26E0B + + GeometryConfiguration + + Frame + {{0, 0}, {500, 315}} + RubberWindowFrame + 1252 1021 500 356 0 0 1440 878 + + Module + XCRefactoringModule + Proportion + 315pt + + + Proportion + 315pt + + + Name + Refactoring + ServiceClasses + + XCRefactoringModule + + StatusbarIsVisible + + TableOfContents + + BD62311613E962A200F26E0B + BDDB2F1413EBE66100B340BB + BD62311513E962A200F26E0B + + WindowString + 1252 1021 500 356 0 0 1440 878 + WindowToolGUID + BD62311613E962A200F26E0B + WindowToolIsVisible + + + + + diff --git a/JabberClient.xcodeproj/cesarerocchi.pbxuser b/JabberClient.xcodeproj/cesarerocchi.pbxuser new file mode 100644 index 0000000..6f45c54 --- /dev/null +++ b/JabberClient.xcodeproj/cesarerocchi.pbxuser @@ -0,0 +1,313 @@ +// !$*UTF8*$! +{ + 1D3623240D0F684500981E51 /* JabberClientAppDelegate.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1018, 1029}}"; + sepNavSelRange = "{911, 103}"; + sepNavVisRange = "{0, 1060}"; + }; + }; + 1D3623250D0F684500981E51 /* JabberClientAppDelegate.m */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1425, 3456}}"; + sepNavSelRange = "{144, 0}"; + sepNavVisRange = "{0, 765}"; + }; + }; + 1D6058900D05DD3D006BFB54 /* JabberClient */ = { + activeExec = 0; + executables = ( + BD622FCC13E95B6800F26E0B /* JabberClient */, + ); + }; + 28D7ACF60DDB3853001CB0EB /* SMBuddyListViewController.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1074, 1029}}"; + sepNavSelRange = "{543, 0}"; + sepNavVisRange = "{0, 789}"; + }; + }; + 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1164, 2718}}"; + sepNavSelRange = "{1082, 0}"; + sepNavVisRange = "{0, 845}"; + }; + }; + 29B97313FDCFA39411CA2CEA /* Project object */ = { + activeBuildConfigurationName = Debug; + activeExecutable = BD622FCC13E95B6800F26E0B /* JabberClient */; + activeTarget = 1D6058900D05DD3D006BFB54 /* JabberClient */; + addToTargets = ( + 1D6058900D05DD3D006BFB54 /* JabberClient */, + ); + breakpoints = ( + ); + codeSenseManager = BD622FD613E95B6F00F26E0B /* Code sense */; + executables = ( + BD622FCC13E95B6800F26E0B /* JabberClient */, + ); + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 840, + 20, + 48, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 681, + 60, + 20, + 48, + 43, + 43, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXTargetDataSource_PrimaryAttribute, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 335725439; + PBXWorkspaceStateSaveDate = 335725439; + }; + perUserProjectItems = { + BD1E3A8A13F40D94008DEF1E /* PBXTextBookmark */ = BD1E3A8A13F40D94008DEF1E /* PBXTextBookmark */; + BD62314113E9638300F26E0B /* PBXTextBookmark */ = BD62314113E9638300F26E0B /* PBXTextBookmark */; + BD62314A13E9640900F26E0B /* PBXTextBookmark */ = BD62314A13E9640900F26E0B /* PBXTextBookmark */; + BD9909101402C38B0095E4EA /* PBXTextBookmark */ = BD9909101402C38B0095E4EA /* PBXTextBookmark */; + BD9909111402C38B0095E4EA /* PBXTextBookmark */ = BD9909111402C38B0095E4EA /* PBXTextBookmark */; + BD9909121402C38B0095E4EA /* PBXTextBookmark */ = BD9909121402C38B0095E4EA /* PBXTextBookmark */; + BD9909131402C38B0095E4EA /* PBXTextBookmark */ = BD9909131402C38B0095E4EA /* PBXTextBookmark */; + BDDB2F2E13EBEF1700B340BB /* PBXTextBookmark */ = BDDB2F2E13EBEF1700B340BB /* PBXTextBookmark */; + BDDB2F2F13EBEF1700B340BB /* PBXTextBookmark */ = BDDB2F2F13EBEF1700B340BB /* PBXTextBookmark */; + BDDB2F4613EBF19000B340BB /* PBXTextBookmark */ = BDDB2F4613EBF19000B340BB /* PBXTextBookmark */; + BDDB2F4B13EBF68400B340BB /* PBXTextBookmark */ = BDDB2F4B13EBF68400B340BB /* PBXTextBookmark */; + }; + sourceControlManager = BD622FD513E95B6F00F26E0B /* Source Control */; + userBuildSettings = { + }; + }; + BD1E3A8A13F40D94008DEF1E /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62316C13E964BA00F26E0B /* SMChatViewController.h */; + name = "SMChatViewController.h: 14"; + rLen = 114; + rLoc = 235; + rType = 0; + vrLen = 738; + vrLoc = 0; + }; + BD622FCC13E95B6800F26E0B /* JabberClient */ = { + isa = PBXExecutable; + activeArgIndices = ( + ); + argumentStrings = ( + ); + autoAttachOnCrash = 1; + breakpointsEnabled = 1; + configStateDict = { + }; + customDataFormattersEnabled = 1; + dataTipCustomDataFormattersEnabled = 1; + dataTipShowTypeColumn = 1; + dataTipSortType = 0; + debuggerPlugin = GDBDebugging; + disassemblyDisplayState = 0; + dylibVariantSuffix = ""; + enableDebugStr = 1; + environmentEntries = ( + ); + executableSystemSymbolLevel = 0; + executableUserSymbolLevel = 0; + libgmallocEnabled = 0; + name = JabberClient; + savedGlobals = { + }; + showTypeColumn = 0; + sourceDirectories = ( + ); + variableFormatDictionary = { + }; + }; + BD622FD513E95B6F00F26E0B /* Source Control */ = { + isa = PBXSourceControlManager; + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + scmConfiguration = { + repositoryNamesForRoots = { + "" = ""; + }; + }; + }; + BD622FD613E95B6F00F26E0B /* Code sense */ = { + isa = PBXCodeSenseManager; + indexTemplatePath = ""; + }; + BD62310813E9626F00F26E0B /* SMLoginViewController.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {749, 883}}"; + sepNavSelRange = "{462, 0}"; + sepNavVisRange = "{0, 513}"; + }; + }; + BD62310913E9626F00F26E0B /* SMLoginViewController.m */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {921, 1116}}"; + sepNavSelRange = "{250, 0}"; + sepNavVisRange = "{0, 1122}"; + }; + }; + BD62310F13E9628700F26E0B /* SMChatDelegate.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1018, 1029}}"; + sepNavSelRange = "{174, 150}"; + sepNavVisRange = "{0, 325}"; + }; + }; + BD62311013E9629700F26E0B /* SMMessageDelegate.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1018, 1029}}"; + sepNavSelRange = "{213, 0}"; + sepNavVisRange = "{0, 270}"; + }; + }; + BD62314113E9638300F26E0B /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62310813E9626F00F26E0B /* SMLoginViewController.h */; + name = "SMLoginViewController.h: 22"; + rLen = 0; + rLoc = 462; + rType = 0; + vrLen = 513; + vrLoc = 0; + }; + BD62314A13E9640900F26E0B /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62310913E9626F00F26E0B /* SMLoginViewController.m */; + name = "SMLoginViewController.m: 14"; + rLen = 0; + rLoc = 250; + rType = 0; + vrLen = 1122; + vrLoc = 0; + }; + BD62316C13E964BA00F26E0B /* SMChatViewController.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1056, 722}}"; + sepNavSelRange = "{235, 114}"; + sepNavVisRange = "{0, 738}"; + }; + }; + BD62316D13E964BA00F26E0B /* SMChatViewController.m */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1018, 3330}}"; + sepNavSelRange = "{1164, 402}"; + sepNavVisRange = "{0, 685}"; + }; + }; + BD9909101402C38B0095E4EA /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62316D13E964BA00F26E0B /* SMChatViewController.m */; + name = "SMChatViewController.m: 69"; + rLen = 402; + rLoc = 1164; + rType = 0; + vrLen = 685; + vrLoc = 0; + }; + BD9909111402C38B0095E4EA /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 1D3623250D0F684500981E51 /* JabberClientAppDelegate.m */; + name = "JabberClientAppDelegate.m: 13"; + rLen = 0; + rLoc = 144; + rType = 0; + vrLen = 765; + vrLoc = 0; + }; + BD9909121402C38B0095E4EA /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */; + name = "SMBuddyListViewController.m: 54"; + rLen = 0; + rLoc = 1082; + rType = 0; + vrLen = 726; + vrLoc = 653; + }; + BD9909131402C38B0095E4EA /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */; + name = "SMBuddyListViewController.m: 54"; + rLen = 0; + rLoc = 1082; + rType = 0; + vrLen = 845; + vrLoc = 0; + }; + BDDB2F2E13EBEF1700B340BB /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62311013E9629700F26E0B /* SMMessageDelegate.h */; + name = "SMMessageDelegate.h: 14"; + rLen = 0; + rLoc = 213; + rType = 0; + vrLen = 270; + vrLoc = 0; + }; + BDDB2F2F13EBEF1700B340BB /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = BD62310F13E9628700F26E0B /* SMChatDelegate.h */; + name = "SMChatDelegate.h: 12"; + rLen = 150; + rLoc = 174; + rType = 0; + vrLen = 325; + vrLoc = 0; + }; + BDDB2F4613EBF19000B340BB /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 1D3623240D0F684500981E51 /* JabberClientAppDelegate.h */; + name = "JabberClientAppDelegate.h: 40"; + rLen = 103; + rLoc = 911; + rType = 0; + vrLen = 1060; + vrLoc = 0; + }; + BDDB2F4B13EBF68400B340BB /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 28D7ACF60DDB3853001CB0EB /* SMBuddyListViewController.h */; + name = "SMBuddyListViewController.h: 22"; + rLen = 0; + rLoc = 543; + rType = 0; + vrLen = 789; + vrLoc = 0; + }; +} diff --git a/JabberClient.xcodeproj/project.pbxproj b/JabberClient.xcodeproj/project.pbxproj new file mode 100755 index 0000000..a0b440c --- /dev/null +++ b/JabberClient.xcodeproj/project.pbxproj @@ -0,0 +1,1033 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 46; + objects = { + +/* Begin PBXBuildFile section */ + 1D3623260D0F684500981E51 /* JabberClientAppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = 1D3623250D0F684500981E51 /* JabberClientAppDelegate.m */; }; + 1D60589B0D05DD56006BFB54 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = 29B97316FDCFA39411CA2CEA /* main.m */; }; + 1D60589F0D05DD5A006BFB54 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1D30AB110D05D00D00671497 /* Foundation.framework */; }; + 1DF5F4E00D08C38300B7A737 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1DF5F4DF0D08C38300B7A737 /* UIKit.framework */; }; + 288765A50DF7441C002DB57D /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 288765A40DF7441C002DB57D /* CoreGraphics.framework */; }; + 2899E5220DE3E06400AC0155 /* JabberClientViewController.xib in Resources */ = {isa = PBXBuildFile; fileRef = 2899E5210DE3E06400AC0155 /* JabberClientViewController.xib */; }; + 28AD733F0D9D9553002E5188 /* MainWindow.xib in Resources */ = {isa = PBXBuildFile; fileRef = 28AD733E0D9D9553002E5188 /* MainWindow.xib */; }; + 28D7ACF80DDB3853001CB0EB /* SMBuddyListViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */; }; + BD62309013E95B7E00F26E0B /* NSData+XMPP.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FDA13E95B7E00F26E0B /* NSData+XMPP.m */; }; + BD62309113E95B7E00F26E0B /* NSNumber+XMPP.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FDC13E95B7E00F26E0B /* NSNumber+XMPP.m */; }; + BD62309213E95B7E00F26E0B /* NSXMLElement+XMPP.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FDE13E95B7E00F26E0B /* NSXMLElement+XMPP.m */; }; + BD62309313E95B7E00F26E0B /* XMPPElement.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FE213E95B7E00F26E0B /* XMPPElement.m */; }; + BD62309413E95B7E00F26E0B /* XMPPIQ.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FE513E95B7E00F26E0B /* XMPPIQ.m */; }; + BD62309513E95B7E00F26E0B /* XMPPJID.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FE713E95B7E00F26E0B /* XMPPJID.m */; }; + BD62309613E95B7E00F26E0B /* XMPPMessage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FEA13E95B7E00F26E0B /* XMPPMessage.m */; }; + BD62309713E95B7E00F26E0B /* XMPPModule.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FEC13E95B7E00F26E0B /* XMPPModule.m */; }; + BD62309813E95B7E00F26E0B /* XMPPParser.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FEE13E95B7E00F26E0B /* XMPPParser.m */; }; + BD62309913E95B7E00F26E0B /* XMPPPresence.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FF013E95B7E00F26E0B /* XMPPPresence.m */; }; + BD62309A13E95B7E00F26E0B /* XMPPStream.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FF213E95B7E00F26E0B /* XMPPStream.m */; }; + BD62309B13E95B7E00F26E0B /* XMPPCoreDataStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FF613E95B7E00F26E0B /* XMPPCoreDataStorage.m */; }; + BD62309C13E95B7E00F26E0B /* XMPPReconnect.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FFA13E95B7E00F26E0B /* XMPPReconnect.m */; }; + BD62309D13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD622FFE13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.m */; }; + BD62309E13E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300013E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.m */; }; + BD62309F13E95B7E00F26E0B /* XMPPRoster.xcdatamodel in Sources */ = {isa = PBXBuildFile; fileRef = BD62300113E95B7E00F26E0B /* XMPPRoster.xcdatamodel */; }; + BD6230A013E95B7E00F26E0B /* XMPPRosterCoreDataStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300313E95B7E00F26E0B /* XMPPRosterCoreDataStorage.m */; }; + BD6230A113E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300513E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.m */; }; + BD6230A213E95B7E00F26E0B /* XMPPResourceMemoryStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300813E95B7E00F26E0B /* XMPPResourceMemoryStorage.m */; }; + BD6230A313E95B7E00F26E0B /* XMPPRosterMemoryStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300A13E95B7E00F26E0B /* XMPPRosterMemoryStorage.m */; }; + BD6230A413E95B7E00F26E0B /* XMPPUserMemoryStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62300D13E95B7E00F26E0B /* XMPPUserMemoryStorage.m */; }; + BD6230A513E95B7E00F26E0B /* XMPPRoster.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301013E95B7E00F26E0B /* XMPPRoster.m */; }; + BD6230A613E95B7E00F26E0B /* XMPPIQ+JabberRPC.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301513E95B7E00F26E0B /* XMPPIQ+JabberRPC.m */; }; + BD6230A713E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301713E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.m */; }; + BD6230A813E95B7E00F26E0B /* XMPPJabberRPCModule.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301913E95B7E00F26E0B /* XMPPJabberRPCModule.m */; }; + BD6230A913E95B7E00F26E0B /* XMPPMessage+XEP0045.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301C13E95B7E00F26E0B /* XMPPMessage+XEP0045.m */; }; + BD6230AA13E95B7E00F26E0B /* XMPPRoom.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62301E13E95B7E00F26E0B /* XMPPRoom.m */; }; + BD6230AB13E95B7E00F26E0B /* XMPPRoomOccupant.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302013E95B7E00F26E0B /* XMPPRoomOccupant.m */; }; + BD6230AC13E95B7E00F26E0B /* XMPPvCard.xcdatamodeld in Sources */ = {isa = PBXBuildFile; fileRef = BD62302313E95B7E00F26E0B /* XMPPvCard.xcdatamodeld */; }; + BD6230AD13E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302613E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.m */; }; + BD6230AE13E95B7E00F26E0B /* XMPPvCardCoreDataStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302813E95B7E00F26E0B /* XMPPvCardCoreDataStorage.m */; }; + BD6230AF13E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302A13E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.m */; }; + BD6230B013E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302C13E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.m */; }; + BD6230B113E95B7E00F26E0B /* XMPPvCardTemp.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62302E13E95B7E00F26E0B /* XMPPvCardTemp.m */; }; + BD6230B213E95B7E00F26E0B /* XMPPvCardTempAdr.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303013E95B7E00F26E0B /* XMPPvCardTempAdr.m */; }; + BD6230B313E95B7E00F26E0B /* XMPPvCardTempAdrTypes.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303213E95B7E00F26E0B /* XMPPvCardTempAdrTypes.m */; }; + BD6230B413E95B7E00F26E0B /* XMPPvCardTempBase.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303413E95B7E00F26E0B /* XMPPvCardTempBase.m */; }; + BD6230B513E95B7E00F26E0B /* XMPPvCardTempEmail.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303613E95B7E00F26E0B /* XMPPvCardTempEmail.m */; }; + BD6230B613E95B7E00F26E0B /* XMPPvCardTempLabel.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303813E95B7E00F26E0B /* XMPPvCardTempLabel.m */; }; + BD6230B713E95B7E00F26E0B /* XMPPvCardTempModule.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303A13E95B7E00F26E0B /* XMPPvCardTempModule.m */; }; + BD6230B813E95B7E00F26E0B /* XMPPvCardTempTel.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303C13E95B7E00F26E0B /* XMPPvCardTempTel.m */; }; + BD6230B913E95B7E00F26E0B /* XMPPPubSub.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62303F13E95B7E00F26E0B /* XMPPPubSub.m */; }; + BD6230BA13E95B7E00F26E0B /* TURNSocket.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62304213E95B7E00F26E0B /* TURNSocket.m */; }; + BD6230BB13E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62304513E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.m */; }; + BD6230BC13E95B7E00F26E0B /* XMPPDateTimeProfiles.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62304713E95B7E00F26E0B /* XMPPDateTimeProfiles.m */; }; + BD6230BD13E95B7E00F26E0B /* XMPPTransports.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62304A13E95B7E00F26E0B /* XMPPTransports.m */; }; + BD6230BE13E95B7E00F26E0B /* XMPPCapabilities.xcdatamodel in Sources */ = {isa = PBXBuildFile; fileRef = BD62304D13E95B7E00F26E0B /* XMPPCapabilities.xcdatamodel */; }; + BD6230BF13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62304F13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.m */; }; + BD6230C013E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305113E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.m */; }; + BD6230C113E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305313E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.m */; }; + BD6230C213E95B7E00F26E0B /* XMPPCapabilities.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305513E95B7E00F26E0B /* XMPPCapabilities.m */; }; + BD6230C313E95B7E00F26E0B /* XMPPvCardAvatarModule.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305813E95B7E00F26E0B /* XMPPvCardAvatarModule.m */; }; + BD6230C413E95B7E00F26E0B /* XMPPAutoPing.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305B13E95B7E00F26E0B /* XMPPAutoPing.m */; }; + BD6230C513E95B7E00F26E0B /* XMPPPing.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62305D13E95B7E00F26E0B /* XMPPPing.m */; }; + BD6230C613E95B7E00F26E0B /* XMPPTime.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306013E95B7E00F26E0B /* XMPPTime.m */; }; + BD6230C713E95B7E00F26E0B /* XMPPElement+Delay.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306313E95B7E00F26E0B /* XMPPElement+Delay.m */; }; + BD6230C813E95B7E00F26E0B /* DDList.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306613E95B7E00F26E0B /* DDList.m */; }; + BD6230C913E95B7E00F26E0B /* GCDMulticastDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306813E95B7E00F26E0B /* GCDMulticastDelegate.m */; }; + BD6230CA13E95B7E00F26E0B /* LibIDN.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306A13E95B7E00F26E0B /* LibIDN.m */; }; + BD6230CB13E95B7E00F26E0B /* RFImageToDataTransformer.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306C13E95B7E00F26E0B /* RFImageToDataTransformer.m */; }; + BD6230CC13E95B7E00F26E0B /* XMPPSRVResolver.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62306E13E95B7E00F26E0B /* XMPPSRVResolver.m */; }; + BD6230CD13E95B7E00F26E0B /* GCDAsyncSocket.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307213E95B7E00F26E0B /* GCDAsyncSocket.m */; }; + BD6230CE13E95B7E00F26E0B /* DDAbstractDatabaseLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307513E95B7E00F26E0B /* DDAbstractDatabaseLogger.m */; }; + BD6230CF13E95B7E00F26E0B /* DDASLLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307713E95B7E00F26E0B /* DDASLLogger.m */; }; + BD6230D013E95B7E00F26E0B /* DDFileLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307913E95B7E00F26E0B /* DDFileLogger.m */; }; + BD6230D113E95B7E00F26E0B /* DDLog.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307B13E95B7E00F26E0B /* DDLog.m */; }; + BD6230D213E95B7E00F26E0B /* DDTTYLogger.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62307D13E95B7E00F26E0B /* DDTTYLogger.m */; }; + BD6230D313E95B7E00F26E0B /* NSString+DDXML.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62308113E95B7E00F26E0B /* NSString+DDXML.m */; }; + BD6230D413E95B7E00F26E0B /* DDXMLDocument.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62308413E95B7E00F26E0B /* DDXMLDocument.m */; }; + BD6230D513E95B7E00F26E0B /* DDXMLElement.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62308613E95B7E00F26E0B /* DDXMLElement.m */; }; + BD6230D613E95B7E00F26E0B /* DDXMLNode.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62308813E95B7E00F26E0B /* DDXMLNode.m */; }; + BD6230D713E95B7E00F26E0B /* libidn-1.15.tar.gz in Resources */ = {isa = PBXBuildFile; fileRef = BD62308D13E95B7E00F26E0B /* libidn-1.15.tar.gz */; }; + BD6230D813E95B7E00F26E0B /* libidn.a in Frameworks */ = {isa = PBXBuildFile; fileRef = BD62308E13E95B7E00F26E0B /* libidn.a */; }; + BD6230DF13E95BE600F26E0B /* libxml2.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230DE13E95BE600F26E0B /* libxml2.dylib */; }; + BD6230E113E95BF300F26E0B /* CFNetwork.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230E013E95BF300F26E0B /* CFNetwork.framework */; }; + BD6230E313E95C0100F26E0B /* libresolv.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230E213E95C0100F26E0B /* libresolv.dylib */; }; + BD6230E513E95C0900F26E0B /* CoreData.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230E413E95C0900F26E0B /* CoreData.framework */; }; + BD6230E713E95C0F00F26E0B /* CoreLocation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230E613E95C0F00F26E0B /* CoreLocation.framework */; }; + BD6230E913E95C1700F26E0B /* SystemConfiguration.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BD6230E813E95C1700F26E0B /* SystemConfiguration.framework */; }; + BD62310B13E9626F00F26E0B /* SMLoginViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62310913E9626F00F26E0B /* SMLoginViewController.m */; }; + BD62310C13E9626F00F26E0B /* SMLoginViewController.xib in Resources */ = {isa = PBXBuildFile; fileRef = BD62310A13E9626F00F26E0B /* SMLoginViewController.xib */; }; + BD62316E13E964BA00F26E0B /* SMChatViewController.xib in Resources */ = {isa = PBXBuildFile; fileRef = BD62316B13E964BA00F26E0B /* SMChatViewController.xib */; }; + BD62316F13E964BA00F26E0B /* SMChatViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = BD62316D13E964BA00F26E0B /* SMChatViewController.m */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 1D30AB110D05D00D00671497 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; + 1D3623240D0F684500981E51 /* JabberClientAppDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JabberClientAppDelegate.h; sourceTree = ""; }; + 1D3623250D0F684500981E51 /* JabberClientAppDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = JabberClientAppDelegate.m; sourceTree = ""; }; + 1D6058910D05DD3D006BFB54 /* JabberClient.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = JabberClient.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 1DF5F4DF0D08C38300B7A737 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; }; + 288765A40DF7441C002DB57D /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; }; + 2899E5210DE3E06400AC0155 /* JabberClientViewController.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = JabberClientViewController.xib; path = ../JabberClientViewController.xib; sourceTree = ""; }; + 28AD733E0D9D9553002E5188 /* MainWindow.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = MainWindow.xib; sourceTree = ""; }; + 28D7ACF60DDB3853001CB0EB /* SMBuddyListViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SMBuddyListViewController.h; sourceTree = ""; }; + 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SMBuddyListViewController.m; sourceTree = ""; }; + 29B97316FDCFA39411CA2CEA /* main.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; + 32CA4F630368D1EE00C91783 /* JabberClient_Prefix.pch */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JabberClient_Prefix.pch; sourceTree = ""; }; + 8D1107310486CEB800E47090 /* JabberClient-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "JabberClient-Info.plist"; plistStructureDefinitionIdentifier = "com.apple.xcode.plist.structure-definition.iphone.info-plist"; sourceTree = ""; }; + BD622FD913E95B7E00F26E0B /* NSData+XMPP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSData+XMPP.h"; sourceTree = ""; }; + BD622FDA13E95B7E00F26E0B /* NSData+XMPP.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSData+XMPP.m"; sourceTree = ""; }; + BD622FDB13E95B7E00F26E0B /* NSNumber+XMPP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSNumber+XMPP.h"; sourceTree = ""; }; + BD622FDC13E95B7E00F26E0B /* NSNumber+XMPP.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSNumber+XMPP.m"; sourceTree = ""; }; + BD622FDD13E95B7E00F26E0B /* NSXMLElement+XMPP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSXMLElement+XMPP.h"; sourceTree = ""; }; + BD622FDE13E95B7E00F26E0B /* NSXMLElement+XMPP.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSXMLElement+XMPP.m"; sourceTree = ""; }; + BD622FE013E95B7E00F26E0B /* XMPP.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPP.h; sourceTree = ""; }; + BD622FE113E95B7E00F26E0B /* XMPPElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPElement.h; sourceTree = ""; }; + BD622FE213E95B7E00F26E0B /* XMPPElement.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPElement.m; sourceTree = ""; }; + BD622FE313E95B7E00F26E0B /* XMPPInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPInternal.h; sourceTree = ""; }; + BD622FE413E95B7E00F26E0B /* XMPPIQ.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPIQ.h; sourceTree = ""; }; + BD622FE513E95B7E00F26E0B /* XMPPIQ.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPIQ.m; sourceTree = ""; }; + BD622FE613E95B7E00F26E0B /* XMPPJID.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPJID.h; sourceTree = ""; }; + BD622FE713E95B7E00F26E0B /* XMPPJID.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPJID.m; sourceTree = ""; }; + BD622FE813E95B7E00F26E0B /* XMPPLogging.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPLogging.h; sourceTree = ""; }; + BD622FE913E95B7E00F26E0B /* XMPPMessage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPMessage.h; sourceTree = ""; }; + BD622FEA13E95B7E00F26E0B /* XMPPMessage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPMessage.m; sourceTree = ""; }; + BD622FEB13E95B7E00F26E0B /* XMPPModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPModule.h; sourceTree = ""; }; + BD622FEC13E95B7E00F26E0B /* XMPPModule.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPModule.m; sourceTree = ""; }; + BD622FED13E95B7E00F26E0B /* XMPPParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPParser.h; sourceTree = ""; }; + BD622FEE13E95B7E00F26E0B /* XMPPParser.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPParser.m; sourceTree = ""; }; + BD622FEF13E95B7E00F26E0B /* XMPPPresence.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPPresence.h; sourceTree = ""; }; + BD622FF013E95B7E00F26E0B /* XMPPPresence.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPPresence.m; sourceTree = ""; }; + BD622FF113E95B7E00F26E0B /* XMPPStream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPStream.h; sourceTree = ""; }; + BD622FF213E95B7E00F26E0B /* XMPPStream.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPStream.m; sourceTree = ""; }; + BD622FF513E95B7E00F26E0B /* XMPPCoreDataStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCoreDataStorage.h; sourceTree = ""; }; + BD622FF613E95B7E00F26E0B /* XMPPCoreDataStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPCoreDataStorage.m; sourceTree = ""; }; + BD622FF713E95B7E00F26E0B /* XMPPCoreDataStorageProtected.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCoreDataStorageProtected.h; sourceTree = ""; }; + BD622FF913E95B7E00F26E0B /* XMPPReconnect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPReconnect.h; sourceTree = ""; }; + BD622FFA13E95B7E00F26E0B /* XMPPReconnect.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPReconnect.m; sourceTree = ""; }; + BD622FFD13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPGroupCoreDataStorageObject.h; sourceTree = ""; }; + BD622FFE13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPGroupCoreDataStorageObject.m; sourceTree = ""; }; + BD622FFF13E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPResourceCoreDataStorageObject.h; sourceTree = ""; }; + BD62300013E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPResourceCoreDataStorageObject.m; sourceTree = ""; }; + BD62300113E95B7E00F26E0B /* XMPPRoster.xcdatamodel */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = wrapper.xcdatamodel; path = XMPPRoster.xcdatamodel; sourceTree = ""; }; + BD62300213E95B7E00F26E0B /* XMPPRosterCoreDataStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRosterCoreDataStorage.h; sourceTree = ""; }; + BD62300313E95B7E00F26E0B /* XMPPRosterCoreDataStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPRosterCoreDataStorage.m; sourceTree = ""; }; + BD62300413E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPUserCoreDataStorageObject.h; sourceTree = ""; }; + BD62300513E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPUserCoreDataStorageObject.m; sourceTree = ""; }; + BD62300713E95B7E00F26E0B /* XMPPResourceMemoryStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPResourceMemoryStorage.h; sourceTree = ""; }; + BD62300813E95B7E00F26E0B /* XMPPResourceMemoryStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPResourceMemoryStorage.m; sourceTree = ""; }; + BD62300913E95B7E00F26E0B /* XMPPRosterMemoryStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRosterMemoryStorage.h; sourceTree = ""; }; + BD62300A13E95B7E00F26E0B /* XMPPRosterMemoryStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPRosterMemoryStorage.m; sourceTree = ""; }; + BD62300B13E95B7E00F26E0B /* XMPPRosterMemoryStoragePrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRosterMemoryStoragePrivate.h; sourceTree = ""; }; + BD62300C13E95B7E00F26E0B /* XMPPUserMemoryStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPUserMemoryStorage.h; sourceTree = ""; }; + BD62300D13E95B7E00F26E0B /* XMPPUserMemoryStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPUserMemoryStorage.m; sourceTree = ""; }; + BD62300E13E95B7E00F26E0B /* XMPPResource.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPResource.h; sourceTree = ""; }; + BD62300F13E95B7E00F26E0B /* XMPPRoster.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRoster.h; sourceTree = ""; }; + BD62301013E95B7E00F26E0B /* XMPPRoster.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPRoster.m; sourceTree = ""; }; + BD62301113E95B7E00F26E0B /* XMPPRosterPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRosterPrivate.h; sourceTree = ""; }; + BD62301213E95B7E00F26E0B /* XMPPUser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPUser.h; sourceTree = ""; }; + BD62301413E95B7E00F26E0B /* XMPPIQ+JabberRPC.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "XMPPIQ+JabberRPC.h"; sourceTree = ""; }; + BD62301513E95B7E00F26E0B /* XMPPIQ+JabberRPC.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "XMPPIQ+JabberRPC.m"; sourceTree = ""; }; + BD62301613E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "XMPPIQ+JabberRPCResonse.h"; sourceTree = ""; }; + BD62301713E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "XMPPIQ+JabberRPCResonse.m"; sourceTree = ""; }; + BD62301813E95B7E00F26E0B /* XMPPJabberRPCModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPJabberRPCModule.h; sourceTree = ""; }; + BD62301913E95B7E00F26E0B /* XMPPJabberRPCModule.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPJabberRPCModule.m; sourceTree = ""; }; + BD62301B13E95B7E00F26E0B /* XMPPMessage+XEP0045.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "XMPPMessage+XEP0045.h"; sourceTree = ""; }; + BD62301C13E95B7E00F26E0B /* XMPPMessage+XEP0045.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "XMPPMessage+XEP0045.m"; sourceTree = ""; }; + BD62301D13E95B7E00F26E0B /* XMPPRoom.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRoom.h; sourceTree = ""; }; + BD62301E13E95B7E00F26E0B /* XMPPRoom.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPRoom.m; sourceTree = ""; }; + BD62301F13E95B7E00F26E0B /* XMPPRoomOccupant.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPRoomOccupant.h; sourceTree = ""; }; + BD62302013E95B7E00F26E0B /* XMPPRoomOccupant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPRoomOccupant.m; sourceTree = ""; }; + BD62302413E95B7E00F26E0B /* XMPPvCard.xcdatamodel */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = wrapper.xcdatamodel; path = XMPPvCard.xcdatamodel; sourceTree = ""; }; + BD62302513E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardAvatarCoreDataStorageObject.h; sourceTree = ""; }; + BD62302613E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardAvatarCoreDataStorageObject.m; sourceTree = ""; }; + BD62302713E95B7E00F26E0B /* XMPPvCardCoreDataStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardCoreDataStorage.h; sourceTree = ""; }; + BD62302813E95B7E00F26E0B /* XMPPvCardCoreDataStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardCoreDataStorage.m; sourceTree = ""; }; + BD62302913E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardCoreDataStorageObject.h; sourceTree = ""; }; + BD62302A13E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardCoreDataStorageObject.m; sourceTree = ""; }; + BD62302B13E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempCoreDataStorageObject.h; sourceTree = ""; }; + BD62302C13E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempCoreDataStorageObject.m; sourceTree = ""; }; + BD62302D13E95B7E00F26E0B /* XMPPvCardTemp.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTemp.h; sourceTree = ""; }; + BD62302E13E95B7E00F26E0B /* XMPPvCardTemp.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTemp.m; sourceTree = ""; }; + BD62302F13E95B7E00F26E0B /* XMPPvCardTempAdr.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempAdr.h; sourceTree = ""; }; + BD62303013E95B7E00F26E0B /* XMPPvCardTempAdr.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempAdr.m; sourceTree = ""; }; + BD62303113E95B7E00F26E0B /* XMPPvCardTempAdrTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempAdrTypes.h; sourceTree = ""; }; + BD62303213E95B7E00F26E0B /* XMPPvCardTempAdrTypes.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempAdrTypes.m; sourceTree = ""; }; + BD62303313E95B7E00F26E0B /* XMPPvCardTempBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempBase.h; sourceTree = ""; }; + BD62303413E95B7E00F26E0B /* XMPPvCardTempBase.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempBase.m; sourceTree = ""; }; + BD62303513E95B7E00F26E0B /* XMPPvCardTempEmail.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempEmail.h; sourceTree = ""; }; + BD62303613E95B7E00F26E0B /* XMPPvCardTempEmail.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempEmail.m; sourceTree = ""; }; + BD62303713E95B7E00F26E0B /* XMPPvCardTempLabel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempLabel.h; sourceTree = ""; }; + BD62303813E95B7E00F26E0B /* XMPPvCardTempLabel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempLabel.m; sourceTree = ""; }; + BD62303913E95B7E00F26E0B /* XMPPvCardTempModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempModule.h; sourceTree = ""; }; + BD62303A13E95B7E00F26E0B /* XMPPvCardTempModule.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempModule.m; sourceTree = ""; }; + BD62303B13E95B7E00F26E0B /* XMPPvCardTempTel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardTempTel.h; sourceTree = ""; }; + BD62303C13E95B7E00F26E0B /* XMPPvCardTempTel.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardTempTel.m; sourceTree = ""; }; + BD62303E13E95B7E00F26E0B /* XMPPPubSub.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPPubSub.h; sourceTree = ""; }; + BD62303F13E95B7E00F26E0B /* XMPPPubSub.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPPubSub.m; sourceTree = ""; }; + BD62304113E95B7E00F26E0B /* TURNSocket.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TURNSocket.h; sourceTree = ""; }; + BD62304213E95B7E00F26E0B /* TURNSocket.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = TURNSocket.m; sourceTree = ""; }; + BD62304413E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSDate+XMPPDateTimeProfiles.h"; sourceTree = ""; }; + BD62304513E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSDate+XMPPDateTimeProfiles.m"; sourceTree = ""; }; + BD62304613E95B7E00F26E0B /* XMPPDateTimeProfiles.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPDateTimeProfiles.h; sourceTree = ""; }; + BD62304713E95B7E00F26E0B /* XMPPDateTimeProfiles.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPDateTimeProfiles.m; sourceTree = ""; }; + BD62304913E95B7E00F26E0B /* XMPPTransports.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPTransports.h; sourceTree = ""; }; + BD62304A13E95B7E00F26E0B /* XMPPTransports.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPTransports.m; sourceTree = ""; }; + BD62304D13E95B7E00F26E0B /* XMPPCapabilities.xcdatamodel */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = wrapper.xcdatamodel; path = XMPPCapabilities.xcdatamodel; sourceTree = ""; }; + BD62304E13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCapabilitiesCoreDataStorage.h; sourceTree = ""; }; + BD62304F13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPCapabilitiesCoreDataStorage.m; sourceTree = ""; }; + BD62305013E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCapsCoreDataStorageObject.h; sourceTree = ""; }; + BD62305113E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPCapsCoreDataStorageObject.m; sourceTree = ""; }; + BD62305213E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCapsResourceCoreDataStorageObject.h; sourceTree = ""; }; + BD62305313E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPCapsResourceCoreDataStorageObject.m; sourceTree = ""; }; + BD62305413E95B7E00F26E0B /* XMPPCapabilities.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPCapabilities.h; sourceTree = ""; }; + BD62305513E95B7E00F26E0B /* XMPPCapabilities.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPCapabilities.m; sourceTree = ""; }; + BD62305713E95B7E00F26E0B /* XMPPvCardAvatarModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPvCardAvatarModule.h; sourceTree = ""; }; + BD62305813E95B7E00F26E0B /* XMPPvCardAvatarModule.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPvCardAvatarModule.m; sourceTree = ""; }; + BD62305A13E95B7E00F26E0B /* XMPPAutoPing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPAutoPing.h; sourceTree = ""; }; + BD62305B13E95B7E00F26E0B /* XMPPAutoPing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPAutoPing.m; sourceTree = ""; }; + BD62305C13E95B7E00F26E0B /* XMPPPing.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPPing.h; sourceTree = ""; }; + BD62305D13E95B7E00F26E0B /* XMPPPing.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPPing.m; sourceTree = ""; }; + BD62305F13E95B7E00F26E0B /* XMPPTime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPTime.h; sourceTree = ""; }; + BD62306013E95B7E00F26E0B /* XMPPTime.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPTime.m; sourceTree = ""; }; + BD62306213E95B7E00F26E0B /* XMPPElement+Delay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "XMPPElement+Delay.h"; sourceTree = ""; }; + BD62306313E95B7E00F26E0B /* XMPPElement+Delay.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "XMPPElement+Delay.m"; sourceTree = ""; }; + BD62306513E95B7E00F26E0B /* DDList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDList.h; sourceTree = ""; }; + BD62306613E95B7E00F26E0B /* DDList.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDList.m; sourceTree = ""; }; + BD62306713E95B7E00F26E0B /* GCDMulticastDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GCDMulticastDelegate.h; sourceTree = ""; }; + BD62306813E95B7E00F26E0B /* GCDMulticastDelegate.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GCDMulticastDelegate.m; sourceTree = ""; }; + BD62306913E95B7E00F26E0B /* LibIDN.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LibIDN.h; sourceTree = ""; }; + BD62306A13E95B7E00F26E0B /* LibIDN.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LibIDN.m; sourceTree = ""; }; + BD62306B13E95B7E00F26E0B /* RFImageToDataTransformer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RFImageToDataTransformer.h; sourceTree = ""; }; + BD62306C13E95B7E00F26E0B /* RFImageToDataTransformer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RFImageToDataTransformer.m; sourceTree = ""; }; + BD62306D13E95B7E00F26E0B /* XMPPSRVResolver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XMPPSRVResolver.h; sourceTree = ""; }; + BD62306E13E95B7E00F26E0B /* XMPPSRVResolver.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = XMPPSRVResolver.m; sourceTree = ""; }; + BD62307113E95B7E00F26E0B /* GCDAsyncSocket.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GCDAsyncSocket.h; sourceTree = ""; }; + BD62307213E95B7E00F26E0B /* GCDAsyncSocket.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GCDAsyncSocket.m; sourceTree = ""; }; + BD62307413E95B7E00F26E0B /* DDAbstractDatabaseLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDAbstractDatabaseLogger.h; sourceTree = ""; }; + BD62307513E95B7E00F26E0B /* DDAbstractDatabaseLogger.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDAbstractDatabaseLogger.m; sourceTree = ""; }; + BD62307613E95B7E00F26E0B /* DDASLLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDASLLogger.h; sourceTree = ""; }; + BD62307713E95B7E00F26E0B /* DDASLLogger.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDASLLogger.m; sourceTree = ""; }; + BD62307813E95B7E00F26E0B /* DDFileLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDFileLogger.h; sourceTree = ""; }; + BD62307913E95B7E00F26E0B /* DDFileLogger.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDFileLogger.m; sourceTree = ""; }; + BD62307A13E95B7E00F26E0B /* DDLog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDLog.h; sourceTree = ""; }; + BD62307B13E95B7E00F26E0B /* DDLog.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDLog.m; sourceTree = ""; }; + BD62307C13E95B7E00F26E0B /* DDTTYLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDTTYLogger.h; sourceTree = ""; }; + BD62307D13E95B7E00F26E0B /* DDTTYLogger.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDTTYLogger.m; sourceTree = ""; }; + BD62308013E95B7E00F26E0B /* NSString+DDXML.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "NSString+DDXML.h"; sourceTree = ""; }; + BD62308113E95B7E00F26E0B /* NSString+DDXML.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "NSString+DDXML.m"; sourceTree = ""; }; + BD62308213E95B7E00F26E0B /* DDXML.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDXML.h; sourceTree = ""; }; + BD62308313E95B7E00F26E0B /* DDXMLDocument.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDXMLDocument.h; sourceTree = ""; }; + BD62308413E95B7E00F26E0B /* DDXMLDocument.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDXMLDocument.m; sourceTree = ""; }; + BD62308513E95B7E00F26E0B /* DDXMLElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDXMLElement.h; sourceTree = ""; }; + BD62308613E95B7E00F26E0B /* DDXMLElement.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDXMLElement.m; sourceTree = ""; }; + BD62308713E95B7E00F26E0B /* DDXMLNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDXMLNode.h; sourceTree = ""; }; + BD62308813E95B7E00F26E0B /* DDXMLNode.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = DDXMLNode.m; sourceTree = ""; }; + BD62308A13E95B7E00F26E0B /* DDXMLPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DDXMLPrivate.h; sourceTree = ""; }; + BD62308C13E95B7E00F26E0B /* idn-int.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "idn-int.h"; sourceTree = ""; }; + BD62308D13E95B7E00F26E0B /* libidn-1.15.tar.gz */ = {isa = PBXFileReference; lastKnownFileType = archive.gzip; path = "libidn-1.15.tar.gz"; sourceTree = ""; }; + BD62308E13E95B7E00F26E0B /* libidn.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libidn.a; sourceTree = ""; }; + BD62308F13E95B7E00F26E0B /* stringprep.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stringprep.h; sourceTree = ""; }; + BD6230DE13E95BE600F26E0B /* libxml2.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libxml2.dylib; path = usr/lib/libxml2.dylib; sourceTree = SDKROOT; }; + BD6230E013E95BF300F26E0B /* CFNetwork.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CFNetwork.framework; path = System/Library/Frameworks/CFNetwork.framework; sourceTree = SDKROOT; }; + BD6230E213E95C0100F26E0B /* libresolv.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libresolv.dylib; path = usr/lib/libresolv.dylib; sourceTree = SDKROOT; }; + BD6230E413E95C0900F26E0B /* CoreData.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreData.framework; path = System/Library/Frameworks/CoreData.framework; sourceTree = SDKROOT; }; + BD6230E613E95C0F00F26E0B /* CoreLocation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreLocation.framework; path = System/Library/Frameworks/CoreLocation.framework; sourceTree = SDKROOT; }; + BD6230E813E95C1700F26E0B /* SystemConfiguration.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = SystemConfiguration.framework; path = System/Library/Frameworks/SystemConfiguration.framework; sourceTree = SDKROOT; }; + BD62310813E9626F00F26E0B /* SMLoginViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SMLoginViewController.h; sourceTree = ""; }; + BD62310913E9626F00F26E0B /* SMLoginViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SMLoginViewController.m; sourceTree = ""; }; + BD62310A13E9626F00F26E0B /* SMLoginViewController.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = SMLoginViewController.xib; sourceTree = ""; }; + BD62310F13E9628700F26E0B /* SMChatDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SMChatDelegate.h; sourceTree = ""; }; + BD62311013E9629700F26E0B /* SMMessageDelegate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SMMessageDelegate.h; sourceTree = ""; }; + BD62316B13E964BA00F26E0B /* SMChatViewController.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = SMChatViewController.xib; sourceTree = ""; }; + BD62316C13E964BA00F26E0B /* SMChatViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SMChatViewController.h; sourceTree = ""; }; + BD62316D13E964BA00F26E0B /* SMChatViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SMChatViewController.m; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 1D60588F0D05DD3D006BFB54 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 1D60589F0D05DD5A006BFB54 /* Foundation.framework in Frameworks */, + 1DF5F4E00D08C38300B7A737 /* UIKit.framework in Frameworks */, + 288765A50DF7441C002DB57D /* CoreGraphics.framework in Frameworks */, + BD6230D813E95B7E00F26E0B /* libidn.a in Frameworks */, + BD6230DF13E95BE600F26E0B /* libxml2.dylib in Frameworks */, + BD6230E113E95BF300F26E0B /* CFNetwork.framework in Frameworks */, + BD6230E313E95C0100F26E0B /* libresolv.dylib in Frameworks */, + BD6230E513E95C0900F26E0B /* CoreData.framework in Frameworks */, + BD6230E713E95C0F00F26E0B /* CoreLocation.framework in Frameworks */, + BD6230E913E95C1700F26E0B /* SystemConfiguration.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 080E96DDFE201D6D7F000001 /* Classes */ = { + isa = PBXGroup; + children = ( + 1D3623240D0F684500981E51 /* JabberClientAppDelegate.h */, + 1D3623250D0F684500981E51 /* JabberClientAppDelegate.m */, + 28D7ACF60DDB3853001CB0EB /* SMBuddyListViewController.h */, + 28D7ACF70DDB3853001CB0EB /* SMBuddyListViewController.m */, + 2899E5210DE3E06400AC0155 /* JabberClientViewController.xib */, + BD62310813E9626F00F26E0B /* SMLoginViewController.h */, + BD62310913E9626F00F26E0B /* SMLoginViewController.m */, + BD62310A13E9626F00F26E0B /* SMLoginViewController.xib */, + BD62310F13E9628700F26E0B /* SMChatDelegate.h */, + BD62311013E9629700F26E0B /* SMMessageDelegate.h */, + BD62316B13E964BA00F26E0B /* SMChatViewController.xib */, + BD62316C13E964BA00F26E0B /* SMChatViewController.h */, + BD62316D13E964BA00F26E0B /* SMChatViewController.m */, + ); + path = Classes; + sourceTree = ""; + }; + 19C28FACFE9D520D11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 1D6058910D05DD3D006BFB54 /* JabberClient.app */, + ); + name = Products; + sourceTree = ""; + }; + 29B97314FDCFA39411CA2CEA /* CustomTemplate */ = { + isa = PBXGroup; + children = ( + BD622FD713E95B7E00F26E0B /* xmpp */, + 080E96DDFE201D6D7F000001 /* Classes */, + 29B97315FDCFA39411CA2CEA /* Other Sources */, + 29B97317FDCFA39411CA2CEA /* Resources */, + 29B97323FDCFA39411CA2CEA /* Frameworks */, + 19C28FACFE9D520D11CA2CBB /* Products */, + ); + name = CustomTemplate; + sourceTree = ""; + }; + 29B97315FDCFA39411CA2CEA /* Other Sources */ = { + isa = PBXGroup; + children = ( + 32CA4F630368D1EE00C91783 /* JabberClient_Prefix.pch */, + 29B97316FDCFA39411CA2CEA /* main.m */, + ); + name = "Other Sources"; + sourceTree = ""; + }; + 29B97317FDCFA39411CA2CEA /* Resources */ = { + isa = PBXGroup; + children = ( + 28AD733E0D9D9553002E5188 /* MainWindow.xib */, + 8D1107310486CEB800E47090 /* JabberClient-Info.plist */, + ); + name = Resources; + sourceTree = ""; + }; + 29B97323FDCFA39411CA2CEA /* Frameworks */ = { + isa = PBXGroup; + children = ( + 1DF5F4DF0D08C38300B7A737 /* UIKit.framework */, + 1D30AB110D05D00D00671497 /* Foundation.framework */, + 288765A40DF7441C002DB57D /* CoreGraphics.framework */, + BD6230DE13E95BE600F26E0B /* libxml2.dylib */, + BD6230E013E95BF300F26E0B /* CFNetwork.framework */, + BD6230E213E95C0100F26E0B /* libresolv.dylib */, + BD6230E413E95C0900F26E0B /* CoreData.framework */, + BD6230E613E95C0F00F26E0B /* CoreLocation.framework */, + BD6230E813E95C1700F26E0B /* SystemConfiguration.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; + BD622FD713E95B7E00F26E0B /* xmpp */ = { + isa = PBXGroup; + children = ( + BD622FD813E95B7E00F26E0B /* Categories */, + BD622FDF13E95B7E00F26E0B /* Core */, + BD622FF313E95B7E00F26E0B /* Extensions */, + BD62306413E95B7E00F26E0B /* Utilities */, + BD62306F13E95B7E00F26E0B /* Vendor */, + ); + path = xmpp; + sourceTree = ""; + }; + BD622FD813E95B7E00F26E0B /* Categories */ = { + isa = PBXGroup; + children = ( + BD622FD913E95B7E00F26E0B /* NSData+XMPP.h */, + BD622FDA13E95B7E00F26E0B /* NSData+XMPP.m */, + BD622FDB13E95B7E00F26E0B /* NSNumber+XMPP.h */, + BD622FDC13E95B7E00F26E0B /* NSNumber+XMPP.m */, + BD622FDD13E95B7E00F26E0B /* NSXMLElement+XMPP.h */, + BD622FDE13E95B7E00F26E0B /* NSXMLElement+XMPP.m */, + ); + path = Categories; + sourceTree = ""; + }; + BD622FDF13E95B7E00F26E0B /* Core */ = { + isa = PBXGroup; + children = ( + BD622FE013E95B7E00F26E0B /* XMPP.h */, + BD622FE113E95B7E00F26E0B /* XMPPElement.h */, + BD622FE213E95B7E00F26E0B /* XMPPElement.m */, + BD622FE313E95B7E00F26E0B /* XMPPInternal.h */, + BD622FE413E95B7E00F26E0B /* XMPPIQ.h */, + BD622FE513E95B7E00F26E0B /* XMPPIQ.m */, + BD622FE613E95B7E00F26E0B /* XMPPJID.h */, + BD622FE713E95B7E00F26E0B /* XMPPJID.m */, + BD622FE813E95B7E00F26E0B /* XMPPLogging.h */, + BD622FE913E95B7E00F26E0B /* XMPPMessage.h */, + BD622FEA13E95B7E00F26E0B /* XMPPMessage.m */, + BD622FEB13E95B7E00F26E0B /* XMPPModule.h */, + BD622FEC13E95B7E00F26E0B /* XMPPModule.m */, + BD622FED13E95B7E00F26E0B /* XMPPParser.h */, + BD622FEE13E95B7E00F26E0B /* XMPPParser.m */, + BD622FEF13E95B7E00F26E0B /* XMPPPresence.h */, + BD622FF013E95B7E00F26E0B /* XMPPPresence.m */, + BD622FF113E95B7E00F26E0B /* XMPPStream.h */, + BD622FF213E95B7E00F26E0B /* XMPPStream.m */, + ); + path = Core; + sourceTree = ""; + }; + BD622FF313E95B7E00F26E0B /* Extensions */ = { + isa = PBXGroup; + children = ( + BD622FF413E95B7E00F26E0B /* CoreDataStorage */, + BD622FF813E95B7E00F26E0B /* Reconnect */, + BD622FFB13E95B7E00F26E0B /* Roster */, + BD62301313E95B7E00F26E0B /* XEP-0009 */, + BD62301A13E95B7E00F26E0B /* XEP-0045 */, + BD62302113E95B7E00F26E0B /* XEP-0054 */, + BD62303D13E95B7E00F26E0B /* XEP-0060 */, + BD62304013E95B7E00F26E0B /* XEP-0065 */, + BD62304313E95B7E00F26E0B /* XEP-0082 */, + BD62304813E95B7E00F26E0B /* XEP-0100 */, + BD62304B13E95B7E00F26E0B /* XEP-0115 */, + BD62305613E95B7E00F26E0B /* XEP-0153 */, + BD62305913E95B7E00F26E0B /* XEP-0199 */, + BD62305E13E95B7E00F26E0B /* XEP-0202 */, + BD62306113E95B7E00F26E0B /* XEP-0203 */, + ); + path = Extensions; + sourceTree = ""; + }; + BD622FF413E95B7E00F26E0B /* CoreDataStorage */ = { + isa = PBXGroup; + children = ( + BD622FF513E95B7E00F26E0B /* XMPPCoreDataStorage.h */, + BD622FF613E95B7E00F26E0B /* XMPPCoreDataStorage.m */, + BD622FF713E95B7E00F26E0B /* XMPPCoreDataStorageProtected.h */, + ); + path = CoreDataStorage; + sourceTree = ""; + }; + BD622FF813E95B7E00F26E0B /* Reconnect */ = { + isa = PBXGroup; + children = ( + BD622FF913E95B7E00F26E0B /* XMPPReconnect.h */, + BD622FFA13E95B7E00F26E0B /* XMPPReconnect.m */, + ); + path = Reconnect; + sourceTree = ""; + }; + BD622FFB13E95B7E00F26E0B /* Roster */ = { + isa = PBXGroup; + children = ( + BD622FFC13E95B7E00F26E0B /* CoreDataStorage */, + BD62300613E95B7E00F26E0B /* MemoryStorage */, + BD62300E13E95B7E00F26E0B /* XMPPResource.h */, + BD62300F13E95B7E00F26E0B /* XMPPRoster.h */, + BD62301013E95B7E00F26E0B /* XMPPRoster.m */, + BD62301113E95B7E00F26E0B /* XMPPRosterPrivate.h */, + BD62301213E95B7E00F26E0B /* XMPPUser.h */, + ); + path = Roster; + sourceTree = ""; + }; + BD622FFC13E95B7E00F26E0B /* CoreDataStorage */ = { + isa = PBXGroup; + children = ( + BD622FFD13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.h */, + BD622FFE13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.m */, + BD622FFF13E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.h */, + BD62300013E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.m */, + BD62300113E95B7E00F26E0B /* XMPPRoster.xcdatamodel */, + BD62300213E95B7E00F26E0B /* XMPPRosterCoreDataStorage.h */, + BD62300313E95B7E00F26E0B /* XMPPRosterCoreDataStorage.m */, + BD62300413E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.h */, + BD62300513E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.m */, + ); + path = CoreDataStorage; + sourceTree = ""; + }; + BD62300613E95B7E00F26E0B /* MemoryStorage */ = { + isa = PBXGroup; + children = ( + BD62300713E95B7E00F26E0B /* XMPPResourceMemoryStorage.h */, + BD62300813E95B7E00F26E0B /* XMPPResourceMemoryStorage.m */, + BD62300913E95B7E00F26E0B /* XMPPRosterMemoryStorage.h */, + BD62300A13E95B7E00F26E0B /* XMPPRosterMemoryStorage.m */, + BD62300B13E95B7E00F26E0B /* XMPPRosterMemoryStoragePrivate.h */, + BD62300C13E95B7E00F26E0B /* XMPPUserMemoryStorage.h */, + BD62300D13E95B7E00F26E0B /* XMPPUserMemoryStorage.m */, + ); + path = MemoryStorage; + sourceTree = ""; + }; + BD62301313E95B7E00F26E0B /* XEP-0009 */ = { + isa = PBXGroup; + children = ( + BD62301413E95B7E00F26E0B /* XMPPIQ+JabberRPC.h */, + BD62301513E95B7E00F26E0B /* XMPPIQ+JabberRPC.m */, + BD62301613E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.h */, + BD62301713E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.m */, + BD62301813E95B7E00F26E0B /* XMPPJabberRPCModule.h */, + BD62301913E95B7E00F26E0B /* XMPPJabberRPCModule.m */, + ); + path = "XEP-0009"; + sourceTree = ""; + }; + BD62301A13E95B7E00F26E0B /* XEP-0045 */ = { + isa = PBXGroup; + children = ( + BD62301B13E95B7E00F26E0B /* XMPPMessage+XEP0045.h */, + BD62301C13E95B7E00F26E0B /* XMPPMessage+XEP0045.m */, + BD62301D13E95B7E00F26E0B /* XMPPRoom.h */, + BD62301E13E95B7E00F26E0B /* XMPPRoom.m */, + BD62301F13E95B7E00F26E0B /* XMPPRoomOccupant.h */, + BD62302013E95B7E00F26E0B /* XMPPRoomOccupant.m */, + ); + path = "XEP-0045"; + sourceTree = ""; + }; + BD62302113E95B7E00F26E0B /* XEP-0054 */ = { + isa = PBXGroup; + children = ( + BD62302213E95B7E00F26E0B /* CoreDataStorage */, + BD62302D13E95B7E00F26E0B /* XMPPvCardTemp.h */, + BD62302E13E95B7E00F26E0B /* XMPPvCardTemp.m */, + BD62302F13E95B7E00F26E0B /* XMPPvCardTempAdr.h */, + BD62303013E95B7E00F26E0B /* XMPPvCardTempAdr.m */, + BD62303113E95B7E00F26E0B /* XMPPvCardTempAdrTypes.h */, + BD62303213E95B7E00F26E0B /* XMPPvCardTempAdrTypes.m */, + BD62303313E95B7E00F26E0B /* XMPPvCardTempBase.h */, + BD62303413E95B7E00F26E0B /* XMPPvCardTempBase.m */, + BD62303513E95B7E00F26E0B /* XMPPvCardTempEmail.h */, + BD62303613E95B7E00F26E0B /* XMPPvCardTempEmail.m */, + BD62303713E95B7E00F26E0B /* XMPPvCardTempLabel.h */, + BD62303813E95B7E00F26E0B /* XMPPvCardTempLabel.m */, + BD62303913E95B7E00F26E0B /* XMPPvCardTempModule.h */, + BD62303A13E95B7E00F26E0B /* XMPPvCardTempModule.m */, + BD62303B13E95B7E00F26E0B /* XMPPvCardTempTel.h */, + BD62303C13E95B7E00F26E0B /* XMPPvCardTempTel.m */, + ); + path = "XEP-0054"; + sourceTree = ""; + }; + BD62302213E95B7E00F26E0B /* CoreDataStorage */ = { + isa = PBXGroup; + children = ( + BD62302313E95B7E00F26E0B /* XMPPvCard.xcdatamodeld */, + BD62302513E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.h */, + BD62302613E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.m */, + BD62302713E95B7E00F26E0B /* XMPPvCardCoreDataStorage.h */, + BD62302813E95B7E00F26E0B /* XMPPvCardCoreDataStorage.m */, + BD62302913E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.h */, + BD62302A13E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.m */, + BD62302B13E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.h */, + BD62302C13E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.m */, + ); + path = CoreDataStorage; + sourceTree = ""; + }; + BD62303D13E95B7E00F26E0B /* XEP-0060 */ = { + isa = PBXGroup; + children = ( + BD62303E13E95B7E00F26E0B /* XMPPPubSub.h */, + BD62303F13E95B7E00F26E0B /* XMPPPubSub.m */, + ); + path = "XEP-0060"; + sourceTree = ""; + }; + BD62304013E95B7E00F26E0B /* XEP-0065 */ = { + isa = PBXGroup; + children = ( + BD62304113E95B7E00F26E0B /* TURNSocket.h */, + BD62304213E95B7E00F26E0B /* TURNSocket.m */, + ); + path = "XEP-0065"; + sourceTree = ""; + }; + BD62304313E95B7E00F26E0B /* XEP-0082 */ = { + isa = PBXGroup; + children = ( + BD62304413E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.h */, + BD62304513E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.m */, + BD62304613E95B7E00F26E0B /* XMPPDateTimeProfiles.h */, + BD62304713E95B7E00F26E0B /* XMPPDateTimeProfiles.m */, + ); + path = "XEP-0082"; + sourceTree = ""; + }; + BD62304813E95B7E00F26E0B /* XEP-0100 */ = { + isa = PBXGroup; + children = ( + BD62304913E95B7E00F26E0B /* XMPPTransports.h */, + BD62304A13E95B7E00F26E0B /* XMPPTransports.m */, + ); + path = "XEP-0100"; + sourceTree = ""; + }; + BD62304B13E95B7E00F26E0B /* XEP-0115 */ = { + isa = PBXGroup; + children = ( + BD62304C13E95B7E00F26E0B /* CoreDataStorage */, + BD62305413E95B7E00F26E0B /* XMPPCapabilities.h */, + BD62305513E95B7E00F26E0B /* XMPPCapabilities.m */, + ); + path = "XEP-0115"; + sourceTree = ""; + }; + BD62304C13E95B7E00F26E0B /* CoreDataStorage */ = { + isa = PBXGroup; + children = ( + BD62304D13E95B7E00F26E0B /* XMPPCapabilities.xcdatamodel */, + BD62304E13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.h */, + BD62304F13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.m */, + BD62305013E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.h */, + BD62305113E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.m */, + BD62305213E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.h */, + BD62305313E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.m */, + ); + path = CoreDataStorage; + sourceTree = ""; + }; + BD62305613E95B7E00F26E0B /* XEP-0153 */ = { + isa = PBXGroup; + children = ( + BD62305713E95B7E00F26E0B /* XMPPvCardAvatarModule.h */, + BD62305813E95B7E00F26E0B /* XMPPvCardAvatarModule.m */, + ); + path = "XEP-0153"; + sourceTree = ""; + }; + BD62305913E95B7E00F26E0B /* XEP-0199 */ = { + isa = PBXGroup; + children = ( + BD62305A13E95B7E00F26E0B /* XMPPAutoPing.h */, + BD62305B13E95B7E00F26E0B /* XMPPAutoPing.m */, + BD62305C13E95B7E00F26E0B /* XMPPPing.h */, + BD62305D13E95B7E00F26E0B /* XMPPPing.m */, + ); + path = "XEP-0199"; + sourceTree = ""; + }; + BD62305E13E95B7E00F26E0B /* XEP-0202 */ = { + isa = PBXGroup; + children = ( + BD62305F13E95B7E00F26E0B /* XMPPTime.h */, + BD62306013E95B7E00F26E0B /* XMPPTime.m */, + ); + path = "XEP-0202"; + sourceTree = ""; + }; + BD62306113E95B7E00F26E0B /* XEP-0203 */ = { + isa = PBXGroup; + children = ( + BD62306213E95B7E00F26E0B /* XMPPElement+Delay.h */, + BD62306313E95B7E00F26E0B /* XMPPElement+Delay.m */, + ); + path = "XEP-0203"; + sourceTree = ""; + }; + BD62306413E95B7E00F26E0B /* Utilities */ = { + isa = PBXGroup; + children = ( + BD62306513E95B7E00F26E0B /* DDList.h */, + BD62306613E95B7E00F26E0B /* DDList.m */, + BD62306713E95B7E00F26E0B /* GCDMulticastDelegate.h */, + BD62306813E95B7E00F26E0B /* GCDMulticastDelegate.m */, + BD62306913E95B7E00F26E0B /* LibIDN.h */, + BD62306A13E95B7E00F26E0B /* LibIDN.m */, + BD62306B13E95B7E00F26E0B /* RFImageToDataTransformer.h */, + BD62306C13E95B7E00F26E0B /* RFImageToDataTransformer.m */, + BD62306D13E95B7E00F26E0B /* XMPPSRVResolver.h */, + BD62306E13E95B7E00F26E0B /* XMPPSRVResolver.m */, + ); + path = Utilities; + sourceTree = ""; + }; + BD62306F13E95B7E00F26E0B /* Vendor */ = { + isa = PBXGroup; + children = ( + BD62307013E95B7E00F26E0B /* CocoaAsyncSocket */, + BD62307313E95B7E00F26E0B /* CocoaLumberjack */, + BD62307E13E95B7E00F26E0B /* KissXML */, + BD62308B13E95B7E00F26E0B /* libidn */, + ); + path = Vendor; + sourceTree = ""; + }; + BD62307013E95B7E00F26E0B /* CocoaAsyncSocket */ = { + isa = PBXGroup; + children = ( + BD62307113E95B7E00F26E0B /* GCDAsyncSocket.h */, + BD62307213E95B7E00F26E0B /* GCDAsyncSocket.m */, + ); + path = CocoaAsyncSocket; + sourceTree = ""; + }; + BD62307313E95B7E00F26E0B /* CocoaLumberjack */ = { + isa = PBXGroup; + children = ( + BD62307413E95B7E00F26E0B /* DDAbstractDatabaseLogger.h */, + BD62307513E95B7E00F26E0B /* DDAbstractDatabaseLogger.m */, + BD62307613E95B7E00F26E0B /* DDASLLogger.h */, + BD62307713E95B7E00F26E0B /* DDASLLogger.m */, + BD62307813E95B7E00F26E0B /* DDFileLogger.h */, + BD62307913E95B7E00F26E0B /* DDFileLogger.m */, + BD62307A13E95B7E00F26E0B /* DDLog.h */, + BD62307B13E95B7E00F26E0B /* DDLog.m */, + BD62307C13E95B7E00F26E0B /* DDTTYLogger.h */, + BD62307D13E95B7E00F26E0B /* DDTTYLogger.m */, + ); + path = CocoaLumberjack; + sourceTree = ""; + }; + BD62307E13E95B7E00F26E0B /* KissXML */ = { + isa = PBXGroup; + children = ( + BD62307F13E95B7E00F26E0B /* Categories */, + BD62308213E95B7E00F26E0B /* DDXML.h */, + BD62308313E95B7E00F26E0B /* DDXMLDocument.h */, + BD62308413E95B7E00F26E0B /* DDXMLDocument.m */, + BD62308513E95B7E00F26E0B /* DDXMLElement.h */, + BD62308613E95B7E00F26E0B /* DDXMLElement.m */, + BD62308713E95B7E00F26E0B /* DDXMLNode.h */, + BD62308813E95B7E00F26E0B /* DDXMLNode.m */, + BD62308913E95B7E00F26E0B /* Private */, + ); + path = KissXML; + sourceTree = ""; + }; + BD62307F13E95B7E00F26E0B /* Categories */ = { + isa = PBXGroup; + children = ( + BD62308013E95B7E00F26E0B /* NSString+DDXML.h */, + BD62308113E95B7E00F26E0B /* NSString+DDXML.m */, + ); + path = Categories; + sourceTree = ""; + }; + BD62308913E95B7E00F26E0B /* Private */ = { + isa = PBXGroup; + children = ( + BD62308A13E95B7E00F26E0B /* DDXMLPrivate.h */, + ); + path = Private; + sourceTree = ""; + }; + BD62308B13E95B7E00F26E0B /* libidn */ = { + isa = PBXGroup; + children = ( + BD62308C13E95B7E00F26E0B /* idn-int.h */, + BD62308D13E95B7E00F26E0B /* libidn-1.15.tar.gz */, + BD62308E13E95B7E00F26E0B /* libidn.a */, + BD62308F13E95B7E00F26E0B /* stringprep.h */, + ); + path = libidn; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 1D6058900D05DD3D006BFB54 /* JabberClient */ = { + isa = PBXNativeTarget; + buildConfigurationList = 1D6058960D05DD3E006BFB54 /* Build configuration list for PBXNativeTarget "JabberClient" */; + buildPhases = ( + 1D60588D0D05DD3D006BFB54 /* Resources */, + 1D60588E0D05DD3D006BFB54 /* Sources */, + 1D60588F0D05DD3D006BFB54 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = JabberClient; + productName = JabberClient; + productReference = 1D6058910D05DD3D006BFB54 /* JabberClient.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 29B97313FDCFA39411CA2CEA /* Project object */ = { + isa = PBXProject; + buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "JabberClient" */; + compatibilityVersion = "Xcode 3.2"; + developmentRegion = English; + hasScannedForEncodings = 1; + knownRegions = ( + English, + Japanese, + French, + German, + ); + mainGroup = 29B97314FDCFA39411CA2CEA /* CustomTemplate */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 1D6058900D05DD3D006BFB54 /* JabberClient */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 1D60588D0D05DD3D006BFB54 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 28AD733F0D9D9553002E5188 /* MainWindow.xib in Resources */, + 2899E5220DE3E06400AC0155 /* JabberClientViewController.xib in Resources */, + BD6230D713E95B7E00F26E0B /* libidn-1.15.tar.gz in Resources */, + BD62310C13E9626F00F26E0B /* SMLoginViewController.xib in Resources */, + BD62316E13E964BA00F26E0B /* SMChatViewController.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 1D60588E0D05DD3D006BFB54 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 1D60589B0D05DD56006BFB54 /* main.m in Sources */, + 1D3623260D0F684500981E51 /* JabberClientAppDelegate.m in Sources */, + 28D7ACF80DDB3853001CB0EB /* SMBuddyListViewController.m in Sources */, + BD62309013E95B7E00F26E0B /* NSData+XMPP.m in Sources */, + BD62309113E95B7E00F26E0B /* NSNumber+XMPP.m in Sources */, + BD62309213E95B7E00F26E0B /* NSXMLElement+XMPP.m in Sources */, + BD62309313E95B7E00F26E0B /* XMPPElement.m in Sources */, + BD62309413E95B7E00F26E0B /* XMPPIQ.m in Sources */, + BD62309513E95B7E00F26E0B /* XMPPJID.m in Sources */, + BD62309613E95B7E00F26E0B /* XMPPMessage.m in Sources */, + BD62309713E95B7E00F26E0B /* XMPPModule.m in Sources */, + BD62309813E95B7E00F26E0B /* XMPPParser.m in Sources */, + BD62309913E95B7E00F26E0B /* XMPPPresence.m in Sources */, + BD62309A13E95B7E00F26E0B /* XMPPStream.m in Sources */, + BD62309B13E95B7E00F26E0B /* XMPPCoreDataStorage.m in Sources */, + BD62309C13E95B7E00F26E0B /* XMPPReconnect.m in Sources */, + BD62309D13E95B7E00F26E0B /* XMPPGroupCoreDataStorageObject.m in Sources */, + BD62309E13E95B7E00F26E0B /* XMPPResourceCoreDataStorageObject.m in Sources */, + BD62309F13E95B7E00F26E0B /* XMPPRoster.xcdatamodel in Sources */, + BD6230A013E95B7E00F26E0B /* XMPPRosterCoreDataStorage.m in Sources */, + BD6230A113E95B7E00F26E0B /* XMPPUserCoreDataStorageObject.m in Sources */, + BD6230A213E95B7E00F26E0B /* XMPPResourceMemoryStorage.m in Sources */, + BD6230A313E95B7E00F26E0B /* XMPPRosterMemoryStorage.m in Sources */, + BD6230A413E95B7E00F26E0B /* XMPPUserMemoryStorage.m in Sources */, + BD6230A513E95B7E00F26E0B /* XMPPRoster.m in Sources */, + BD6230A613E95B7E00F26E0B /* XMPPIQ+JabberRPC.m in Sources */, + BD6230A713E95B7E00F26E0B /* XMPPIQ+JabberRPCResonse.m in Sources */, + BD6230A813E95B7E00F26E0B /* XMPPJabberRPCModule.m in Sources */, + BD6230A913E95B7E00F26E0B /* XMPPMessage+XEP0045.m in Sources */, + BD6230AA13E95B7E00F26E0B /* XMPPRoom.m in Sources */, + BD6230AB13E95B7E00F26E0B /* XMPPRoomOccupant.m in Sources */, + BD6230AC13E95B7E00F26E0B /* XMPPvCard.xcdatamodeld in Sources */, + BD6230AD13E95B7E00F26E0B /* XMPPvCardAvatarCoreDataStorageObject.m in Sources */, + BD6230AE13E95B7E00F26E0B /* XMPPvCardCoreDataStorage.m in Sources */, + BD6230AF13E95B7E00F26E0B /* XMPPvCardCoreDataStorageObject.m in Sources */, + BD6230B013E95B7E00F26E0B /* XMPPvCardTempCoreDataStorageObject.m in Sources */, + BD6230B113E95B7E00F26E0B /* XMPPvCardTemp.m in Sources */, + BD6230B213E95B7E00F26E0B /* XMPPvCardTempAdr.m in Sources */, + BD6230B313E95B7E00F26E0B /* XMPPvCardTempAdrTypes.m in Sources */, + BD6230B413E95B7E00F26E0B /* XMPPvCardTempBase.m in Sources */, + BD6230B513E95B7E00F26E0B /* XMPPvCardTempEmail.m in Sources */, + BD6230B613E95B7E00F26E0B /* XMPPvCardTempLabel.m in Sources */, + BD6230B713E95B7E00F26E0B /* XMPPvCardTempModule.m in Sources */, + BD6230B813E95B7E00F26E0B /* XMPPvCardTempTel.m in Sources */, + BD6230B913E95B7E00F26E0B /* XMPPPubSub.m in Sources */, + BD6230BA13E95B7E00F26E0B /* TURNSocket.m in Sources */, + BD6230BB13E95B7E00F26E0B /* NSDate+XMPPDateTimeProfiles.m in Sources */, + BD6230BC13E95B7E00F26E0B /* XMPPDateTimeProfiles.m in Sources */, + BD6230BD13E95B7E00F26E0B /* XMPPTransports.m in Sources */, + BD6230BE13E95B7E00F26E0B /* XMPPCapabilities.xcdatamodel in Sources */, + BD6230BF13E95B7E00F26E0B /* XMPPCapabilitiesCoreDataStorage.m in Sources */, + BD6230C013E95B7E00F26E0B /* XMPPCapsCoreDataStorageObject.m in Sources */, + BD6230C113E95B7E00F26E0B /* XMPPCapsResourceCoreDataStorageObject.m in Sources */, + BD6230C213E95B7E00F26E0B /* XMPPCapabilities.m in Sources */, + BD6230C313E95B7E00F26E0B /* XMPPvCardAvatarModule.m in Sources */, + BD6230C413E95B7E00F26E0B /* XMPPAutoPing.m in Sources */, + BD6230C513E95B7E00F26E0B /* XMPPPing.m in Sources */, + BD6230C613E95B7E00F26E0B /* XMPPTime.m in Sources */, + BD6230C713E95B7E00F26E0B /* XMPPElement+Delay.m in Sources */, + BD6230C813E95B7E00F26E0B /* DDList.m in Sources */, + BD6230C913E95B7E00F26E0B /* GCDMulticastDelegate.m in Sources */, + BD6230CA13E95B7E00F26E0B /* LibIDN.m in Sources */, + BD6230CB13E95B7E00F26E0B /* RFImageToDataTransformer.m in Sources */, + BD6230CC13E95B7E00F26E0B /* XMPPSRVResolver.m in Sources */, + BD6230CD13E95B7E00F26E0B /* GCDAsyncSocket.m in Sources */, + BD6230CE13E95B7E00F26E0B /* DDAbstractDatabaseLogger.m in Sources */, + BD6230CF13E95B7E00F26E0B /* DDASLLogger.m in Sources */, + BD6230D013E95B7E00F26E0B /* DDFileLogger.m in Sources */, + BD6230D113E95B7E00F26E0B /* DDLog.m in Sources */, + BD6230D213E95B7E00F26E0B /* DDTTYLogger.m in Sources */, + BD6230D313E95B7E00F26E0B /* NSString+DDXML.m in Sources */, + BD6230D413E95B7E00F26E0B /* DDXMLDocument.m in Sources */, + BD6230D513E95B7E00F26E0B /* DDXMLElement.m in Sources */, + BD6230D613E95B7E00F26E0B /* DDXMLNode.m in Sources */, + BD62310B13E9626F00F26E0B /* SMLoginViewController.m in Sources */, + BD62316F13E964BA00F26E0B /* SMChatViewController.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 1D6058940D05DD3E006BFB54 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = JabberClient_Prefix.pch; + HEADER_SEARCH_PATHS = /usr/include/libxml2; + INFOPLIST_FILE = "JabberClient-Info.plist"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/xmpp/Vendor/libidn\"", + ); + PRODUCT_NAME = JabberClient; + }; + name = Debug; + }; + 1D6058950D05DD3E006BFB54 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = YES; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = JabberClient_Prefix.pch; + HEADER_SEARCH_PATHS = /usr/include/libxml2; + INFOPLIST_FILE = "JabberClient-Info.plist"; + LIBRARY_SEARCH_PATHS = ( + "$(inherited)", + "\"$(SRCROOT)/xmpp/Vendor/libidn\"", + ); + PRODUCT_NAME = JabberClient; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + C01FCF4F08A954540054247B /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_BIT)"; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + GCC_C_LANGUAGE_STANDARD = c99; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + OTHER_LDFLAGS = "-lxml2"; + PREBINDING = NO; + SDKROOT = iphoneos; + USER_HEADER_SEARCH_PATHS = /usr/include/libxml2; + }; + name = Debug; + }; + C01FCF5008A954540054247B /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_BIT)"; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + GCC_C_LANGUAGE_STANDARD = c99; + GCC_WARN_ABOUT_RETURN_TYPE = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1"; + OTHER_LDFLAGS = "-lxml2"; + PREBINDING = NO; + SDKROOT = iphoneos; + USER_HEADER_SEARCH_PATHS = /usr/include/libxml2; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 1D6058960D05DD3E006BFB54 /* Build configuration list for PBXNativeTarget "JabberClient" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 1D6058940D05DD3E006BFB54 /* Debug */, + 1D6058950D05DD3E006BFB54 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + C01FCF4E08A954540054247B /* Build configuration list for PBXProject "JabberClient" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + C01FCF4F08A954540054247B /* Debug */, + C01FCF5008A954540054247B /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + +/* Begin XCVersionGroup section */ + BD62302313E95B7E00F26E0B /* XMPPvCard.xcdatamodeld */ = { + isa = XCVersionGroup; + children = ( + BD62302413E95B7E00F26E0B /* XMPPvCard.xcdatamodel */, + ); + currentVersion = BD62302413E95B7E00F26E0B /* XMPPvCard.xcdatamodel */; + path = XMPPvCard.xcdatamodeld; + sourceTree = ""; + versionGroupType = wrapper.xcdatamodel; + }; +/* End XCVersionGroup section */ + }; + rootObject = 29B97313FDCFA39411CA2CEA /* Project object */; +} diff --git a/JabberClientViewController.xib b/JabberClientViewController.xib new file mode 100644 index 0000000..262caab --- /dev/null +++ b/JabberClientViewController.xib @@ -0,0 +1,559 @@ + + + + 1056 + 10K549 + 851 + 1038.36 + 461.00 + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + 141 + + + YES + + + + YES + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + YES + + YES + + + YES + + + + YES + + IBFilesOwner + IBCocoaTouchFramework + + + IBFirstResponder + IBCocoaTouchFramework + + + + 274 + + YES + + + 274 + {{0, 41}, {320, 399}} + + + 3 + MQA + + YES + IBCocoaTouchFramework + YES + 1 + 0 + YES + 44 + 22 + 22 + + + + 266 + {320, 44} + + + NO + NO + IBCocoaTouchFramework + + YES + + Account + IBCocoaTouchFramework + 1 + + + + + + {320, 460} + + + 3 + MC43NQA + + 2 + + + NO + + IBCocoaTouchFramework + + + + + YES + + + tView + + + + 11 + + + + showLogin + + + + 12 + + + + view + + + + 13 + + + + + YES + + 0 + + + + + + -1 + + + File's Owner + + + -2 + + + + + 6 + + + YES + + + + + + + 8 + + + + + 9 + + + YES + + + + + + 10 + + + + + + + YES + + YES + -1.CustomClassName + -2.CustomClassName + 10.IBPluginDependency + 6.IBEditorWindowLastContentRect + 6.IBPluginDependency + 8.IBPluginDependency + 8.IBViewBoundsToFrameTransform + 9.IBPluginDependency + 9.IBViewBoundsToFrameTransform + + + YES + SMBuddyListViewController + UIResponder + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + {{1365, 542}, {320, 480}} + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAAAAAAAAw9YAAA + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + P4AAAL+AAAAAAAAAw3oAAA + + + + + YES + + + YES + + + + + YES + + + YES + + + + 13 + + + + YES + + SMBuddyListViewController + UIViewController + + YES + + YES + addBuddy + showLogin + + + YES + id + id + + + + YES + + YES + addBuddy + showLogin + + + YES + + addBuddy + id + + + showLogin + id + + + + + YES + + YES + addBuddyView + buddyField + tView + + + YES + UIView + UITextField + UITableView + + + + YES + + YES + addBuddyView + buddyField + tView + + + YES + + addBuddyView + UIView + + + buddyField + UITextField + + + tView + UITableView + + + + + IBProjectSource + Classes/SMBuddyListViewController.h + + + + SMBuddyListViewController + UIViewController + + IBUserSource + + + + + + YES + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSError.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSFileManager.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueCoding.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueObserving.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyedArchiver.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSObject.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSRunLoop.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSThread.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURL.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURLConnection.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIAccessibility.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UINibLoading.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIResponder.h + + + + UIBarButtonItem + UIBarItem + + IBFrameworkSource + UIKit.framework/Headers/UIBarButtonItem.h + + + + UIBarItem + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIBarItem.h + + + + UIControl + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIControl.h + + + + UIResponder + NSObject + + + + UIScrollView + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIScrollView.h + + + + UISearchBar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UISearchBar.h + + + + UISearchDisplayController + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UISearchDisplayController.h + + + + UITableView + UIScrollView + + IBFrameworkSource + UIKit.framework/Headers/UITableView.h + + + + UITextField + UIControl + + IBFrameworkSource + UIKit.framework/Headers/UITextField.h + + + + UIToolbar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIToolbar.h + + + + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIPrintFormatter.h + + + + UIView + + + + UIView + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIView.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UINavigationController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UIPopoverController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UISplitViewController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UITabBarController.h + + + + UIViewController + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIViewController.h + + + + + 0 + IBCocoaTouchFramework + + com.apple.InterfaceBuilder.CocoaTouchPlugin.iPhoneOS + + + + com.apple.InterfaceBuilder.CocoaTouchPlugin.InterfaceBuilder3 + + + YES + JabberClient.xcodeproj + 3 + 141 + + diff --git a/JabberClient_Prefix.pch b/JabberClient_Prefix.pch new file mode 100644 index 0000000..0e616e1 --- /dev/null +++ b/JabberClient_Prefix.pch @@ -0,0 +1,8 @@ +// +// Prefix header for all source files of the 'JabberClient' target in the 'JabberClient' project +// + +#ifdef __OBJC__ + #import + #import +#endif diff --git a/MainWindow.xib b/MainWindow.xib new file mode 100644 index 0000000..0f78c2c --- /dev/null +++ b/MainWindow.xib @@ -0,0 +1,443 @@ + + + + 1024 + 10K549 + 851 + 1038.36 + 461.00 + + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + 141 + + + YES + + + YES + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + YES + + YES + + + YES + + + + YES + + IBFilesOwner + IBCocoaTouchFramework + + + IBFirstResponder + IBCocoaTouchFramework + + + IBCocoaTouchFramework + + + JabberClientViewController + + + 1 + + IBCocoaTouchFramework + NO + + + + 292 + {320, 480} + + 1 + MSAxIDEAA + + NO + NO + + IBCocoaTouchFramework + YES + + + + + YES + + + delegate + + + + 4 + + + + viewController + + + + 11 + + + + window + + + + 14 + + + + + YES + + 0 + + + + + + -1 + + + File's Owner + + + 3 + + + JabberClient App Delegate + + + -2 + + + + + 10 + + + + + 12 + + + + + + + YES + + YES + -1.CustomClassName + -2.CustomClassName + 10.CustomClassName + 10.IBEditorWindowLastContentRect + 10.IBPluginDependency + 12.IBEditorWindowLastContentRect + 12.IBPluginDependency + 3.CustomClassName + 3.IBPluginDependency + + + YES + UIApplication + UIResponder + SMBuddyListViewController + {{234, 376}, {320, 480}} + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + {{525, 346}, {320, 480}} + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + JabberClientAppDelegate + com.apple.InterfaceBuilder.IBCocoaTouchPlugin + + + + YES + + + YES + + + + + YES + + + YES + + + + 15 + + + + YES + + JabberClientAppDelegate + NSObject + + YES + + YES + viewController + window + + + YES + SMBuddyListViewController + UIWindow + + + + YES + + YES + viewController + window + + + YES + + viewController + SMBuddyListViewController + + + window + UIWindow + + + + + IBProjectSource + Classes/JabberClientAppDelegate.h + + + + JabberClientAppDelegate + NSObject + + IBUserSource + + + + + SMBuddyListViewController + UIViewController + + IBUserSource + + + + + UIWindow + UIView + + IBUserSource + + + + + + YES + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSError.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSFileManager.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueCoding.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyValueObserving.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSKeyedArchiver.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSObject.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSRunLoop.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSThread.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURL.h + + + + NSObject + + IBFrameworkSource + Foundation.framework/Headers/NSURLConnection.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIAccessibility.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UINibLoading.h + + + + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UIResponder.h + + + + UIApplication + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIApplication.h + + + + UIResponder + NSObject + + + + UISearchBar + UIView + + IBFrameworkSource + UIKit.framework/Headers/UISearchBar.h + + + + UISearchDisplayController + NSObject + + IBFrameworkSource + UIKit.framework/Headers/UISearchDisplayController.h + + + + UIView + + IBFrameworkSource + UIKit.framework/Headers/UITextField.h + + + + UIView + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIView.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UINavigationController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UIPopoverController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UISplitViewController.h + + + + UIViewController + + IBFrameworkSource + UIKit.framework/Headers/UITabBarController.h + + + + UIViewController + UIResponder + + IBFrameworkSource + UIKit.framework/Headers/UIViewController.h + + + + UIWindow + UIView + + IBFrameworkSource + UIKit.framework/Headers/UIWindow.h + + + + + 0 + IBCocoaTouchFramework + + com.apple.InterfaceBuilder.CocoaTouchPlugin.iPhoneOS + + + + com.apple.InterfaceBuilder.CocoaTouchPlugin.InterfaceBuilder3 + + + YES + JabberClient.xcodeproj + 3 + 141 + + diff --git a/main.m b/main.m new file mode 100644 index 0000000..2dabc11 --- /dev/null +++ b/main.m @@ -0,0 +1,17 @@ +// +// main.m +// JabberClient +// +// Created by cesarerocchi on 8/3/11. +// Copyright 2011 studiomagnolia.com. All rights reserved. +// + +#import + +int main(int argc, char *argv[]) { + + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; + int retVal = UIApplicationMain(argc, argv, nil, nil); + [pool release]; + return retVal; +} diff --git a/xmpp/Categories/NSData+XMPP.h b/xmpp/Categories/NSData+XMPP.h new file mode 100644 index 0000000..085c944 --- /dev/null +++ b/xmpp/Categories/NSData+XMPP.h @@ -0,0 +1,14 @@ +#import + +@interface NSData (XMPP) + +- (NSData *)md5Digest; + +- (NSData *)sha1Digest; + +- (NSString *)hexStringValue; + +- (NSString *)base64Encoded; +- (NSData *)base64Decoded; + +@end diff --git a/xmpp/Categories/NSData+XMPP.m b/xmpp/Categories/NSData+XMPP.m new file mode 100644 index 0000000..b01c24f --- /dev/null +++ b/xmpp/Categories/NSData+XMPP.m @@ -0,0 +1,158 @@ +#import "NSData+XMPP.h" +#import + + +@implementation NSData (XMPP) + +static char encodingTable[64] = { + 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P', + 'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f', + 'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v', + 'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/' }; + + +- (NSData *)md5Digest +{ + unsigned char result[CC_MD5_DIGEST_LENGTH]; + + CC_MD5([self bytes], (CC_LONG)[self length], result); + return [NSData dataWithBytes:result length:CC_MD5_DIGEST_LENGTH]; +} + +- (NSData *)sha1Digest +{ + unsigned char result[CC_SHA1_DIGEST_LENGTH]; + + CC_SHA1([self bytes], (CC_LONG)[self length], result); + return [NSData dataWithBytes:result length:CC_SHA1_DIGEST_LENGTH]; +} + +- (NSString *)hexStringValue +{ + NSMutableString *stringBuffer = [NSMutableString stringWithCapacity:([self length] * 2)]; + + const unsigned char *dataBuffer = [self bytes]; + int i; + + for (i = 0; i < [self length]; ++i) + { + [stringBuffer appendFormat:@"%02x", (unsigned long)dataBuffer[i]]; + } + + return [[stringBuffer copy] autorelease]; +} + +- (NSString *)base64Encoded +{ + const unsigned char *bytes = [self bytes]; + NSMutableString *result = [NSMutableString stringWithCapacity:[self length]]; + unsigned long ixtext = 0; + unsigned long lentext = [self length]; + long ctremaining = 0; + unsigned char inbuf[3], outbuf[4]; + unsigned short i = 0; + unsigned short charsonline = 0, ctcopy = 0; + unsigned long ix = 0; + + while( YES ) + { + ctremaining = lentext - ixtext; + if( ctremaining <= 0 ) break; + + for( i = 0; i < 3; i++ ) { + ix = ixtext + i; + if( ix < lentext ) inbuf[i] = bytes[ix]; + else inbuf [i] = 0; + } + + outbuf [0] = (inbuf [0] & 0xFC) >> 2; + outbuf [1] = ((inbuf [0] & 0x03) << 4) | ((inbuf [1] & 0xF0) >> 4); + outbuf [2] = ((inbuf [1] & 0x0F) << 2) | ((inbuf [2] & 0xC0) >> 6); + outbuf [3] = inbuf [2] & 0x3F; + ctcopy = 4; + + switch( ctremaining ) + { + case 1: + ctcopy = 2; + break; + case 2: + ctcopy = 3; + break; + } + + for( i = 0; i < ctcopy; i++ ) + [result appendFormat:@"%c", encodingTable[outbuf[i]]]; + + for( i = ctcopy; i < 4; i++ ) + [result appendString:@"="]; + + ixtext += 3; + charsonline += 4; + } + + return [NSString stringWithString:result]; +} + +- (NSData *)base64Decoded +{ + const unsigned char *bytes = [self bytes]; + NSMutableData *result = [NSMutableData dataWithCapacity:[self length]]; + + unsigned long ixtext = 0; + unsigned long lentext = [self length]; + unsigned char ch = 0; + unsigned char inbuf[4], outbuf[3]; + short i = 0, ixinbuf = 0; + BOOL flignore = NO; + BOOL flendtext = NO; + + while( YES ) + { + if( ixtext >= lentext ) break; + ch = bytes[ixtext++]; + flignore = NO; + + if( ( ch >= 'A' ) && ( ch <= 'Z' ) ) ch = ch - 'A'; + else if( ( ch >= 'a' ) && ( ch <= 'z' ) ) ch = ch - 'a' + 26; + else if( ( ch >= '0' ) && ( ch <= '9' ) ) ch = ch - '0' + 52; + else if( ch == '+' ) ch = 62; + else if( ch == '=' ) flendtext = YES; + else if( ch == '/' ) ch = 63; + else flignore = YES; + + if( ! flignore ) + { + short ctcharsinbuf = 3; + BOOL flbreak = NO; + + if( flendtext ) + { + if( ! ixinbuf ) break; + if( ( ixinbuf == 1 ) || ( ixinbuf == 2 ) ) ctcharsinbuf = 1; + else ctcharsinbuf = 2; + ixinbuf = 3; + flbreak = YES; + } + + inbuf [ixinbuf++] = ch; + + if( ixinbuf == 4 ) + { + ixinbuf = 0; + outbuf [0] = ( inbuf[0] << 2 ) | ( ( inbuf[1] & 0x30) >> 4 ); + outbuf [1] = ( ( inbuf[1] & 0x0F ) << 4 ) | ( ( inbuf[2] & 0x3C ) >> 2 ); + outbuf [2] = ( ( inbuf[2] & 0x03 ) << 6 ) | ( inbuf[3] & 0x3F ); + + for( i = 0; i < ctcharsinbuf; i++ ) + [result appendBytes:&outbuf[i] length:1]; + } + + if( flbreak ) break; + } + } + + return [NSData dataWithData:result]; +} + +@end diff --git a/xmpp/Categories/NSNumber+XMPP.h b/xmpp/Categories/NSNumber+XMPP.h new file mode 100644 index 0000000..ec0679b --- /dev/null +++ b/xmpp/Categories/NSNumber+XMPP.h @@ -0,0 +1,21 @@ +#import + + +@interface NSNumber (XMPP) + ++ (NSNumber *)numberWithPtr:(const void *)ptr; +- (id)initWithPtr:(const void *)ptr; + ++ (BOOL)parseString:(NSString *)str intoSInt64:(SInt64 *)pNum; ++ (BOOL)parseString:(NSString *)str intoUInt64:(UInt64 *)pNum; + ++ (BOOL)parseString:(NSString *)str intoNSInteger:(NSInteger *)pNum; ++ (BOOL)parseString:(NSString *)str intoNSUInteger:(NSUInteger *)pNum; + ++ (UInt8)extractUInt8FromData:(NSData *)data atOffset:(unsigned int)offset; + ++ (UInt16)extractUInt16FromData:(NSData *)data atOffset:(unsigned int)offset andConvertFromNetworkOrder:(BOOL)flag; + ++ (UInt32)extractUInt32FromData:(NSData *)data atOffset:(unsigned int)offset andConvertFromNetworkOrder:(BOOL)flag; + +@end diff --git a/xmpp/Categories/NSNumber+XMPP.m b/xmpp/Categories/NSNumber+XMPP.m new file mode 100644 index 0000000..161843f --- /dev/null +++ b/xmpp/Categories/NSNumber+XMPP.m @@ -0,0 +1,140 @@ +#import "NSNumber+XMPP.h" + + +@implementation NSNumber (XMPP) + ++ (NSNumber *)numberWithPtr:(const void *)ptr +{ + return [[[NSNumber alloc] initWithPtr:ptr] autorelease]; +} + +- (id)initWithPtr:(const void *)ptr +{ + return [self initWithLong:(long)ptr]; +} + ++ (BOOL)parseString:(NSString *)str intoSInt64:(SInt64 *)pNum +{ + if(str == nil) + { + *pNum = 0; + return NO; + } + + errno = 0; + + // On both 32-bit and 64-bit machines, long long = 64 bit + + *pNum = strtoll([str UTF8String], NULL, 10); + + if(errno != 0) + return NO; + else + return YES; +} + ++ (BOOL)parseString:(NSString *)str intoUInt64:(UInt64 *)pNum +{ + if(str == nil) + { + *pNum = 0; + return NO; + } + + errno = 0; + + // On both 32-bit and 64-bit machines, unsigned long long = 64 bit + + *pNum = strtoull([str UTF8String], NULL, 10); + + if(errno != 0) + return NO; + else + return YES; +} + ++ (BOOL)parseString:(NSString *)str intoNSInteger:(NSInteger *)pNum +{ + if(str == nil) + { + *pNum = 0; + return NO; + } + + errno = 0; + + // On LP64, NSInteger = long = 64 bit + // Otherwise, NSInteger = int = long = 32 bit + + *pNum = strtol([str UTF8String], NULL, 10); + + if(errno != 0) + return NO; + else + return YES; +} + ++ (BOOL)parseString:(NSString *)str intoNSUInteger:(NSUInteger *)pNum +{ + if(str == nil) + { + *pNum = 0; + return NO; + } + + errno = 0; + + // On LP64, NSUInteger = unsigned long = 64 bit + // Otherwise, NSUInteger = unsigned int = unsigned long = 32 bit + + *pNum = strtoul([str UTF8String], NULL, 10); + + if(errno != 0) + return NO; + else + return YES; +} + ++ (UInt8)extractUInt8FromData:(NSData *)data atOffset:(unsigned int)offset +{ + // 8 bits = 1 byte + + if([data length] < offset + 1) return 0; + + UInt8 *pResult = (UInt8 *)([data bytes] + offset); + UInt8 result = *pResult; + + return result; +} + ++ (UInt16)extractUInt16FromData:(NSData *)data atOffset:(unsigned int)offset andConvertFromNetworkOrder:(BOOL)flag +{ + // 16 bits = 2 bytes + + if([data length] < offset + 2) return 0; + + UInt16 *pResult = (UInt16 *)([data bytes] + offset); + UInt16 result = *pResult; + + if(flag) + return ntohs(result); + else + return result; +} + ++ (UInt32)extractUInt32FromData:(NSData *)data atOffset:(unsigned int)offset andConvertFromNetworkOrder:(BOOL)flag +{ + // 32 bits = 4 bytes + + if([data length] < offset + 4) return 0; + + UInt32 *pResult = (UInt32 *)([data bytes] + offset); + UInt32 result = *pResult; + + if(flag) + return ntohl(result); + else + return result; +} + +@end diff --git a/xmpp/Categories/NSXMLElement+XMPP.h b/xmpp/Categories/NSXMLElement+XMPP.h new file mode 100644 index 0000000..66831e3 --- /dev/null +++ b/xmpp/Categories/NSXMLElement+XMPP.h @@ -0,0 +1,47 @@ +#import + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + + +@interface NSXMLElement (XMPP) + ++ (NSXMLElement *)elementWithName:(NSString *)name xmlns:(NSString *)ns; +- (id)initWithName:(NSString *)name xmlns:(NSString *)ns; + +- (NSXMLElement *)elementForName:(NSString *)name; +- (NSXMLElement *)elementForName:(NSString *)name xmlns:(NSString *)xmlns; + +- (NSString *)xmlns; +- (void)setXmlns:(NSString *)ns; + +- (NSString *)prettyXMLString; +- (NSString *)compactXMLString; + +- (void)addAttributeWithName:(NSString *)name stringValue:(NSString *)string; + +- (int)attributeIntValueForName:(NSString *)name; +- (BOOL)attributeBoolValueForName:(NSString *)name; +- (float)attributeFloatValueForName:(NSString *)name; +- (double)attributeDoubleValueForName:(NSString *)name; +- (NSString *)attributeStringValueForName:(NSString *)name; +- (NSNumber *)attributeNumberIntValueForName:(NSString *)name; +- (NSNumber *)attributeNumberBoolValueForName:(NSString *)name; + +- (int)attributeIntValueForName:(NSString *)name withDefaultValue:(int)defaultValue; +- (BOOL)attributeBoolValueForName:(NSString *)name withDefaultValue:(BOOL)defaultValue; +- (float)attributeFloatValueForName:(NSString *)name withDefaultValue:(float)defaultValue; +- (double)attributeDoubleValueForName:(NSString *)name withDefaultValue:(double)defaultValue; +- (NSString *)attributeStringValueForName:(NSString *)name withDefaultValue:(NSString *)defaultValue; +- (NSNumber *)attributeNumberIntValueForName:(NSString *)name withDefaultValue:(int)defaultValue; +- (NSNumber *)attributeNumberBoolValueForName:(NSString *)name withDefaultValue:(BOOL)defaultValue; + +- (NSMutableDictionary *)attributesAsDictionary; + +- (void)addNamespaceWithPrefix:(NSString *)prefix stringValue:(NSString *)string; + +- (NSString *)namespaceStringValueForPrefix:(NSString *)prefix; +- (NSString *)namespaceStringValueForPrefix:(NSString *)prefix withDefaultValue:(NSString *)defaultValue; + +@end diff --git a/xmpp/Categories/NSXMLElement+XMPP.m b/xmpp/Categories/NSXMLElement+XMPP.m new file mode 100644 index 0000000..416730a --- /dev/null +++ b/xmpp/Categories/NSXMLElement+XMPP.m @@ -0,0 +1,231 @@ +#import "NSXMLElement+XMPP.h" + +@implementation NSXMLElement (XMPP) + +/** + * Quick method to create an element +**/ ++ (NSXMLElement *)elementWithName:(NSString *)name xmlns:(NSString *)ns +{ + NSXMLElement *element = [NSXMLElement elementWithName:name]; + [element setXmlns:ns]; + return element; +} + +- (id)initWithName:(NSString *)name xmlns:(NSString *)ns +{ + if ([self initWithName:name]) + { + [self setXmlns:ns]; + } + return self; +} + +/** + * This method returns the first child element for the given name (as an NSXMLElement). + * If no child elements exist for the given name, nil is returned. +**/ +- (NSXMLElement *)elementForName:(NSString *)name +{ + NSArray *elements = [self elementsForName:name]; + if([elements count] > 0) + { + return [elements objectAtIndex:0]; + } + else + { + // There is a bug in the NSXMLElement elementsForName: method. + // Consider the following XML fragment: + // + // + // + // + // + // Calling [query elementsForName:@"x"] results in an empty array! + // + // However, it will work properly if you use the following: + // [query elementsForLocalName:@"x" URI:@"some:other:namespace"] + // + // The trouble with this is that we may not always know the xmlns in advance, + // so in this particular case there is no way to access the element without looping through the children. + // + // This bug was submitted to apple on June 1st, 2007 and was classified as "serious". + // + // --!!-- This bug does NOT exist in DDXML --!!-- + + return nil; + } +} + +/** + * This method returns the first child element for the given name and given xmlns (as an NSXMLElement). + * If no child elements exist for the given name and given xmlns, nil is returned. +**/ +- (NSXMLElement *)elementForName:(NSString *)name xmlns:(NSString *)xmlns +{ + NSArray *elements = [self elementsForLocalName:name URI:xmlns]; + if([elements count] > 0) + { + return [elements objectAtIndex:0]; + } + else + { + return nil; + } +} + +/** + * Returns the common xmlns "attribute", which is only accessible via the namespace methods. + * The xmlns value is often used in jabber elements. +**/ +- (NSString *)xmlns +{ + return [[self namespaceForPrefix:@""] stringValue]; +} + +- (void)setXmlns:(NSString *)ns +{ + // If we use setURI: then the xmlns won't be displayed in the XMLString. + // Adding the namespace this way works properly. + + [self addNamespace:[NSXMLNode namespaceWithName:@"" stringValue:ns]]; +} + +/** + * Shortcut to get a pretty (formatted) string representation of the element. +**/ +- (NSString *)prettyXMLString +{ + return [self XMLStringWithOptions:(NSXMLNodePrettyPrint | NSXMLNodeCompactEmptyElement)]; +} + +/** + * Shortcut to get a compact string representation of the element. +**/ +- (NSString *)compactXMLString +{ + return [self XMLStringWithOptions:NSXMLNodeCompactEmptyElement]; +} + +/** + * Shortcut to avoid having to use NSXMLNode everytime +**/ +- (void)addAttributeWithName:(NSString *)name stringValue:(NSString *)string +{ + [self addAttribute:[NSXMLNode attributeWithName:name stringValue:string]]; +} + +/** + * The following methods return the corresponding value of the attribute with the given name. +**/ + +- (int)attributeIntValueForName:(NSString *)name +{ + return [[self attributeStringValueForName:name] intValue]; +} +- (BOOL)attributeBoolValueForName:(NSString *)name +{ + return [[self attributeStringValueForName:name] boolValue]; +} +- (float)attributeFloatValueForName:(NSString *)name +{ + return [[self attributeStringValueForName:name] floatValue]; +} +- (double)attributeDoubleValueForName:(NSString *)name +{ + return [[self attributeStringValueForName:name] doubleValue]; +} +- (NSString *)attributeStringValueForName:(NSString *)name +{ + return [[self attributeForName:name] stringValue]; +} +- (NSNumber *)attributeNumberIntValueForName:(NSString *)name +{ + return [NSNumber numberWithInt:[self attributeIntValueForName:name]]; +} +- (NSNumber *)attributeNumberBoolValueForName:(NSString *)name +{ + return [NSNumber numberWithBool:[self attributeBoolValueForName:name]]; +} + +/** + * The following methods return the corresponding value of the attribute with the given name. + * If the attribute does not exist, the given defaultValue is returned. +**/ + +- (int)attributeIntValueForName:(NSString *)name withDefaultValue:(int)defaultValue +{ + NSXMLNode *attr = [self attributeForName:name]; + return (attr) ? [[attr stringValue] intValue] : defaultValue; +} +- (BOOL)attributeBoolValueForName:(NSString *)name withDefaultValue:(BOOL)defaultValue +{ + NSXMLNode *attr = [self attributeForName:name]; + return (attr) ? [[attr stringValue] boolValue] : defaultValue; +} +- (float)attributeFloatValueForName:(NSString *)name withDefaultValue:(float)defaultValue +{ + NSXMLNode *attr = [self attributeForName:name]; + return (attr) ? [[attr stringValue] floatValue] : defaultValue; +} +- (double)attributeDoubleValueForName:(NSString *)name withDefaultValue:(double)defaultValue +{ + NSXMLNode *attr = [self attributeForName:name]; + return (attr) ? [[attr stringValue] doubleValue] : defaultValue; +} +- (NSString *)attributeStringValueForName:(NSString *)name withDefaultValue:(NSString *)defaultValue +{ + NSXMLNode *attr = [self attributeForName:name]; + return (attr) ? [attr stringValue] : defaultValue; +} +- (NSNumber *)attributeNumberIntValueForName:(NSString *)name withDefaultValue:(int)defaultValue +{ + return [NSNumber numberWithInt:[self attributeIntValueForName:name withDefaultValue:defaultValue]]; +} +- (NSNumber *)attributeNumberBoolValueForName:(NSString *)name withDefaultValue:(BOOL)defaultValue +{ + return [NSNumber numberWithBool:[self attributeBoolValueForName:name withDefaultValue:defaultValue]]; +} + +/** + * Returns all the attributes in a dictionary. +**/ +- (NSMutableDictionary *)attributesAsDictionary +{ + NSArray *attributes = [self attributes]; + NSMutableDictionary *result = [NSMutableDictionary dictionaryWithCapacity:[attributes count]]; + + NSUInteger i; + for(i = 0; i < [attributes count]; i++) + { + NSXMLNode *node = [attributes objectAtIndex:i]; + + [result setObject:[node stringValue] forKey:[node name]]; + } + return result; +} + +/** + * Shortcut to avoid having to use NSXMLNode everytime +**/ +- (void)addNamespaceWithPrefix:(NSString *)prefix stringValue:(NSString *)string +{ + [self addNamespace:[NSXMLNode namespaceWithName:prefix stringValue:string]]; +} + +/** + * Just to make your code look a little bit cleaner. +**/ + +- (NSString *)namespaceStringValueForPrefix:(NSString *)prefix +{ + return [[self namespaceForPrefix:prefix] stringValue]; +} + +- (NSString *)namespaceStringValueForPrefix:(NSString *)prefix withDefaultValue:(NSString *)defaultValue +{ + NSXMLNode *namespace = [self namespaceForPrefix:prefix]; + return (namespace) ? [namespace stringValue] : defaultValue; +} + +@end diff --git a/xmpp/Core/XMPP.h b/xmpp/Core/XMPP.h new file mode 100644 index 0000000..8bba54c --- /dev/null +++ b/xmpp/Core/XMPP.h @@ -0,0 +1,9 @@ +#import "XMPPJID.h" +#import "XMPPStream.h" +#import "XMPPElement.h" +#import "XMPPIQ.h" +#import "XMPPMessage.h" +#import "XMPPPresence.h" +#import "XMPPModule.h" + +#import "NSXMLElement+XMPP.h" diff --git a/xmpp/Core/XMPPElement.h b/xmpp/Core/XMPPElement.h new file mode 100644 index 0000000..1f1f47b --- /dev/null +++ b/xmpp/Core/XMPPElement.h @@ -0,0 +1,28 @@ +#import + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPJID; + +/** + * The XMPPElement provides the base class for XMPPIQ, XMPPMessage & XMPPPresence. + * + * This class extends NSXMLElement. + * The NSXML classes (NSXMLElement & NSXMLNode) provide a full-featured library for working with XML elements. + * + * On the iPhone, the KissXML library provides a drop-in replacement for Apple's NSXML classes. +**/ + +@interface XMPPElement : NSXMLElement + +- (NSString *)elementID; + +- (XMPPJID *)to; +- (XMPPJID *)from; + +- (NSString *)toStr; +- (NSString *)fromStr; + +@end diff --git a/xmpp/Core/XMPPElement.m b/xmpp/Core/XMPPElement.m new file mode 100644 index 0000000..498e6e5 --- /dev/null +++ b/xmpp/Core/XMPPElement.m @@ -0,0 +1,80 @@ +#import "XMPPElement.h" +#import "XMPPJID.h" +#import "NSXMLElement+XMPP.h" + + +@implementation XMPPElement + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Encoding, Decoding +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if ! TARGET_OS_IPHONE +- (id)replacementObjectForPortCoder:(NSPortCoder *)encoder +{ + if([encoder isBycopy]) + return self; + else + return [NSDistantObject proxyWithLocal:self connection:[encoder connection]]; +} +#endif + +- (id)initWithCoder:(NSCoder *)coder +{ + NSString *xmlString; + if([coder allowsKeyedCoding]) + { + xmlString = [coder decodeObjectForKey:@"xmlString"]; + } + else + { + xmlString = [coder decodeObject]; + } + + return [super initWithXMLString:xmlString error:nil]; +} + +- (void)encodeWithCoder:(NSCoder *)coder +{ + NSString *xmlString = [self compactXMLString]; + + if([coder allowsKeyedCoding]) + { + [coder encodeObject:xmlString forKey:@"xmlString"]; + } + else + { + [coder encodeObject:xmlString]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Common Jabber Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)elementID +{ + return [[self attributeForName:@"id"] stringValue]; +} + +- (NSString *)toStr +{ + return [[self attributeForName:@"to"] stringValue]; +} + +- (NSString *)fromStr +{ + return [[self attributeForName:@"from"] stringValue]; +} + +- (XMPPJID *)to +{ + return [XMPPJID jidWithString:[self toStr]]; +} + +- (XMPPJID *)from +{ + return [XMPPJID jidWithString:[self fromStr]]; +} + +@end diff --git a/xmpp/Core/XMPPIQ.h b/xmpp/Core/XMPPIQ.h new file mode 100644 index 0000000..375d08f --- /dev/null +++ b/xmpp/Core/XMPPIQ.h @@ -0,0 +1,75 @@ +#import +#import "XMPPElement.h" + +/** + * The XMPPIQ class represents an element. + * It extends XMPPElement, which in turn extends NSXMLElement. + * All elements that go in and out of the + * xmpp stream will automatically be converted to XMPPIQ objects. + * + * This class exists to provide developers an easy way to add functionality to IQ processing. + * Simply add your own category to XMPPIQ to extend it with your own custom methods. +**/ + +@interface XMPPIQ : XMPPElement + +/** + * Converts an NSXMLElement to an XMPPIQ element in place (no memory allocations or copying) +**/ ++ (XMPPIQ *)iqFromElement:(NSXMLElement *)element; + +/** + * Creates and returns a new autoreleased XMPPIQ element. + * If the type or elementID parameters are nil, those attributes will not be added. +**/ ++ (XMPPIQ *)iq; ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid; ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid; ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid child:(NSXMLElement *)childElement; + +/** + * Creates and returns a new XMPPIQ element. + * If the type or elementID parameters are nil, those attributes will not be added. +**/ +- (id)init; +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid; +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid; +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid child:(NSXMLElement *)childElement; + +/** + * Returns the type attribute of the IQ. + * According to the XMPP protocol, the type should be one of 'get', 'set', 'result' or 'error'. + * + * This method converts the attribute to lowercase so + * case-sensitive string comparisons are safe (regardless of server treatment). +**/ +- (NSString *)type; + +/** + * Convenience methods for determining the IQ type. +**/ +- (BOOL)isGetIQ; +- (BOOL)isSetIQ; +- (BOOL)isResultIQ; +- (BOOL)isErrorIQ; + +/** + * Convenience method for determining if the IQ is of type 'get' or 'set'. +**/ +- (BOOL)requiresResponse; + +/** + * The XMPP RFC has various rules for the number of child elements an IQ is allowed to have: + * + * - An IQ stanza of type "get" or "set" MUST contain one and only one child element. + * - An IQ stanza of type "result" MUST include zero or one child elements. + * - An IQ stanza of type "error" SHOULD include the child element contained in the + * associated "get" or "set" and MUST include an child. + * + * The childElement returns the single non-error element, if one exists, or nil. + * The childErrorElement returns the error element, if one exists, or nil. +**/ +- (NSXMLElement *)childElement; +- (NSXMLElement *)childErrorElement; + +@end diff --git a/xmpp/Core/XMPPIQ.m b/xmpp/Core/XMPPIQ.m new file mode 100644 index 0000000..cac1e44 --- /dev/null +++ b/xmpp/Core/XMPPIQ.m @@ -0,0 +1,154 @@ +#import "XMPPIQ.h" +#import "XMPPJID.h" +#import "NSXMLElement+XMPP.h" + +#import + + +@implementation XMPPIQ + ++ (void)initialize +{ + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPIQ class]); + + if (superSize != ourSize) + { + NSLog(@"Adding instance variables to XMPPIQ is not currently supported!"); + exit(15); + } +} + ++ (XMPPIQ *)iqFromElement:(NSXMLElement *)element +{ + object_setClass(element, [XMPPIQ class]); + + return (XMPPIQ *)element; +} + ++ (XMPPIQ *)iq +{ + return [[[XMPPIQ alloc] initWithType:nil to:nil elementID:nil child:nil] autorelease]; +} + ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid +{ + return [[[XMPPIQ alloc] initWithType:type to:jid elementID:nil child:nil] autorelease]; +} + ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid +{ + return [[[XMPPIQ alloc] initWithType:type to:jid elementID:eid child:nil] autorelease]; +} + ++ (XMPPIQ *)iqWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid child:(NSXMLElement *)childElement +{ + return [[[XMPPIQ alloc] initWithType:type to:jid elementID:eid child:childElement] autorelease]; +} + +- (id)init +{ + return [self initWithType:nil to:nil elementID:nil child:nil]; +} + +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid +{ + return [self initWithType:type to:jid elementID:nil child:nil]; +} + +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid +{ + return [self initWithType:type to:jid elementID:eid child:nil]; +} + +- (id)initWithType:(NSString *)type to:(XMPPJID *)jid elementID:(NSString *)eid child:(NSXMLElement *)childElement +{ + if ((self = [super initWithName:@"iq"])) + { + if (type) + [self addAttributeWithName:@"type" stringValue:type]; + + if (jid) + [self addAttributeWithName:@"to" stringValue:[jid full]]; + + if (eid) + [self addAttributeWithName:@"id" stringValue:eid]; + + if (childElement) + [self addChild:childElement]; + } + return self; +} + +- (NSString *)type +{ + return [[self attributeStringValueForName:@"type"] lowercaseString]; +} + +- (BOOL)isGetIQ +{ + return [[self type] isEqualToString:@"get"]; +} + +- (BOOL)isSetIQ +{ + return [[self type] isEqualToString:@"set"]; +} + +- (BOOL)isResultIQ +{ + return [[self type] isEqualToString:@"result"]; +} + +- (BOOL)isErrorIQ +{ + return [[self type] isEqualToString:@"error"]; +} + +- (BOOL)requiresResponse +{ + // An entity that receives an IQ request of type "get" or "set" MUST reply with an IQ response + // of type "result" or "error" (the response MUST preserve the 'id' attribute of the request). + + return [self isGetIQ] || [self isSetIQ]; +} + +- (NSXMLElement *)childElement +{ + NSArray *children = [self children]; + for (NSXMLElement *child in children) + { + if ([[child name] caseInsensitiveCompare:@"error"] != NSOrderedSame) + { + return child; + } + } + + return nil; +} + +- (NSXMLElement *)childErrorElement +{ + NSArray *children = [self children]; + for (NSXMLElement *child in children) + { + if ([[child name] caseInsensitiveCompare:@"error"] == NSOrderedSame) + { + return child; + } + } + + return nil; +} + +@end diff --git a/xmpp/Core/XMPPInternal.h b/xmpp/Core/XMPPInternal.h new file mode 100644 index 0000000..5084872 --- /dev/null +++ b/xmpp/Core/XMPPInternal.h @@ -0,0 +1,49 @@ +// +// The following is for XMPPStream, +// and any classes that extend XMPPStream such as XMPPFacebookStream. +// + +// Define the various timeouts (in seconds) for retreiving various parts of the XML stream +#define TIMEOUT_XMPP_WRITE -1 +#define TIMEOUT_XMPP_READ_START 10 +#define TIMEOUT_XMPP_READ_STREAM -1 + +// Define the various tags we'll use to differentiate what it is we're currently reading or writing +#define TAG_XMPP_READ_START 100 +#define TAG_XMPP_READ_STREAM 101 +#define TAG_XMPP_WRITE_START 200 +#define TAG_XMPP_WRITE_STREAM 201 +#define TAG_XMPP_WRITE_RECEIPT 202 + +// Define the various states we'll use to track our progress +enum { + STATE_XMPP_DISCONNECTED, + STATE_XMPP_RESOLVING_SRV, + STATE_XMPP_CONNECTING, + STATE_XMPP_OPENING, + STATE_XMPP_NEGOTIATING, + STATE_XMPP_STARTTLS_1, + STATE_XMPP_STARTTLS_2, + STATE_XMPP_POST_NEGOTIATION, + STATE_XMPP_REGISTERING, + STATE_XMPP_AUTH_1, + STATE_XMPP_AUTH_2, + STATE_XMPP_AUTH_3, + STATE_XMPP_BINDING, + STATE_XMPP_START_SESSION, + STATE_XMPP_CONNECTED, +}; + +// +// It is recommended that storage classes cache a stream's myJID. +// This prevents them from constantly querying the property from the xmppStream instance, +// as doing so goes through xmppStream's dispatch queue. +// Caching the stream's myJID frees the dispatch queue to handle xmpp processing tasks. +// +// The object of the notification will be the XMPPStream instance. +// +// Note: We're not using the typical MulticastDelegate paradigm for this task as +// storage classes are not typically added as a delegate of the xmppStream. +// + +extern NSString *const XMPPStreamDidChangeMyJIDNotification; diff --git a/xmpp/Core/XMPPJID.h b/xmpp/Core/XMPPJID.h new file mode 100644 index 0000000..9e47517 --- /dev/null +++ b/xmpp/Core/XMPPJID.h @@ -0,0 +1,33 @@ +#import + + +@interface XMPPJID : NSObject +{ + NSString *user; + NSString *domain; + NSString *resource; +} + ++ (XMPPJID *)jidWithString:(NSString *)jidStr; ++ (XMPPJID *)jidWithString:(NSString *)jidStr resource:(NSString *)resource; ++ (XMPPJID *)jidWithUser:(NSString *)user domain:(NSString *)domain resource:(NSString *)resource; + +- (NSString *)user; +- (NSString *)domain; +- (NSString *)resource; + +- (XMPPJID *)bareJID; +- (XMPPJID *)domainJID; + +- (NSString *)bare; +- (NSString *)full; + +- (BOOL)isBare; +- (BOOL)isBareWithUser; + +- (BOOL)isFull; +- (BOOL)isFullWithUser; + +- (BOOL)isServer; + +@end diff --git a/xmpp/Core/XMPPJID.m b/xmpp/Core/XMPPJID.m new file mode 100644 index 0000000..5b6f535 --- /dev/null +++ b/xmpp/Core/XMPPJID.m @@ -0,0 +1,390 @@ +#import "XMPPJID.h" +#import "LibIDN.h" + +@implementation XMPPJID + ++ (BOOL)validateDomain:(NSString *)domain +{ + // Domain is the only required part of a JID + if ((domain == nil) || ([domain length] == 0)) + return NO; + + // If there's an @ symbol in the domain it probably means user put @ in their username + NSRange invalidAtRange = [domain rangeOfString:@"@"]; + if (invalidAtRange.location != NSNotFound) + return NO; + + return YES; +} + ++ (BOOL)validateResource:(NSString *)resource +{ + // Can't use an empty string resource name + if ((resource != nil) && ([resource length] == 0)) + return NO; + + return YES; +} + ++ (BOOL)validateUser:(NSString *)user domain:(NSString *)domain resource:(NSString *)resource +{ + if (![self validateDomain:domain]) + return NO; + + if (![self validateResource:resource]) + return NO; + + return YES; +} + ++ (BOOL)parse:(NSString *)jidStr + outUser:(NSString **)user + outDomain:(NSString **)domain + outResource:(NSString **)resource +{ + if(user) *user = nil; + if(domain) *domain = nil; + if(resource) *resource = nil; + + if(jidStr == nil) return NO; + + NSString *rawUser = nil; + NSString *rawDomain = nil; + NSString *rawResource = nil; + + NSRange atRange = [jidStr rangeOfString:@"@"]; + + if(atRange.location != NSNotFound) + { + rawUser = [jidStr substringToIndex:atRange.location]; + + NSString *minusUser = [jidStr substringFromIndex:atRange.location+1]; + + NSRange slashRange = [minusUser rangeOfString:@"/"]; + + if(slashRange.location != NSNotFound) + { + rawDomain = [minusUser substringToIndex:slashRange.location]; + rawResource = [minusUser substringFromIndex:slashRange.location+1]; + } + else + { + rawDomain = minusUser; + } + } + else + { + NSRange slashRange = [jidStr rangeOfString:@"/"]; + + if(slashRange.location != NSNotFound) + { + rawDomain = [jidStr substringToIndex:slashRange.location]; + rawResource = [jidStr substringFromIndex:slashRange.location+1]; + } + else + { + rawDomain = jidStr; + } + } + + NSString *prepUser = [LibIDN prepNode:rawUser]; + NSString *prepDomain = [LibIDN prepDomain:rawDomain]; + NSString *prepResource = [LibIDN prepResource:rawResource]; + + if([XMPPJID validateUser:prepUser domain:prepDomain resource:prepResource]) + { + if(user) *user = prepUser; + if(domain) *domain = prepDomain; + if(resource) *resource = prepResource; + + return YES; + } + + return NO; +} + ++ (XMPPJID *)jidWithString:(NSString *)jidStr +{ + NSString *user; + NSString *domain; + NSString *resource; + + if([XMPPJID parse:jidStr outUser:&user outDomain:&domain outResource:&resource]) + { + XMPPJID *jid = [[XMPPJID alloc] init]; + jid->user = [user copy]; + jid->domain = [domain copy]; + jid->resource = [resource copy]; + + return [jid autorelease]; + } + + return nil; +} + ++ (XMPPJID *)jidWithString:(NSString *)jidStr resource:(NSString *)resource +{ + if(![self validateResource:resource]) return nil; + + NSString *user; + NSString *domain; + + if([XMPPJID parse:jidStr outUser:&user outDomain:&domain outResource:nil]) + { + XMPPJID *jid = [[XMPPJID alloc] init]; + jid->user = [user copy]; + jid->domain = [domain copy]; + jid->resource = [resource copy]; + + return [jid autorelease]; + } + + return nil; +} + ++ (XMPPJID *)jidWithUser:(NSString *)user domain:(NSString *)domain resource:(NSString *)resource +{ + NSString *prepUser = [LibIDN prepNode:user]; + NSString *prepDomain = [LibIDN prepDomain:domain]; + NSString *prepResource = [LibIDN prepResource:resource]; + + if([XMPPJID validateUser:prepUser domain:prepDomain resource:prepResource]) + { + XMPPJID *jid = [[XMPPJID alloc] init]; + jid->user = [prepUser copy]; + jid->domain = [prepDomain copy]; + jid->resource = [prepResource copy]; + + return [jid autorelease]; + } + + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Encoding, Decoding: +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if ! TARGET_OS_IPHONE +- (id)replacementObjectForPortCoder:(NSPortCoder *)encoder +{ + if([encoder isBycopy]) + return self; + else + return [NSDistantObject proxyWithLocal:self connection:[encoder connection]]; +} +#endif + +- (id)initWithCoder:(NSCoder *)coder +{ + if((self = [super init])) + { + if([coder allowsKeyedCoding]) + { + user = [[coder decodeObjectForKey:@"user"] copy]; + domain = [[coder decodeObjectForKey:@"domain"] copy]; + resource = [[coder decodeObjectForKey:@"resource"] copy]; + } + else + { + user = [[coder decodeObject] copy]; + domain = [[coder decodeObject] copy]; + resource = [[coder decodeObject] copy]; + } + } + return self; +} + +- (void)encodeWithCoder:(NSCoder *)coder +{ + if([coder allowsKeyedCoding]) + { + [coder encodeObject:user forKey:@"user"]; + [coder encodeObject:domain forKey:@"domain"]; + [coder encodeObject:resource forKey:@"resource"]; + } + else + { + [coder encodeObject:user]; + [coder encodeObject:domain]; + [coder encodeObject:resource]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Copying: +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)copyWithZone:(NSZone *)zone +{ + // This class is immutable + return [self retain]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Normal Methods: +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)user +{ + return user; +} + +- (NSString *)domain +{ + return domain; +} + +- (NSString *)resource +{ + return resource; +} + +- (XMPPJID *)bareJID +{ + if(resource == nil) + { + return [[self retain] autorelease]; + } + else + { + return [XMPPJID jidWithUser:user domain:domain resource:nil]; + } +} + +- (XMPPJID *)domainJID +{ + if(user == nil && resource == nil) + { + return [[self retain] autorelease]; + } + else + { + return [XMPPJID jidWithUser:nil domain:domain resource:nil]; + } +} + +- (NSString *)bare +{ + if(user) + return [NSString stringWithFormat:@"%@@%@", user, domain]; + else + return domain; +} + +- (NSString *)full +{ + if(user) + { + if(resource) + return [NSString stringWithFormat:@"%@@%@/%@", user, domain, resource]; + else + return [NSString stringWithFormat:@"%@@%@", user, domain]; + } + else + { + if(resource) + return [NSString stringWithFormat:@"%@/%@", domain, resource]; + else + return domain; + } +} + +- (BOOL)isBare +{ + // From RFC 6120 Terminology: + // + // The term "bare JID" refers to an XMPP address of the form (for an account at a server) + // or of the form (for a server). + + return (resource == nil); +} + +- (BOOL)isBareWithUser +{ + return (user != nil && resource == nil); +} + +- (BOOL)isFull +{ + // From RFC 6120 Terminology: + // + // The term "full JID" refers to an XMPP address of the form + // (for a particular authorized client or device associated with an account) + // or of the form (for a particular resource or script associated with a server). + + return (resource != nil); +} + +- (BOOL)isFullWithUser +{ + return (user != nil && resource != nil); +} + +- (BOOL)isServer +{ + return (user == nil); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark NSObject Methods: +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4 +- (unsigned)hash +{ + return [[self full] hash]; +} +#else +- (NSUInteger)hash +{ + return [[self full] hash]; +} +#endif + +- (BOOL)isEqual:(id)anObject +{ + if ([anObject isMemberOfClass:[self class]]) + { + XMPPJID *aJID = (XMPPJID *)anObject; + + if (user) { + if (![user isEqualToString:aJID->user]) return NO; + } + else { + if (aJID->user) return NO; + } + + if (domain) { + if (![domain isEqualToString:aJID->domain]) return NO; + } + else { + if (aJID->domain) return NO; + } + + if (resource) { + if (![resource isEqualToString:aJID->resource]) return NO; + } + else { + if (aJID->resource) return NO; + } + + return YES; + } + return NO; +} + +- (NSString *)description +{ + return [self full]; +} + +- (void)dealloc +{ + [user release]; + [domain release]; + [resource release]; + [super dealloc]; +} + +@end diff --git a/xmpp/Core/XMPPLogging.h b/xmpp/Core/XMPPLogging.h new file mode 100644 index 0000000..d995b6e --- /dev/null +++ b/xmpp/Core/XMPPLogging.h @@ -0,0 +1,174 @@ +/** + * In order to provide fast and flexible logging, this project uses Cocoa Lumberjack. + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * Here's what you need to know concerning how logging is setup for XMPPFramework: + * + * There are 4 log levels: + * - Error + * - Warning + * - Info + * - Verbose + * + * In addition to this, there is a Trace flag that can be enabled. + * When tracing is enabled, it spits out the methods that are being called. + * + * Please note that tracing is separate from the log levels. + * For example, one could set the log level to warning, and enable tracing. + * + * All logging is asynchronous, except errors. + * To use logging within your own custom files, follow the steps below. + * + * Step 1: + * Import this header in your implementation file: + * + * #import "XMPPLogging.h" + * + * Step 2: + * Define your logging level in your implementation file: + * + * // Log levels: off, error, warn, info, verbose + * static const int xmppLogLevel = XMPP_LOG_LEVEL_VERBOSE; + * + * If you wish to enable tracing, you could do something like this: + * + * // Log levels: off, error, warn, info, verbose + * static const int xmppLogLevel = XMPP_LOG_LEVEL_INFO | XMPP_LOG_FLAG_TRACE; + * + * Step 3: + * Replace your NSLog statements with XMPPLog statements according to the severity of the message. + * + * NSLog(@"Fatal error, no dohickey found!"); -> XMPPLogError(@"Fatal error, no dohickey found!"); + * + * XMPPLog has the same syntax as NSLog. + * This means you can pass it multiple variables just like NSLog. + * + * You may optionally choose to define different log levels for debug and release builds. + * You can do so like this: + * + * // Log levels: off, error, warn, info, verbose + * #if DEBUG + * static const int xmppLogLevel = XMPP_LOG_LEVEL_VERBOSE; + * #else + * static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; + * #endif + * + * Xcode projects created with Xcode 4 automatically define DEBUG via the project's preprocessor macros. + * If you created your project with a previous version of Xcode, you may need to add the DEBUG macro manually. +**/ + +#import "DDLog.h" + +// Define logging context for every log message coming from the XMPP framework. +// The logging context can be extracted from the DDLogMessage from within the logging framework. +// This gives loggers, formatters, and filters the ability to optionally process them differently. + +#define XMPP_LOG_CONTEXT 5222 + +// Configure log levels. + +#define XMPP_LOG_FLAG_ERROR (1 << 0) // 0...00001 +#define XMPP_LOG_FLAG_WARN (1 << 1) // 0...00010 +#define XMPP_LOG_FLAG_INFO (1 << 2) // 0...00100 +#define XMPP_LOG_FLAG_VERBOSE (1 << 3) // 0...01000 + +#define XMPP_LOG_LEVEL_OFF 0 // 0...00000 +#define XMPP_LOG_LEVEL_ERROR (XMPP_LOG_LEVEL_OFF | XMPP_LOG_FLAG_ERROR) // 0...00001 +#define XMPP_LOG_LEVEL_WARN (XMPP_LOG_LEVEL_ERROR | XMPP_LOG_FLAG_WARN) // 0...00011 +#define XMPP_LOG_LEVEL_INFO (XMPP_LOG_LEVEL_WARN | XMPP_LOG_FLAG_INFO) // 0...00111 +#define XMPP_LOG_LEVEL_VERBOSE (XMPP_LOG_LEVEL_INFO | XMPP_LOG_FLAG_VERBOSE) // 0...01111 + +// Setup fine grained logging. +// The first 4 bits are being used by the standard log levels (0 - 3) +// +// We're going to add tracing, but NOT as a log level. +// Tracing can be turned on and off independently of log level. + +#define XMPP_LOG_FLAG_TRACE (1 << 4) // 0...10000 + + +// Setup the usual boolean macros. + +#define XMPP_LOG_ERROR (xmppLogLevel & XMPP_LOG_FLAG_ERROR) +#define XMPP_LOG_WARN (xmppLogLevel & XMPP_LOG_FLAG_WARN) +#define XMPP_LOG_INFO (xmppLogLevel & XMPP_LOG_FLAG_INFO) +#define XMPP_LOG_VERBOSE (xmppLogLevel & XMPP_LOG_FLAG_VERBOSE) +#define XMPP_LOG_TRACE (xmppLogLevel & XMPP_LOG_FLAG_TRACE) + +// Configure asynchronous logging. +// We follow the default configuration, +// but we reserve a special macro to easily disable asynchronous logging for debugging purposes. + +#define XMPP_LOG_ASYNC_ENABLED YES + +#define XMPP_LOG_ASYNC_ERROR ( NO && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_WARN (YES && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_INFO (YES && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_VERBOSE (YES && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_TRACE (YES && XMPP_LOG_ASYNC_ENABLED) + +// Define logging primitives. + +#define XMPPLogError(frmt, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_ERROR, xmppLogLevel, XMPP_LOG_FLAG_ERROR, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogWarn(frmt, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_WARN, xmppLogLevel, XMPP_LOG_FLAG_WARN, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogInfo(frmt, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_INFO, xmppLogLevel, XMPP_LOG_FLAG_INFO, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogVerbose(frmt, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_VERBOSE, xmppLogLevel, XMPP_LOG_FLAG_VERBOSE, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogTrace() LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_TRACE, xmppLogLevel, XMPP_LOG_FLAG_TRACE, \ + XMPP_LOG_CONTEXT, @"%@: %@", THIS_FILE, THIS_METHOD) + +#define XMPPLogTrace2(frmt, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_TRACE, xmppLogLevel, XMPP_LOG_FLAG_TRACE, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + + +#define XMPPLogCError(frmt, ...) LOG_C_MAYBE(XMPP_LOG_ASYNC_ERROR, xmppLogLevel, XMPP_LOG_FLAG_ERROR, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogCWarn(frmt, ...) LOG_C_MAYBE(XMPP_LOG_ASYNC_WARN, xmppLogLevel, XMPP_LOG_FLAG_WARN, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogCInfo(frmt, ...) LOG_C_MAYBE(XMPP_LOG_ASYNC_INFO, xmppLogLevel, XMPP_LOG_FLAG_INFO, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogCVerbose(frmt, ...) LOG_C_MAYBE(XMPP_LOG_ASYNC_VERBOSE, xmppLogLevel, XMPP_LOG_FLAG_VERBOSE, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +#define XMPPLogCTrace() LOG_C_MAYBE(XMPP_LOG_ASYNC_TRACE, xmppLogLevel, XMPP_LOG_FLAG_TRACE, \ + XMPP_LOG_CONTEXT, @"%@: %s", THIS_FILE, __FUNCTION__) + +#define XMPPLogCTrace2(frmt, ...) LOG_C_MAYBE(XMPP_LOG_ASYNC_TRACE, xmppLogLevel, XMPP_LOG_FLAG_TRACE, \ + XMPP_LOG_CONTEXT, frmt, ##__VA_ARGS__) + +// Setup logging for XMPPStream (and subclasses such as XMPPStreamFacebook) + +#define XMPP_LOG_FLAG_SEND (1 << 5) +#define XMPP_LOG_FLAG_RECV_PRE (1 << 6) // Prints data before it goes to the parser +#define XMPP_LOG_FLAG_RECV_POST (1 << 7) // Prints data as it comes out of the parser + +#define XMPP_LOG_FLAG_SEND_RECV (XMPP_LOG_FLAG_SEND | XMPP_LOG_FLAG_RECV_POST) + +#define XMPP_LOG_SEND (xmppLogLevel & XMPP_LOG_FLAG_SEND) +#define XMPP_LOG_RECV_PRE (xmppLogLevel & XMPP_LOG_FLAG_RECV_PRE) +#define XMPP_LOG_RECV_POST (xmppLogLevel & XMPP_LOG_FLAG_RECV_POST) + +#define XMPP_LOG_ASYNC_SEND (YES && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_RECV_PRE (YES && XMPP_LOG_ASYNC_ENABLED) +#define XMPP_LOG_ASYNC_RECV_POST (YES && XMPP_LOG_ASYNC_ENABLED) + +#define XMPPLogSend(format, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_SEND, xmppLogLevel, XMPP_LOG_FLAG_SEND, \ + XMPP_LOG_CONTEXT, format, ##__VA_ARGS__) + +#define XMPPLogRecvPre(format, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_RECV_PRE, xmppLogLevel, XMPP_LOG_FLAG_RECV_PRE, \ + XMPP_LOG_CONTEXT, format, ##__VA_ARGS__) + +#define XMPPLogRecvPost(format, ...) LOG_OBJC_MAYBE(XMPP_LOG_ASYNC_RECV_POST, xmppLogLevel, XMPP_LOG_FLAG_RECV_POST, \ + XMPP_LOG_CONTEXT, format, ##__VA_ARGS__) diff --git a/xmpp/Core/XMPPMessage.h b/xmpp/Core/XMPPMessage.h new file mode 100644 index 0000000..be91a64 --- /dev/null +++ b/xmpp/Core/XMPPMessage.h @@ -0,0 +1,35 @@ +#import +#import "XMPPElement.h" + +/** + * The XMPPMessage class represents a element. + * It extends XMPPElement, which in turn extends NSXMLElement. + * All elements that go in and out of the + * xmpp stream will automatically be converted to XMPPMessage objects. + * + * This class exists to provide developers an easy way to add functionality to message processing. + * Simply add your own category to XMPPMessage to extend it with your own custom methods. +**/ + +@interface XMPPMessage : XMPPElement + +// Converts an NSXMLElement to an XMPPMessage element in place (no memory allocations or copying) ++ (XMPPMessage *)messageFromElement:(NSXMLElement *)element; + ++ (XMPPMessage *)message; + +- (id)init; + +- (BOOL)isChatMessage; +- (BOOL)isChatMessageWithBody; +- (BOOL)isErrorMessage; +- (BOOL)isMessageWithBody; + +- (BOOL)hasReceiptRequest; +- (BOOL)hasReceiptResponse; +- (NSString *)extractReceiptResponseID; +- (XMPPMessage *)generateReceiptResponse; + +- (NSError *)errorMessage; + +@end diff --git a/xmpp/Core/XMPPMessage.m b/xmpp/Core/XMPPMessage.m new file mode 100644 index 0000000..5827f18 --- /dev/null +++ b/xmpp/Core/XMPPMessage.m @@ -0,0 +1,141 @@ +#import "XMPPMessage.h" +#import "XMPPJID.h" +#import "NSXMLElement+XMPP.h" + +#import + + +@implementation XMPPMessage + ++ (void)initialize +{ + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPMessage class]); + + if (superSize != ourSize) + { + NSLog(@"Adding instance variables to XMPPMessage is not currently supported!"); + exit(15); + } +} + ++ (XMPPMessage *)messageFromElement:(NSXMLElement *)element +{ + object_setClass(element, [XMPPMessage class]); + + return (XMPPMessage *)element; +} + ++ (XMPPMessage *)message +{ + return [[[XMPPMessage alloc] init] autorelease]; +} + +- (id)init +{ + self = [super initWithName:@"message"]; + return self; +} + +- (BOOL)isChatMessage +{ + return [[[self attributeForName:@"type"] stringValue] isEqualToString:@"chat"]; +} + +- (BOOL)isChatMessageWithBody +{ + if([self isChatMessage]) + { + return [self isMessageWithBody]; + } + + return NO; +} + +- (BOOL)isErrorMessage { + return [[[self attributeForName:@"type"] stringValue] isEqualToString:@"error"]; +} + +- (NSError *)errorMessage { + if (![self isErrorMessage]) { + return nil; + } + + NSXMLElement *error = [self elementForName:@"error"]; + return [NSError errorWithDomain:@"urn:ietf:params:xml:ns:xmpp-stanzas" + code:[error attributeIntValueForName:@"code"] + userInfo:[NSDictionary dictionaryWithObject:[error compactXMLString] forKey:NSLocalizedDescriptionKey]]; + +} + +- (BOOL)isMessageWithBody { + NSString *body = [[self elementForName:@"body"] stringValue]; + + return ((body != nil) && ([body length] > 0)); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XEP-0184: Message Receipts +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)hasReceiptRequest +{ + NSXMLElement *receiptRequest = [self elementForName:@"request" xmlns:@"urn:xmpp:receipts"]; + + return (receiptRequest != nil); +} + +- (BOOL)hasReceiptResponse +{ + NSXMLElement *receiptResponse = [self elementForName:@"received" xmlns:@"urn:xmpp:receipts"]; + + return (receiptResponse != nil); +} + +- (NSString *)extractReceiptResponseID +{ + NSXMLElement *receiptResponse = [self elementForName:@"received" xmlns:@"urn:xmpp:receipts"]; + + return [receiptResponse attributeStringValueForName:@"id"]; +} + +- (XMPPMessage *)generateReceiptResponse +{ + // Example: + // + // + // + // + + NSXMLElement *received = [NSXMLElement elementWithName:@"received" xmlns:@"urn:xmpp:receipts"]; + + NSXMLElement *message = [NSXMLElement elementWithName:@"message"]; + + NSString *to = [self fromStr]; + if(to) + { + [message addAttributeWithName:@"to" stringValue:to]; + } + + NSString *msgid = [self elementID]; + if(msgid) + { + [received addAttributeWithName:@"id" stringValue:msgid]; + } + + [message addChild:received]; + + return [[self class] messageFromElement:message]; +} + +@end diff --git a/xmpp/Core/XMPPModule.h b/xmpp/Core/XMPPModule.h new file mode 100644 index 0000000..3c6b1bd --- /dev/null +++ b/xmpp/Core/XMPPModule.h @@ -0,0 +1,39 @@ +#import +#import "GCDMulticastDelegate.h" + +@class XMPPStream; + +/** + * XMPPModule is the base class that all extensions/modules inherit. + * They automatically get: + * + * - A dispatch queue. + * - A multicast delegate that automatically invokes added delegates. + * + * The module also automatically registers/unregisters itself with the + * xmpp stream during the activate/deactive methods. +**/ +@interface XMPPModule : NSObject +{ + XMPPStream *xmppStream; + + dispatch_queue_t moduleQueue; + id multicastDelegate; +} + +@property (readonly) dispatch_queue_t moduleQueue; +@property (readonly) XMPPStream *xmppStream; + +- (id)init; +- (id)initWithDispatchQueue:(dispatch_queue_t)queue; + +- (BOOL)activate:(XMPPStream *)xmppStream; +- (void)deactivate; + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate; + +- (NSString *)moduleName; + +@end diff --git a/xmpp/Core/XMPPModule.m b/xmpp/Core/XMPPModule.m new file mode 100644 index 0000000..31acece --- /dev/null +++ b/xmpp/Core/XMPPModule.m @@ -0,0 +1,238 @@ +#import "XMPPModule.h" +#import "XMPPStream.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + + +@implementation XMPPModule + +/** + * Standard init method. +**/ +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +/** + * Designated initializer. +**/ +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super init])) + { + if (queue) + { + moduleQueue = queue; + dispatch_retain(moduleQueue); + } + else + { + const char *moduleQueueName = [[self moduleName] UTF8String]; + moduleQueue = dispatch_queue_create(moduleQueueName, NULL); + } + + multicastDelegate = [[GCDMulticastDelegate alloc] init]; + } + return self; +} + +- (void)dealloc +{ + if (xmppStream) + { + // It is dangerous to rely on the dealloc method to deactivate a module. + // + // Why? + // Because when a module is activated, it is added as a delegate to the xmpp stream. + // In addition to this, the module may be added as a delegate to various other xmpp components. + // As per usual, these delegate references do NOT retain this module. + // This means that modules may get invoked after they are deallocated. + // + // Consider the following example: + // + // 1. Thread A: Module is created (alloc/init) (retainCount = 1) + // 2. Thread A: Module is activated (retainCount = 1) + // 3. Thread A: Module is released, and dealloc is called. + // First [MyCustomModule dealloc] is invoked. + // Then [XMPPModule dealloc] is invoked. + // Only at this point is [XMPPModule deactivate] run. + // Since the deactivate method is synchronous, + // it blocks until the module is removed as a delegate from the stream and all other modules. + // 4. Thread B: Invokes a delegate method on our module ([XMPPModule deactivate] is waiting on thread B). + // 5. Thread A: The [XMPPModule deactivate] method returns, but the damage is done. + // Thread B has asynchronously dispatched a delegate method set to run on our module. + // 6. Thread A: The dealloc method completes, and our module is now deallocated. + // 7. Thread C: The delegate method attempts to run on our module, which is deallocated, + // the application crashes, the computer blows up, and a meteor hits your favorite restaurant. + + XMPPLogWarn(@"%@: Deallocating activated module. You should deactivate modules before their final release.", + NSStringFromClass([self class])); + + [self deactivate]; + } + + [multicastDelegate release]; + + dispatch_release(moduleQueue); + + [super dealloc]; +} + +/** + * The activate method is the point at which the module gets plugged into the xmpp stream. + * Subclasses may override this method to perform any custom actions, + * but must invoke [super activate:aXmppStream] at some point within their implementation. +**/ +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + __block BOOL result = YES; + + dispatch_block_t block = ^{ + + if (xmppStream != nil) + { + result = NO; + } + else + { + xmppStream = [aXmppStream retain]; + + [xmppStream addDelegate:self delegateQueue:moduleQueue]; + [xmppStream registerModule:self]; + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +/** + * The deactivate method unplugs a module from the xmpp stream. + * When this method returns, no further delegate methods on this module will be dispatched. + * However, there may be delegate methods that have already been dispatched. + * If this is the case, the module will be properly retained until the delegate methods have completed. + * If your custom module requires that delegate methods are not run after the deactivate method has been run, + * then simply check the xmppStream variable in your delegate methods. +**/ +- (void)deactivate +{ + dispatch_block_t block = ^{ + + if (xmppStream) + { + [xmppStream removeDelegate:self delegateQueue:moduleQueue]; + [xmppStream unregisterModule:self]; + + [xmppStream release]; + xmppStream = nil; + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); +} + +- (dispatch_queue_t)moduleQueue +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return moduleQueue; + } + else + { + __block dispatch_queue_t result; + + dispatch_sync(moduleQueue, ^{ + result = moduleQueue; + }); + + return result; + } +} + +- (XMPPStream *)xmppStream +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return xmppStream; + } + else + { + __block XMPPStream *result; + + dispatch_sync(moduleQueue, ^{ + result = [xmppStream retain]; + }); + + return [result autorelease]; + } +} + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + // Asynchronous operation (if outside xmppQueue) + + dispatch_block_t block = ^{ + [multicastDelegate addDelegate:delegate delegateQueue:delegateQueue]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + // Synchronous operation + // + // Delegate removal MUST always be synchronous. + + dispatch_block_t block = ^{ + [multicastDelegate removeDelegate:delegate delegateQueue:delegateQueue]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); +} + +- (void)removeDelegate:(id)delegate +{ + // Synchronous operation + // + // Delegate remove MUST always be synchronous. + + dispatch_block_t block = ^{ + [multicastDelegate removeDelegate:delegate]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); +} + +- (NSString *)moduleName +{ + // Override me to provide a proper module name. + // The name may be used as the name of the dispatch_queue which could aid in debugging. + + return @"XMPPModule"; +} + +@end diff --git a/xmpp/Core/XMPPParser.h b/xmpp/Core/XMPPParser.h new file mode 100644 index 0000000..453ed9b --- /dev/null +++ b/xmpp/Core/XMPPParser.h @@ -0,0 +1,47 @@ +#import +#import + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + + +@interface XMPPParser : NSObject +{ + id delegate; + + BOOL hasReportedRoot; + unsigned depth; + + xmlParserCtxt *parserCtxt; +} + +- (id)initWithDelegate:(id)delegate; + +- (id)delegate; +- (void)setDelegate:(id)delegate; + +/** + * Synchronously parses the given data. + * This means the delegate methods will get called before this method returns. +**/ +- (void)parseData:(NSData *)data; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPParserDelegate +@optional + +- (void)xmppParser:(XMPPParser *)sender didReadRoot:(NSXMLElement *)root; + +- (void)xmppParser:(XMPPParser *)sender didReadElement:(NSXMLElement *)element; + +- (void)xmppParserDidEnd:(XMPPParser *)sender; + +- (void)xmppParser:(XMPPParser *)sender didFail:(NSError *)error; + +@end diff --git a/xmpp/Core/XMPPParser.m b/xmpp/Core/XMPPParser.m new file mode 100644 index 0000000..b6e5ded --- /dev/null +++ b/xmpp/Core/XMPPParser.m @@ -0,0 +1,749 @@ +#import "XMPPParser.h" +#import + +#if TARGET_OS_IPHONE + #import "DDXMLPrivate.h" +#endif + +// When the xmpp parser invokes a delegate method, such as xmppParser:didReadElement:, +// it exposes itself to the possibility of exceptions mid-parse. +// This aborts the current run loop, +// and thus causes the parser to lose the rest of the data that was passed to it via the parseData method. +// +// The end result is that our parser will likely barf the next time it tries to parse data. +// Probably with a "EndTag: 'delegate respondsToSelector:@selector(xmppParser:didReadRoot:)]) + { + // We first copy the root node. + // We do this to allow the delegate to retain and make changes to the reported root + // without affecting the underlying xmpp parser. + + // xmlCopyNode(const xmlNodePtr node, int extended) + // + // node: + // the node to copy + // extended: + // if 1 do a recursive copy (properties, namespaces and children when applicable) + // if 2 copy properties and namespaces (when applicable) + + xmlNodePtr rootCopy = xmlCopyNode(root, 2); + DDXMLElement *rootCopyWrapper = [DDXMLElement nodeWithElementPrimitive:rootCopy freeOnDealloc:YES]; + +#if USE_TRY_CATCH + @try + { + // If the delegate throws an exception that we don't catch, + // this would cause our parser to abort, + // and ignore the rest of the data that was passed to us in parseData. + // + // The end result is that our parser will likely barf the next time it tries to parse data. + // Probably with a "EndTag: 'delegate xmppParser:parser didReadRoot:rootCopyWrapper]; + } + @catch (id exception) { /* Ignore */ } +#else + [parser->delegate xmppParser:parser didReadRoot:rootCopyWrapper]; +#endif + // Note: DDXMLElement will properly free the rootCopy when it's deallocated. + } +} + +static void onDidReadElement(XMPPParser *parser, xmlNodePtr child) +{ + [DDXMLNode detachChild:child fromNode:child->parent]; + + DDXMLElement *childWrapper = [DDXMLElement nodeWithElementPrimitive:child freeOnDealloc:YES]; + + // Note: We want to detach the child from the root even if the delegate method isn't setup. + // This prevents the doc from growing infinitely large. + + if([parser->delegate respondsToSelector:@selector(xmppParser:didReadElement:)]) + { +#if USE_TRY_CATCH + @try + { + // If the delegate throws an exception that we don't catch, + // this would cause our parser to abort, + // and ignore the rest of the data that was passed to us in parseData. + // + // The end result is that our parser will likely barf the next time it tries to parse data. + // Probably with a "EndTag: 'delegate xmppParser:parser didReadElement:childWrapper]; + } + @catch (id exception) { /* Ignore */ } +#else + [parser->delegate xmppParser:parser didReadElement:childWrapper]; +#endif + } + + // Note: DDXMLElement will properly free the child when it's deallocated. +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Mac +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#else + +static void setName(NSXMLElement *element, xmlNodePtr node) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + if(node->name == NULL) + { + [element setName:@""]; + return; + } + + if((node->ns != NULL) && (node->ns->prefix != NULL)) + { + // E.g: + + NSString *prefix = [[NSString alloc] initWithUTF8String:(const char *)node->ns->prefix]; + NSString *name = [[NSString alloc] initWithUTF8String:(const char *)node->name]; + + NSString *elementName = [[NSString alloc] initWithFormat:@"%@:%@", prefix, name]; + [element setName:elementName]; + [elementName release]; + + [name release]; + [prefix release]; + } + else + { + NSString *elementName = [[NSString alloc] initWithUTF8String:(const char *)node->name]; + [element setName:elementName]; + [elementName release]; + } +} + +static void addNamespaces(NSXMLElement *element, xmlNodePtr node) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + xmlNsPtr nsNode = node->nsDef; + while(nsNode != NULL) + { + if(nsNode->href == NULL) + { + // Namespace doesn't have a value! + } + else + { + NSXMLNode *ns = [[NSXMLNode alloc] initWithKind:NSXMLNamespaceKind]; + + if(nsNode->prefix != NULL) + { + NSString *nsName = [[NSString alloc] initWithUTF8String:(const char *)nsNode->prefix]; + [ns setName:nsName]; + [nsName release]; + } + else + { + // Default namespace. + // E.g: xmlns="deusty.com" + + [ns setName:@""]; + } + + NSString *nsValue = [[NSString alloc] initWithUTF8String:(const char *)nsNode->href]; + [ns setStringValue:nsValue]; + [nsValue release]; + + [element addNamespace:ns]; + [ns release]; + } + + nsNode = nsNode->next; + } +} + +static void addChildren(NSXMLElement *element, xmlNodePtr node) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + xmlNodePtr childNode = node->children; + while(childNode != NULL) + { + if(childNode->type == XML_ELEMENT_NODE) + { + recursiveAddChild(element, childNode); + } + else if(childNode->type == XML_TEXT_NODE) + { + if(childNode->content != NULL) + { + NSString *value = [[NSString alloc] initWithUTF8String:(const char *)childNode->content]; + [element setStringValue:value]; + [value release]; + } + } + + childNode = childNode->next; + } +} + +static void addAttributes(NSXMLElement *element, xmlNodePtr node) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + xmlAttrPtr attrNode = node->properties; + while(attrNode != NULL) + { + if(attrNode->name == NULL) + { + // Attribute doesn't have a name! + } + else if(attrNode->children == NULL) + { + // Attribute doesn't have a value node! + } + else if(attrNode->children->content == NULL) + { + // Attribute doesn't have a value! + } + else + { + NSXMLNode *attr = [[NSXMLNode alloc] initWithKind:NSXMLAttributeKind]; + + if((attrNode->ns != NULL) && (attrNode->ns->prefix != NULL)) + { + // E.g: + + NSString *prefix = [[NSString alloc] initWithUTF8String:(const char *)attrNode->ns->prefix]; + NSString *name = [[NSString alloc] initWithUTF8String:(const char *)attrNode->name]; + + NSString *attrName = [[NSString alloc] initWithFormat:@"%@:%@", prefix, name]; + [attr setName:attrName]; + [attrName release]; + + [name release]; + [prefix release]; + } + else + { + NSString *attrName = [[NSString alloc] initWithUTF8String:(const char *)attrNode->name]; + [attr setName:attrName]; + [attrName release]; + } + + NSString *attrValue = [[NSString alloc] initWithUTF8String:(const char *)attrNode->children->content]; + [attr setStringValue:attrValue]; + [attrValue release]; + + [element addAttribute:attr]; + [attr release]; + } + + attrNode = attrNode->next; + } +} + +/** + * Recursively adds all the child elements to the given parent. + * + * Note: This method is almost the same as nsxmlFromLibxml, with one important difference. + * It doen't add any objects to the autorelease pool. +**/ +static void recursiveAddChild(NSXMLElement *parent, xmlNodePtr childNode) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + NSXMLElement *child = [[NSXMLElement alloc] initWithKind:NSXMLElementKind]; + + setName(child, childNode); + + addNamespaces(child, childNode); + + addChildren(child, childNode); + addAttributes(child, childNode); + + [parent addChild:child]; + [child release]; +} + +/** + * Creates and returns an NSXMLElement from the given node. + * Use this method after finding the root element, or root.child element. +**/ +static NSXMLElement* nsxmlFromLibxml(xmlNodePtr rootNode) +{ + // Remember: The NSString initWithUTF8String raises an exception if passed NULL + + NSXMLElement *root = [[NSXMLElement alloc] initWithKind:NSXMLElementKind]; + + setName(root, rootNode); + + addNamespaces(root, rootNode); + + addChildren(root, rootNode); + addAttributes(root, rootNode); + + return [root autorelease]; +} + +static void onDidReadRoot(XMPPParser *parser, xmlNodePtr root) +{ + if([parser->delegate respondsToSelector:@selector(xmppParser:didReadRoot:)]) + { + NSXMLElement *nsRoot = nsxmlFromLibxml(root); + +#if USE_TRY_CATCH + @try + { + // If the delegate throws an exception that we don't catch, + // this would cause our parser to abort, + // and ignore the rest of the data that was passed to us in parseData. + // + // The end result is that our parser will likely barf the next time it tries to parse data. + // Probably with a "EndTag: 'delegate xmppParser:parser didReadRoot:nsRoot]; + } + @catch (id exception) { /* Ignore */ } +#else + [parser->delegate xmppParser:parser didReadRoot:nsRoot]; +#endif + } +} + +static void onDidReadElement(XMPPParser *parser, xmlNodePtr child) +{ + if([parser->delegate respondsToSelector:@selector(xmppParser:didReadElement:)]) + { + NSXMLElement *nsChild = nsxmlFromLibxml(child); + +#if USE_TRY_CATCH + @try + { + // If the delegate throws an exception that we don't catch, + // this would cause our parser to abort, + // and ignore the rest of the data that was passed to us in parseData. + // + // The end result is that our parser will likely barf the next time it tries to parse data. + // Probably with a "EndTag: 'delegate xmppParser:parser didReadElement:nsChild]; + } + @catch (id exception) { /* Ignore */ } +#else + [parser->delegate xmppParser:parser didReadElement:nsChild]; +#endif + } + + // Note: We want to detach the child from the root even if the delegate method isn't setup. + // This prevents the doc from growing infinitely large. + + // Detach and free child to keep memory footprint small + xmlUnlinkNode(child); + xmlFreeNode(child); +} + +#endif + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Common +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method is called at the end of the xmlStartElement method. + * This allows us to inspect the parser and xml tree, and determine if we need to invoke any delegate methods. +**/ +static void postStartElement(xmlParserCtxt *ctxt) +{ + XMPPParser *parser = (XMPPParser *)ctxt->_private; + parser->depth++; + + if(!(parser->hasReportedRoot) && (parser->depth == 1)) + { + // We've received the full root - report it to the delegate + + if(ctxt->myDoc) + { + xmlNodePtr root = xmlDocGetRootElement(ctxt->myDoc); + if(root) + { + onDidReadRoot(parser, root); + + parser->hasReportedRoot = YES; + } + } + } +} + +/** + * This method is called at the end of the xmlEndElement method. + * This allows us to inspect the parser and xml tree, and determine if we need to invoke any delegate methods. +**/ +static void postEndElement(xmlParserCtxt *ctxt) +{ + XMPPParser *parser = (XMPPParser *)ctxt->_private; + parser->depth--; + + if(parser->depth == 1) + { + // End of full xmpp element. + // That is, a child of the root element. + // Extract the child, and pass it to the delegate. + + xmlDocPtr doc = ctxt->myDoc; + xmlNodePtr root = xmlDocGetRootElement(doc); + + xmlNodePtr child = root->children; + while(child != NULL) + { + if(child->type == XML_ELEMENT_NODE) + { + onDidReadElement(parser, child); + + // Exit while loop + break; + } + + child = child->next; + } + } + else if(parser->depth == 0) + { + // End of the root element + + if([parser->delegate respondsToSelector:@selector(xmppParserDidEnd:)]) + { + [parser->delegate xmppParserDidEnd:parser]; + } + } +} + +/** + * We're screwed... +**/ +static void xmlAbortDueToMemoryShortage(xmlParserCtxt *ctxt) +{ + XMPPParser *parser = (XMPPParser *)ctxt->_private; + + xmlStopParser(ctxt); + + if([parser->delegate respondsToSelector:@selector(xmppParser:didFail:)]) + { + NSString *errMsg = @"Unable to allocate memory in xmpp parser"; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + NSError *error = [NSError errorWithDomain:@"libxmlErrorDomain" code:1001 userInfo:info]; + + [parser->delegate xmppParser:parser didFail:error]; + } +} + +/** + * SAX parser C-style callback. + * Invoked when a new node element is started. +**/ +static void xmlStartElement(void *ctx, const xmlChar *nodeName, + const xmlChar *nodePrefix, + const xmlChar *nodeUri, + int nb_namespaces, + const xmlChar **namespaces, + int nb_attributes, + int nb_defaulted, + const xmlChar **attributes) +{ + int i, j; + xmlNsPtr lastAddedNs = NULL; + + xmlParserCtxt *ctxt = (xmlParserCtxt *)ctx; + + // We store the parent node in the context's node pointer. + // We keep this updated by "pushing" the node in the startElement method, + // and "popping" the node in the endElement method. + xmlNodePtr parent = ctxt->node; + + // Create the node + xmlNodePtr newNode = xmlNewDocNode(ctxt->myDoc, NULL, nodeName, NULL); + CHECK_FOR_NULL(newNode); + + // Add the node to the tree + if(parent == NULL) + { + // Root node + xmlAddChild((xmlNodePtr)ctxt->myDoc, newNode); + } + else + { + xmlAddChild(parent, newNode); + } + + // Process the namespaces + for(i = 0, j = 0; j < nb_namespaces; j++) + { + // Extract namespace prefix and uri + const xmlChar *nsPrefix = namespaces[i++]; + const xmlChar *nsUri = namespaces[i++]; + + // Create the namespace + xmlNsPtr newNs = xmlNewNs(NULL, nsUri, nsPrefix); + CHECK_FOR_NULL(newNs); + + // Add namespace to node. + // Each node has a linked list of nodes (in the nsDef variable). + // The linked list is forward only. + // In other words, each ns has a next, but not a prev pointer. + + if (newNode->nsDef == NULL) + { + newNode->nsDef = lastAddedNs = newNs; + } + else if(lastAddedNs) + { + lastAddedNs->next = newNs; + lastAddedNs = newNs; + } + + if ((nodeUri != NULL) && (nodePrefix == nsPrefix)) + { + // This is the namespace for the node. + // Example 1: the node was and newNs is the stream:url namespace. + // Example 2: the node was and newNs is the null:url namespace. + newNode->ns = newNs; + } + } + + // Search for the node's namespace if it wasn't already found + if ((nodeUri != NULL) && (newNode->ns == NULL)) + { + // xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace) + // + // Search a Ns registered under a given name space for a document. + // Recurse on the parents until it finds the defined namespace or return NULL otherwise. + // The nameSpace parameter can be NULL, this is a search for the default namespace. + + newNode->ns = xmlSearchNs(ctxt->myDoc, parent, nodePrefix); + + if (newNode->ns == NULL) + { + // We use href==NULL in the case of an element creation where the namespace was not defined. + newNode->ns = xmlNewNs(newNode, NULL, nodePrefix); + CHECK_FOR_NULL(newNode->ns); + } + } + + // Process all the attributes + for (i = 0, j = 0; j < nb_attributes; j++) + { + const xmlChar *attrName = attributes[i++]; + const xmlChar *attrPrefix = attributes[i++]; + const xmlChar *attrUri = attributes[i++]; + const xmlChar *valueBegin = attributes[i++]; + const xmlChar *valueEnd = attributes[i++]; + + // The attribute value might contain character references which need to be decoded. + // + // "Franks & Beans" -> "Franks & Beans" + + xmlChar *value = xmlStringLenDecodeEntities(ctxt, // the parser context + valueBegin, // the input string + (int)(valueEnd - valueBegin), // the input string length + (XML_SUBSTITUTE_REF), // what to substitue + 0, 0, 0); // end markers, 0 if none + CHECK_FOR_NULL(value); + + if ((attrPrefix == NULL) && (attrUri == NULL)) + { + // Normal attribute - no associated namespace + xmlAttrPtr newAttr = xmlNewProp(newNode, attrName, value); + CHECK_FOR_NULL(newAttr); + } + else + { + // Find the namespace for the attribute + xmlNsPtr attrNs = xmlSearchNs(ctxt->myDoc, newNode, attrPrefix); + + if(attrNs != NULL) + { + xmlAttrPtr newAttr = xmlNewNsProp(newNode, attrNs, attrName, value); + CHECK_FOR_NULL(newAttr); + } + else + { + attrNs = xmlNewNs(NULL, NULL, nodePrefix); + CHECK_FOR_NULL(attrNs); + + xmlAttrPtr newAttr = xmlNewNsProp(newNode, attrNs, attrName, value); + CHECK_FOR_NULL(newAttr); + } + } + + xmlFree(value); + } + + // Update our parent node pointer + ctxt->node = newNode; + + // Invoke delegate methods if needed + postStartElement(ctxt); +} + +/** + * SAX parser C-style callback. + * Invoked when characters are found within a node. +**/ +static void xmlCharacters(void *ctx, const xmlChar *ch, int len) +{ + xmlParserCtxt *ctxt = (xmlParserCtxt *)ctx; + + if(ctxt->node != NULL) + { + xmlNodePtr textNode = xmlNewTextLen(ch, len); + + // xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) + // + // Add a new node to @parent, at the end of the child list + // merging adjacent TEXT nodes (in which case @cur is freed). + + xmlAddChild(ctxt->node, textNode); + } +} + +/** + * SAX parser C-style callback. + * Invoked when a new node element is ended. +**/ +static void xmlEndElement(void *ctx, const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI) +{ + xmlParserCtxt *ctxt = (xmlParserCtxt *)ctx; + + // Update our parent node pointer + if(ctxt->node != NULL) + ctxt->node = ctxt->node->parent; + + // Invoke delegate methods if needed + postEndElement(ctxt); +} + +- (id)initWithDelegate:(id)aDelegate +{ + if((self = [super init])) + { + delegate = aDelegate; + + hasReportedRoot = NO; + depth = 0; + + // Create SAX handler + xmlSAXHandler saxHandler; + memset(&saxHandler, 0, sizeof(xmlSAXHandler)); + + saxHandler.initialized = XML_SAX2_MAGIC; + saxHandler.startElementNs = xmlStartElement; + saxHandler.characters = xmlCharacters; + saxHandler.endElementNs = xmlEndElement; + + // Create the push parser context + parserCtxt = xmlCreatePushParserCtxt(&saxHandler, NULL, NULL, 0, NULL); + + // Note: This method copies the saxHandler, so we don't have to keep it around. + + // Create the document to hold the parsed elements + parserCtxt->myDoc = xmlNewDoc(parserCtxt->version); + + // Store reference to ourself + parserCtxt->_private = self; + + // Note: The parserCtxt also has a userData variable, but it is used by the DOM building functions. + // If we put a value there, it actually causes a crash! + // We need to be sure to use the _private variable which libxml won't touch. + } + return self; +} + +- (void)dealloc +{ + if(parserCtxt) + { + // The xmlFreeParserCtxt method will not free the created document in parserCtxt->myDoc. + + if(parserCtxt->myDoc) + { + // Free the created xmlDoc + xmlFreeDoc(parserCtxt->myDoc); + } + + xmlFreeParserCtxt(parserCtxt); + } + + [super dealloc]; +} + +- (id)delegate { + return delegate; +} +- (void)setDelegate:(id)aDelegate { + delegate = aDelegate; +} + +- (void)parseData:(NSData *)data +{ + // The xmlParseChunk method below will cause the delegate methods to be invoked before this method returns. + // If the delegate subsequently attempts to release us in one of those methods, and our dealloc method + // gets invoked, then the parserCtxt will be freed in the middle of the xmlParseChunk method. + // This often has the effect of crashing the application. + // To get around this problem we simply retain/release within the method. + [self retain]; + + int result = xmlParseChunk(parserCtxt, (const char *)[data bytes], (int)[data length], 0); + + if(result != 0) + { + if([delegate respondsToSelector:@selector(xmppParser:didFail:)]) + { + NSError *error; + + xmlError *xmlErr = xmlCtxtGetLastError(parserCtxt); + + if(xmlErr->message) + { + NSString *errMsg = [NSString stringWithFormat:@"%s", xmlErr->message]; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + error = [NSError errorWithDomain:@"libxmlErrorDomain" code:xmlErr->code userInfo:info]; + } + else + { + error = [NSError errorWithDomain:@"libxmlErrorDomain" code:xmlErr->code userInfo:nil]; + } + + [delegate xmppParser:self didFail:error]; + } + } + + [self release]; +} + +@end diff --git a/xmpp/Core/XMPPPresence.h b/xmpp/Core/XMPPPresence.h new file mode 100644 index 0000000..eb9a31b --- /dev/null +++ b/xmpp/Core/XMPPPresence.h @@ -0,0 +1,36 @@ +#import +#import "XMPPElement.h" + +/** + * The XMPPPresence class represents a element. + * It extends XMPPElement, which in turn extends NSXMLElement. + * All elements that go in and out of the + * xmpp stream will automatically be converted to XMPPPresence objects. + * + * This class exists to provide developers an easy way to add functionality to presence processing. + * Simply add your own category to XMPPPresence to extend it with your own custom methods. +**/ + +@interface XMPPPresence : XMPPElement + +// Converts an NSXMLElement to an XMPPPresence element in place (no memory allocations or copying) ++ (XMPPPresence *)presenceFromElement:(NSXMLElement *)element; + ++ (XMPPPresence *)presence; ++ (XMPPPresence *)presenceWithType:(NSString *)type; ++ (XMPPPresence *)presenceWithType:(NSString *)type to:(XMPPJID *)to; + +- (id)init; +- (id)initWithType:(NSString *)type; +- (id)initWithType:(NSString *)type to:(XMPPJID *)to; + +- (NSString *)type; + +- (NSString *)show; +- (NSString *)status; + +- (int)priority; + +- (int)intShow; + +@end diff --git a/xmpp/Core/XMPPPresence.m b/xmpp/Core/XMPPPresence.m new file mode 100644 index 0000000..548f1f0 --- /dev/null +++ b/xmpp/Core/XMPPPresence.m @@ -0,0 +1,122 @@ +#import "XMPPPresence.h" +#import "NSXMLElement+XMPP.h" + +#import + + +@implementation XMPPPresence + ++ (void)initialize +{ + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPPresence class]); + + if (superSize != ourSize) + { + NSLog(@"Adding instance variables to XMPPPresence is not currently supported!"); + exit(15); + } +} + ++ (XMPPPresence *)presenceFromElement:(NSXMLElement *)element +{ + object_setClass(element, [XMPPPresence class]); + + return (XMPPPresence *)element; +} + ++ (XMPPPresence *)presence +{ + return [[[XMPPPresence alloc] init] autorelease]; +} + ++ (XMPPPresence *)presenceWithType:(NSString *)type +{ + return [[[XMPPPresence alloc] initWithType:type] autorelease]; +} + ++ (XMPPPresence *)presenceWithType:(NSString *)type to:(XMPPJID *)to +{ + return [[[XMPPPresence alloc] initWithType:type to:to] autorelease]; +} + +- (id)init +{ + self = [super initWithName:@"presence"]; + return self; +} + +- (id)initWithType:(NSString *)type +{ + if ((self = [super initWithName:@"presence"])) + { + if (type) + [self addAttributeWithName:@"type" stringValue:type]; + } + return self; +} + +- (id)initWithType:(NSString *)type to:(XMPPJID *)to +{ + if ((self = [super initWithName:@"presence"])) + { + if (type) + [self addAttributeWithName:@"type" stringValue:type]; + + if (to) + [self addAttributeWithName:@"to" stringValue:[to description]]; + } + return self; +} + +- (NSString *)type +{ + NSString *type = [self attributeStringValueForName:@"type"]; + if(type) + return [type lowercaseString]; + else + return @"available"; +} + +- (NSString *)show +{ + return [[self elementForName:@"show"] stringValue]; +} + +- (NSString *)status +{ + return [[self elementForName:@"status"] stringValue]; +} + +- (int)priority +{ + return [[[self elementForName:@"priority"] stringValue] intValue]; +} + +- (int)intShow +{ + NSString *show = [self show]; + + if([show isEqualToString:@"dnd"]) + return 0; + if([show isEqualToString:@"xa"]) + return 1; + if([show isEqualToString:@"away"]) + return 2; + if([show isEqualToString:@"chat"]) + return 4; + + return 3; +} + +@end diff --git a/xmpp/Core/XMPPStream.h b/xmpp/Core/XMPPStream.h new file mode 100644 index 0000000..def440f --- /dev/null +++ b/xmpp/Core/XMPPStream.h @@ -0,0 +1,804 @@ +#import +#import "GCDMulticastDelegate.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class GCDAsyncSocket; +@class XMPPSRVResolver; +@class DDList; +@class XMPPParser; +@class XMPPJID; +@class XMPPIQ; +@class XMPPMessage; +@class XMPPPresence; +@class XMPPModule; +@class XMPPElementReceipt; +@protocol XMPPStreamDelegate; + +#if TARGET_OS_IPHONE + #define MIN_KEEPALIVE_INTERVAL 20.0 // 20 Seconds + #define DEFAULT_KEEPALIVE_INTERVAL 120.0 // 2 Minutes +#else + #define MIN_KEEPALIVE_INTERVAL 10.0 // 10 Seconds + #define DEFAULT_KEEPALIVE_INTERVAL 300.0 // 5 Minutes +#endif + +extern NSString *const XMPPStreamErrorDomain; + +enum XMPPStreamErrorCode +{ + XMPPStreamInvalidType, // Attempting to access P2P methods in a non-P2P stream, or vice-versa + XMPPStreamInvalidState, // Invalid state for requested action, such as connect when already connected + XMPPStreamInvalidProperty, // Missing a required property, such as hostName or myJID + XMPPStreamInvalidParameter, // Invalid parameter, such as a nil JID + XMPPStreamUnsupportedAction, // The server doesn't support the requested action +}; +typedef enum XMPPStreamErrorCode XMPPStreamErrorCode; + + +@interface XMPPStream : NSObject +{ + dispatch_queue_t xmppQueue; + dispatch_queue_t parserQueue; + + GCDMulticastDelegate *multicastDelegate; + + int state; + + GCDAsyncSocket *asyncSocket; + NSMutableData *socketBuffer; + + UInt64 numberOfBytesSent; + UInt64 numberOfBytesReceived; + + XMPPParser *parser; + NSError *parserError; + + Byte flags; + Byte config; + + NSString *hostName; + UInt16 hostPort; + + NSString *tempPassword; + + XMPPJID *myJID; + XMPPJID *remoteJID; + + XMPPPresence *myPresence; + NSXMLElement *rootElement; + + NSTimeInterval keepAliveInterval; + dispatch_source_t keepAliveTimer; + dispatch_time_t lastSendReceiveTime; + + DDList *registeredModules; + NSMutableDictionary *autoDelegateDict; + + XMPPSRVResolver *srvResolver; + NSArray *srvResults; + NSUInteger srvResultsIndex; + + NSMutableArray *receipts; + + NSThread *xmppUtilityThread; + NSRunLoop *xmppUtilityRunLoop; + + id userTag; +} + +/** + * Standard XMPP initialization. + * The stream is a standard client to server connection. + * + * P2P streams using XEP-0174 are also supported. + * See the P2P section below. +**/ +- (id)init; + +/** + * Peer to Peer XMPP initialization. + * The stream is a direct client to client connection as outlined in XEP-0174. +**/ +- (id)initP2PFrom:(XMPPJID *)myJID; + +/** + * XMPPStream uses a multicast delegate. + * This allows one to add multiple delegates to a single XMPPStream instance, + * which makes it easier to separate various components and extensions. + * + * For example, if you were implementing two different custom extensions on top of XMPP, + * you could put them in separate classes, and simply add each as a delegate. +**/ +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The server's hostname that should be used to make the TCP connection. + * This may be a domain name (e.g. "deusty.com") or an IP address (e.g. "70.85.193.226"). + * + * Note that this may be different from the virtual xmpp hostname. + * Just as HTTP servers can support mulitple virtual hosts from a single server, so too can xmpp servers. + * A prime example is google via google apps. + * + * For example, say you own the domain "mydomain.com". + * If you go to mydomain.com in a web browser, + * you are directed to your apache server running on your webserver somewhere in the cloud. + * But you use google apps for your email and xmpp needs. + * So if somebody sends you an email, it actually goes to google's servers, where you later access it from. + * Similarly, you connect to google's servers to sign into xmpp. + * + * In the example above, your hostname is "talk.google.com" and your JID is "me@mydomain.com". + * + * This hostName property is optional. + * If you do not set the hostName, then the framework will follow the xmpp specification using jid's domain. + * That is, it first do an SRV lookup (as specified in the xmpp RFC). + * If that fails, it will fall back to simply attempting to connect to the jid's domain. +**/ +@property (readwrite, copy) NSString *hostName; + +/** + * The port the xmpp server is running on. + * If you do not explicitly set the port, the default port will be used. + * If you set the port to zero, the default port will be used. + * + * The default port is 5222. +**/ +@property (readwrite, assign) UInt16 hostPort; + +/** + * The JID of the user. + * + * This value is required, and is used in many parts of the underlying implementation. + * When connecting, the domain of the JID is used to properly specify the correct xmpp virtual host. + * It is used during registration to supply the username of the user to create an account for. + * It is used during authentication to supply the username of the user to authenticate with. + * And the resource may be used post-authentication during the required xmpp resource binding step. + * + * A proper JID is of the form user@domain/resource. + * For example: robbiehanson@deusty.com/work + * + * The resource is optional, in the sense that if one is not supplied, + * one will be automatically generated for you (either by us or by the server). + * + * Please note: + * Resource collisions are handled in different ways depending on server configuration. + * + * For example: + * You are signed in with user1@domain.com/home on your desktop. + * Then you attempt to sign in with user1@domain.com/home on your laptop. + * + * The server could possibly: + * - Reject the resource request for the laptop. + * - Accept the resource request for the laptop, and immediately disconnect the desktop. + * - Automatically assign the laptop another resource without a conflict. + * + * For this reason, you may wish to check the myJID variable after the stream has been connected, + * just in case the resource was changed by the server. +**/ +@property (readwrite, copy) XMPPJID *myJID; + +/** + * Only used in P2P streams. +**/ +@property (readonly) XMPPJID *remoteJID; + +/** + * Many routers will teardown a socket mapping if there is no activity on the socket. + * For this reason, the xmpp stream supports sending keep-alive data. + * This is simply whitespace, which is ignored by the xmpp protocol. + * + * Keep-alive data is only sent in the absence of any other data being sent/received. + * + * The default value is defined in DEFAULT_KEEPALIVE_INTERVAL. + * The minimum value is defined in MIN_KEEPALIVE_INTERVAL. + * + * To disable keep-alive, set the interval to zero. + * + * The keep-alive timer (if enabled) fires every (keepAliveInterval / 4) seconds. + * Upon firing it checks when data was last sent/received, + * and sends keep-alive data if the elapsed time has exceeded the keepAliveInterval. + * Thus the effective resolution of the keepalive timer is based on the interval. +**/ +@property (readwrite, assign) NSTimeInterval keepAliveInterval; + +/** + * Represents the last sent presence element concerning the presence of myJID on the server. + * In other words, it represents the presence as others see us. + * + * This excludes presence elements sent concerning subscriptions, MUC rooms, etc. +**/ +@property (readonly) XMPPPresence *myPresence; + +/** + * Returns the total number of bytes bytes sent/received by the xmpp stream. + * + * By default this is the byte count since the xmpp stream object has been created. + * If the stream has connected/disconnected/reconnected multiple times, + * the count will be the summation of all connections. + * + * The functionality may optionaly be changed to count only the current socket connection. + * See the resetByteCountPerConnection property. +**/ +@property (readonly) UInt64 numberOfBytesSent; +@property (readonly) UInt64 numberOfBytesReceived; + +/** + * Affects the funtionality of the byte counter. + * + * The default value is NO. + * + * If set to YES, the byte count will be reset just prior to a new connection (in the connect methods). +**/ +@property (readwrite, assign) BOOL resetByteCountPerConnection; + +/** + * The tag property allows you to associate user defined information with the stream. + * Tag values are not used internally, and should not be used by xmpp modules. +**/ +@property (readwrite, retain) id tag; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark State +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns YES if the connection is closed, and thus no stream is open. + * If the stream is neither disconnected, nor connected, then a connection is currently being established. +**/ +- (BOOL)isDisconnected; + +/** + * Returns YES if the connection is open, and the stream has been properly established. + * If the stream is neither disconnected, nor connected, then a connection is currently being established. + * + * If this method returns YES, then it is ready for you to start sending and receiving elements. +**/ +- (BOOL)isConnected; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Connect & Disconnect +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Connects to the configured hostName on the configured hostPort. + * If the hostName or myJID are not set, this method will return NO and set the error parameter. +**/ +- (BOOL)connect:(NSError **)errPtr; + +/** + * THIS IS DEPRECATED BY THE XMPP SPECIFICATION. + * + * The xmpp specification outlines the proper use of SSL/TLS by negotiating + * the startTLS upgrade within the stream negotiation. + * This method exists for those ancient servers that still require the connection to be secured prematurely. + * + * Note: Such servers generally use port 5223 for this, which you will need to set. +**/ +- (BOOL)oldSchoolSecureConnect:(NSError **)errPtr; + +/** + * Starts a P2P connection to the given user and given address. + * This method only works with XMPPStream objects created using the initP2P method. + * + * The given address is specified as a sockaddr structure wrapped in a NSData object. + * For example, a NSData object returned from NSNetservice's addresses method. +**/ +- (BOOL)connectTo:(XMPPJID *)remoteJID withAddress:(NSData *)remoteAddr error:(NSError **)errPtr; + +/** + * Starts a P2P connection with the given accepted socket. + * This method only works with XMPPStream objects created using the initP2P method. + * + * The given socket should be a socket that has already been accepted. + * The remoteJID will be extracted from the opening stream negotiation. +**/ +- (BOOL)connectP2PWithSocket:(GCDAsyncSocket *)acceptedSocket error:(NSError **)errPtr; + +/** + * Disconnects from the remote host by closing the underlying TCP socket connection. + * + * The disconnect method is synchronous. + * Meaning that the disconnect will happen immediately, even if there are pending elements yet to be sent. + * The xmppStreamDidDisconnect:withError: method will be invoked before the disconnect method returns. + * + * The disconnectAfterSending method is asynchronous. + * The disconnect will happen after all pending elements have been sent. + * Attempting to send elements after this method is called will not result in the elements getting sent. + * The disconnectAfterSending method will return immediately, + * and the xmppStreamDidDisconnect:withError: delegate method will be invoked at a later time. +**/ +- (void)disconnect; +- (void)disconnectAfterSending; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Security +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns YES if SSL/TLS was used to establish a connection to the server. + * + * Some servers may require an "upgrade to TLS" in order to start communication, + * so even if the connection was not explicitly secured, an ugrade to TLS may have occured. + * + * See also the xmppStream:willSecureWithSettings: delegate method. +**/ +- (BOOL)isSecure; + +/** + * Returns whether or not the server supports securing the connection via SSL/TLS. + * + * Some servers will actually require a secure connection, + * in which case the stream will attempt to secure the connection during the opening process. + * + * If the connection has already been secured, this method may return NO. +**/ +- (BOOL)supportsStartTLS; + +/** + * Attempts to secure the connection via SSL/TLS. + * + * This method is asynchronous. + * The SSL/TLS handshake will occur in the background, and + * the xmppStreamDidSecure: delegate method will be called after the TLS process has completed. + * + * This method returns immediately. + * If the secure process was started, it will return YES. + * If there was an issue while starting the security process, + * this method will return NO and set the error parameter. + * + * The errPtr parameter is optional - you may pass nil. + * + * You may wish to configure the security settings via the xmppStream:willSecureWithSettings: delegate method. + * + * If the SSL/TLS handshake fails, the connection will be closed. + * The reason for the error will be reported via the xmppStreamDidDisconnect:withError: delegate method. + * The error parameter will be an NSError object, and may have an error domain of kCFStreamErrorDomainSSL. + * The corresponding error code is documented in Apple's Security framework, in SecureTransport.h +**/ +- (BOOL)secureConnection:(NSError **)errPtr; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Registration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * In Band Registration. + * Creating a user account on the xmpp server within the xmpp protocol. + * + * The registerWithPassword:error: method is asynchronous. + * It will return immediately, and the delegate methods are used to determine success. + * See the xmppStreamDidRegister: and xmppStream:didNotRegister: methods. + * + * If there is something immediately wrong, such as the stream is not connected, + * this method will return NO and set the error. + * + * The errPtr parameter is optional - you may pass nil. + * + * Security Note: + * The password will be sent in the clear unless the stream has been secured. +**/ +- (BOOL)supportsInBandRegistration; +- (BOOL)registerWithPassword:(NSString *)password error:(NSError **)errPtr; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Authentication +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Authentication. + * + * The authenticateWithPassword:error: method is asynchronous. + * It will return immediately, and the delegate methods are used to determine success. + * See the xmppStreamDidAuthenticate: and xmppStream:didNotAuthenticate: methods. + * + * If there is something immediately wrong, such as the stream is not connected, + * this method will return NO and set the error. + * + * The errPtr parameter is optional - you may pass nil. + * + * The authenticateWithPassword:error: method will choose the most secure protocol to send the password. + * + * Security Note: + * Care should be taken if sending passwords in the clear is not acceptable. + * You may use the supportsXAuthentication methods below to determine + * if an acceptable authentication protocol is supported. +**/ +- (BOOL)isAuthenticated; +- (BOOL)supportsAnonymousAuthentication; +- (BOOL)supportsPlainAuthentication; +- (BOOL)supportsDigestMD5Authentication; +- (BOOL)supportsDeprecatedPlainAuthentication; +- (BOOL)supportsDeprecatedDigestAuthentication; +- (BOOL)authenticateWithPassword:(NSString *)password error:(NSError **)errPtr; +- (BOOL)authenticateAnonymously:(NSError **)errPtr; + +- (void)handleAuth1:(NSXMLElement *)response; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Server Info +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method will return the root element of the document. + * This element contains the opening and tags received from the server. + * + * If multiple have been received during the course of stream negotiation, + * the root element contains only the most recent (current) version. + * + * Note: The rootElement is "empty", in so much as it does not contain all the XML elements the stream has + * received during it's connection. This is done for performance reasons and for the obvious benefit + * of being more memory efficient. +**/ +- (NSXMLElement *)rootElement; + +/** + * Returns the version attribute from the servers's element. + * This should be at least 1.0 to be RFC 3920 compliant. + * If no version number was set, the server is not RFC compliant, and 0 is returned. +**/ +- (float)serverXmppStreamVersionNumber; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Sending +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Sends the given XML element. + * If the stream is not yet connected, this method does nothing. +**/ +- (void)sendElement:(NSXMLElement *)element; + +/** + * Just like the sendElement: method above, + * but allows you to receive a receipt that can later be used to verify the element has been sent. + * + * If you later want to check to see if the element has been sent: + * + * if ([receipt wait:0]) { + * // Element has been sent + * } + * + * If you later want to wait until the element has been sent: + * + * if ([receipt wait:-1]) { + * // Element was sent + * } else { + * // Element failed to send due to disconnection + * } + * + * It is important to understand what it means when [receipt wait:timeout] returns YES. + * It does NOT mean the server has received the element. + * It only means the data has been queued for sending in the underlying OS socket buffer. + * + * So at this point the OS will do everything in its capacity to send the data to the server, + * which generally means the server will eventually receive the data. + * Unless, of course, something horrible happens such as a network failure, + * or a system crash, or the server crashes, etc. + * + * Even if you close the xmpp stream after this point, the OS will still do everything it can to send the data. +**/ +- (void)sendElement:(NSXMLElement *)element andGetReceipt:(XMPPElementReceipt **)receiptPtr; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Module Plug-In System +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The XMPPModule class automatically invokes these methods when it is activated/deactivated. + * + * The registerModule method registers the module with the xmppStream. + * If there are any other modules that have requested to be automatically added as delegates to modules of this type, + * then those modules are automatically added as delegates during the asynchronous execution of this method. + * + * The registerModule method is asynchronous. + * + * The unregisterModule method unregisters the module with the xmppStream, + * and automatically removes it as a delegate of any other module. + * + * The unregisterModule method is fully synchronous. + * That is, after this method returns, the module will not be scheduled in any more delegate calls from other modules. + * However, if the module was already scheduled in an existing asynchronous delegate call from another module, + * the scheduled delegate invocation remains queued and will fire in the near future. + * Since the delegate invocation is already queued, + * the module's retainCount has been incremented, + * and the module will not be deallocated until after the delegate invocation has fired. +**/ +- (void)registerModule:(XMPPModule *)module; +- (void)unregisterModule:(XMPPModule *)module; + +/** + * Automatically registers the given delegate with all current and future registered modules of the given class. + * + * That is, the given delegate will be added to the delegate list ([module addDelegate:delegate delegateQueue:dq]) to + * all current and future registered modules that respond YES to [module isKindOfClass:aClass]. + * + * This method is used by modules to automatically integrate with other modules. + * For example, a module may auto-add itself as a delegate to XMPPCapabilities + * so that it can broadcast its implemented features. + * + * This may also be useful to clients, for example, to add a delegate to instances of something like XMPPChatRoom, + * where there may be multiple instances of the module that get created during the course of an xmpp session. + * + * If you auto register on multiple queues, you can remove all registrations with a single + * call to removeAutoDelegate::: by passing NULL as the 'dq' parameter. + * + * If you auto register for multiple classes, you can remove all registrations with a single + * call to removeAutoDelegate::: by passing nil as the 'aClass' parameter. +**/ +- (void)autoAddDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue toModulesOfClass:(Class)aClass; +- (void)removeAutoDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue fromModulesOfClass:(Class)aClass; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Generates and returns a new autoreleased UUID. + * UUIDs (Universally Unique Identifiers) may also be known as GUIDs (Globally Unique Identifiers). + * + * The UUID is generated using the CFUUID library, which generates a unique 128 bit value. + * The uuid is then translated into a string using the standard format for UUIDs: + * "68753A44-4D6F-1226-9C60-0050E4C00067" + * + * This method is most commonly used to generate a unique id value for an xmpp element. +**/ ++ (NSString *)generateUUID; +- (NSString *)generateUUID; + +/** + * The XMPP Framework is designed to be entirely GCD based. + * However, there are various utility classes provided by Apple that are still dependent upon a thread/runloop model. + * For example, monitoring a network for changes related to connectivity requires we register a runloop-based delegate. + * Thus XMPPStream creates a dedicated thread/runloop for any xmpp classes that may need it. + * This provides multiple benefits: + * + * - Development is simplified for those transitioning from previous thread/runloop versions. + * - Development is simplified for those who rely on utility classes that don't yet support pure GCD, + * as they don't have to setup and maintain a thread/runloop on their own. + * - It prevents multiple xmpp classes from creating multiple internal threads (which would be resource costly). + * + * Please note: + * This thread is designed to be used only if absolutely necessary. + * That is, if you MUST use a class that doesn't yet support pure GCD. + * If there is a GCD alternative, you should be using it instead. + * For example, do NOT use NSTimer. Instead setup a GCD timer using a dispatch_source. +**/ +- (NSThread *)xmppUtilityThread; +- (NSRunLoop *)xmppUtilityRunLoop; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPElementReceipt : NSObject +{ + BOOL complete; + BOOL failed; + dispatch_semaphore_t semaphore; +} + +/** + * Element receipts allow you to check to see if the element has been sent. + * The timeout parameter allows you to do any of the following: + * + * - Do an instantaneous check (pass timeout == 0) + * - Wait until the element has been sent (pass timeout < 0) + * - Wait up to a certain amount of time (pass timeout > 0) + * + * It is important to understand what it means when [receipt wait:timeout] returns YES. + * It does NOT mean the server has received the element. + * It only means the data has been queued for sending in the underlying OS socket buffer. + * + * So at this point the OS will do everything in its capacity to send the data to the server, + * which generally means the server will eventually receive the data. + * Unless, of course, something horrible happens such as a network failure, + * or a system crash, or the server crashes, etc. + * + * Even if you close the xmpp stream after this point, the OS will still do everything it can to send the data. +**/ +- (BOOL)wait:(NSTimeInterval)timeout; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPStreamDelegate +@optional + +/** + * This method is called before the stream begins the connection process. + * + * If developing an iOS app that runs in the background, this may be a good place to indicate + * that this is a task that needs to continue running in the background. + **/ +- (void)xmppStreamWillConnect:(XMPPStream *)sender; + +/** + * This method is called after the socket has connected to the remote host. + * + * If developing an iOS app that runs in the background, this is where you would enable background sockets. + * For example: + * + * [socket performBlock:^{ + * [socket enableBackgroundingOnSocket]; + * }]; +**/ +- (void)xmppStream:(XMPPStream *)sender socketDidConnect:(GCDAsyncSocket *)socket; + +/** + * This method is called after a TCP connection has been established with the server, + * and the opening XML stream negotiation has started. +**/ +- (void)xmppStreamDidStartNegotiation:(XMPPStream *)sender; + +/** + * This method is called immediately prior to the stream being secured via TLS/SSL. + * Note that this delegate may be called even if you do not explicitly invoke the startTLS method. + * Servers have the option of requiring connections to be secured during the opening process. + * If this is the case, the XMPPStream will automatically attempt to properly secure the connection. + * + * The possible keys and values for the security settings are well documented. + * Some possible keys are: + * - kCFStreamSSLLevel + * - kCFStreamSSLAllowsExpiredCertificates + * - kCFStreamSSLAllowsExpiredRoots + * - kCFStreamSSLAllowsAnyRoot + * - kCFStreamSSLValidatesCertificateChain + * - kCFStreamSSLPeerName + * - kCFStreamSSLCertificates + * + * Please refer to Apple's documentation for associated values, as well as other possible keys. + * + * The dictionary of settings is what will be passed to the startTLS method of ther underlying AsyncSocket. + * The AsyncSocket header file also contains a discussion of the security consequences of various options. + * It is recommended reading if you are planning on implementing this method. + * + * The dictionary of settings that are initially passed will be an empty dictionary. + * If you choose not to implement this method, or simply do not edit the dictionary, + * then the default settings will be used. + * That is, the kCFStreamSSLPeerName will be set to the configured host name, + * and the default security validation checks will be performed. + * + * This means that authentication will fail if the name on the X509 certificate of + * the server does not match the value of the hostname for the xmpp stream. + * It will also fail if the certificate is self-signed, or if it is expired, etc. + * + * These settings are most likely the right fit for most production environments, + * but may need to be tweaked for development or testing, + * where the development server may be using a self-signed certificate. +**/ +- (void)xmppStream:(XMPPStream *)sender willSecureWithSettings:(NSMutableDictionary *)settings; + +/** + * This method is called after the stream has been secured via SSL/TLS. + * This method may be called if the server required a secure connection during the opening process, + * or if the secureConnection: method was manually invoked. +**/ +- (void)xmppStreamDidSecure:(XMPPStream *)sender; + +/** + * This method is called after the XML stream has been fully opened. + * More precisely, this method is called after an opening and tag have been sent and received, + * and after the stream features have been received, and any required features have been fullfilled. + * At this point it's safe to begin communication with the server. +**/ +- (void)xmppStreamDidConnect:(XMPPStream *)sender; + +/** + * This method is called after registration of a new user has successfully finished. + * If registration fails for some reason, the xmppStream:didNotRegister: method will be called instead. +**/ +- (void)xmppStreamDidRegister:(XMPPStream *)sender; + +/** + * This method is called if registration fails. +**/ +- (void)xmppStream:(XMPPStream *)sender didNotRegister:(NSXMLElement *)error; + +/** + * This method is called after authentication has successfully finished. + * If authentication fails for some reason, the xmppStream:didNotAuthenticate: method will be called instead. +**/ +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender; + +/** + * This method is called if authentication fails. +**/ +- (void)xmppStream:(XMPPStream *)sender didNotAuthenticate:(NSXMLElement *)error; + +/** + * These methods are called after their respective XML elements are received on the stream. + * + * In the case of an IQ, the delegate method should return YES if it has or will respond to the given IQ. + * If the IQ is of type 'get' or 'set', and no delegates respond to the IQ, + * then xmpp stream will automatically send an error response. +**/ +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq; +- (void)xmppStream:(XMPPStream *)sender didReceiveMessage:(XMPPMessage *)message; +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence; + +/** + * This method is called if an XMPP error is received. + * In other words, a . + * + * However, this method may also be called for any unrecognized xml stanzas. + * + * Note that standard errors ( for example) are delivered normally, + * via the other didReceive...: methods. +**/ +- (void)xmppStream:(XMPPStream *)sender didReceiveError:(NSXMLElement *)error; + +/** + * These methods are called before their respective XML elements are sent over the stream. + * These methods can be used to customize elements on the fly. + * (E.g. add standard information for custom protocols.) +**/ +- (void)xmppStream:(XMPPStream *)sender willSendIQ:(XMPPIQ *)iq; +- (void)xmppStream:(XMPPStream *)sender willSendMessage:(XMPPMessage *)message; +- (void)xmppStream:(XMPPStream *)sender willSendPresence:(XMPPPresence *)presence; + +/** + * These methods are called after their respective XML elements are sent over the stream. + * These methods may be used to listen for certain events (such as an unavailable presence having been sent), + * or for general logging purposes. (E.g. a central history logging mechanism). +**/ +- (void)xmppStream:(XMPPStream *)sender didSendIQ:(XMPPIQ *)iq; +- (void)xmppStream:(XMPPStream *)sender didSendMessage:(XMPPMessage *)message; +- (void)xmppStream:(XMPPStream *)sender didSendPresence:(XMPPPresence *)presence; + +/** + * This method is called if the disconnect method is called. + * It may be used to determine if a disconnection was purposeful, or due to an error. +**/ +- (void)xmppStreamWasToldToDisconnect:(XMPPStream *)sender; + +/** + * This method is called after the stream is closed. + * + * The given error parameter will be non-nil if the error was due to something outside the general xmpp realm. + * Some examples: + * - The TCP socket was unexpectedly disconnected. + * - The SRV resolution of the domain failed. + * - Error parsing xml sent from server. +**/ +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error; + +/** + * This method is only used in P2P mode when the connectTo:withAddress: method was used. + * + * It allows the delegate to read the element if/when they arrive. + * Recall that the XEP specifies that SHOULD be sent. +**/ +- (void)xmppStream:(XMPPStream *)sender didReceiveP2PFeatures:(NSXMLElement *)streamFeatures; + +/** + * This method is only used in P2P mode when the connectTo:withSocket: method was used. + * + * It allows the delegate to customize the element, + * adding any specific featues the delegate might support. +**/ +- (void)xmppStream:(XMPPStream *)sender willSendP2PFeatures:(NSXMLElement *)streamFeatures; + +/** + * These methods are called as xmpp modules are registered and unregistered with the stream. + * This generally corresponds to xmpp modules being initailzed and deallocated. + * + * The methods may be useful, for example, if a more precise auto delegation mechanism is needed + * than what is available with the autoAddDelegate:toModulesOfClass: method. +**/ +- (void)xmppStream:(XMPPStream *)sender didRegisterModule:(id)module; +- (void)xmppStream:(XMPPStream *)sender willUnregisterModule:(id)module; + +@end diff --git a/xmpp/Core/XMPPStream.m b/xmpp/Core/XMPPStream.m new file mode 100644 index 0000000..dfcd384 --- /dev/null +++ b/xmpp/Core/XMPPStream.m @@ -0,0 +1,4227 @@ +#import "XMPPStream.h" +#import "XMPPInternal.h" +#import "XMPPParser.h" +#import "XMPPJID.h" +#import "XMPPIQ.h" +#import "XMPPMessage.h" +#import "XMPPPresence.h" +#import "XMPPModule.h" +#import "XMPPLogging.h" +#import "GCDAsyncSocket.h" +#import "GCDMulticastDelegate.h" +#import "NSData+XMPP.h" +#import "NSXMLElement+XMPP.h" +#import "XMPPSRVResolver.h" +#import "DDList.h" + +#import + +#if TARGET_OS_IPHONE + // Note: You may need to add the CFNetwork Framework to your project + #import +#endif + +#if TARGET_OS_IPHONE + #define SOCKET_BUFFER_SIZE 512 // bytes +#else + #define SOCKET_BUFFER_SIZE 1024 // bytes +#endif + +/** + * Seeing a return statements within an inner block + * can sometimes be mistaken for a return point of the enclosing method. + * This makes inline blocks a bit easier to read. +**/ +#define return_from_block return + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_INFO | XMPP_LOG_FLAG_SEND_RECV; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + + +NSString *const XMPPStreamErrorDomain = @"XMPPStreamErrorDomain"; +NSString *const XMPPStreamDidChangeMyJIDNotification = @"XMPPStreamDidChangeMyJID"; + +enum XMPPStreamFlags +{ + kP2PInitiator = 1 << 0, // If set, we are the P2P initializer + kIsSecure = 1 << 1, // If set, connection has been secured via SSL/TLS + kIsAuthenticated = 1 << 2, // If set, authentication has succeeded + kDidStartNegotiation = 1 << 3, // If set, negotiation has started at least once +}; + +enum XMPPStreamConfig +{ + kP2PMode = 1 << 0, // If set, the XMPPStream was initialized in P2P mode + kResetByteCountPerConnection = 1 << 1, // If set, byte count should be reset per connection +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPDigestAuthentication : NSObject +{ + NSString *rspauth; + NSString *realm; + NSString *nonce; + NSString *qop; + NSString *username; + NSString *password; + NSString *cnonce; + NSString *nc; + NSString *digestURI; +} + +- (id)initWithChallenge:(NSXMLElement *)challenge; + +- (NSString *)rspauth; + +- (NSString *)realm; +- (void)setRealm:(NSString *)realm; + +- (void)setDigestURI:(NSString *)digestURI; + +- (void)setUsername:(NSString *)username password:(NSString *)password; + +- (NSString *)response; +- (NSString *)base64EncodedFullResponse; + +@end + +@interface XMPPStream (PrivateAPI) + +- (void)cleanup; +- (void)setIsSecure:(BOOL)flag; +- (void)setIsAuthenticated:(BOOL)flag; +- (void)continueSendElement:(NSXMLElement *)element withTag:(long)tag; +- (void)startNegotiation; +- (void)sendOpeningNegotiation; +- (void)continueStartTLS:(NSMutableDictionary *)settings; +- (void)setupKeepAliveTimer; +- (void)keepAlive; + +@end + +@interface XMPPElementReceipt (PrivateAPI) + +- (void)signalSuccess; +- (void)signalFailure; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPStream + +@synthesize tag = userTag; + +/** + * Shared initialization between the various init methods. +**/ +- (void)commonInit +{ + xmppQueue = dispatch_queue_create("xmppStreamQueue", NULL); + parserQueue = dispatch_queue_create("xmppParserQueue", NULL); + + multicastDelegate = [[GCDMulticastDelegate alloc] init]; + + state = STATE_XMPP_DISCONNECTED; + + flags = 0; + config = 0; + + numberOfBytesSent = 0; + numberOfBytesReceived = 0; + + parser = [(XMPPParser *)[XMPPParser alloc] initWithDelegate:self]; + + hostPort = 5222; + keepAliveInterval = DEFAULT_KEEPALIVE_INTERVAL; + + registeredModules = [[DDList alloc] init]; + autoDelegateDict = [[NSMutableDictionary alloc] init]; + + receipts = [[NSMutableArray alloc] init]; + + // Setup and start the utility thread. + // We need to be careful to ensure the thread doesn't retain a reference to us longer than necessary. + + xmppUtilityThread = [[NSThread alloc] initWithTarget:[self class] selector:@selector(xmppThreadMain) object:nil]; + [[xmppUtilityThread threadDictionary] setObject:self forKey:@"XMPPStream"]; + [xmppUtilityThread start]; +} + +/** + * Standard XMPP initialization. + * The stream is a standard client to server connection. +**/ +- (id)init +{ + if ((self = [super init])) + { + // Common initialization + [self commonInit]; + + // Initialize socket + asyncSocket = [(GCDAsyncSocket *)[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:xmppQueue]; + } + return self; +} + +/** + * Peer to Peer XMPP initialization. + * The stream is a direct client to client connection as outlined in XEP-0174. +**/ +- (id)initP2PFrom:(XMPPJID *)jid +{ + if ((self = [super init])) + { + // Common initialization + [self commonInit]; + + // Store JID + myJID = [jid retain]; + + // We do not initialize the socket, since the connectP2PWithSocket: method might be used. + + // Initialize configuration + config = kP2PMode; + } + return self; +} + +/** + * Standard deallocation method. + * Every object variable declared in the header file should be released here. +**/ +- (void)dealloc +{ + dispatch_release(xmppQueue); + dispatch_release(parserQueue); + + [multicastDelegate release]; + + [asyncSocket setDelegate:nil delegateQueue:NULL]; + [asyncSocket disconnect]; + [asyncSocket release]; + [socketBuffer release]; + + [parser setDelegate:nil]; + [parser release]; + [parserError release]; + + [hostName release]; + + [tempPassword release]; + + [myJID release]; + [remoteJID release]; + + [myPresence release]; + [rootElement release]; + + if (keepAliveTimer) + { + dispatch_source_cancel(keepAliveTimer); + } + + [registeredModules release]; + [autoDelegateDict release]; + + [srvResolver release]; + [srvResults release]; + + for (XMPPElementReceipt *receipt in receipts) + { + [receipt signalFailure]; + } + [receipts release]; + + [[self class] performSelector:@selector(xmppThreadStop) + onThread:xmppUtilityThread + withObject:nil + waitUntilDone:NO]; + + [userTag release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)hostName +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return hostName; + } + else + { + __block NSString *result; + + dispatch_sync(xmppQueue, ^{ + result = [hostName retain]; + }); + + return [result autorelease]; + } +} + +- (void)setHostName:(NSString *)newHostName +{ + if (dispatch_get_current_queue() == xmppQueue) + { + if (hostName != newHostName) + { + [hostName release]; + hostName = [newHostName copy]; + } + } + else + { + NSString *newHostNameCopy = [newHostName copy]; + + dispatch_async(xmppQueue, ^{ + [hostName release]; + hostName = [newHostNameCopy retain]; + }); + + [newHostNameCopy release]; + } +} + +- (UInt16)hostPort +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return hostPort; + } + else + { + __block UInt16 result; + + dispatch_sync(xmppQueue, ^{ + result = hostPort; + }); + + return result; + } +} + +- (void)setHostPort:(UInt16)newHostPort +{ + dispatch_block_t block = ^{ + hostPort = newHostPort; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +- (XMPPJID *)myJID +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return myJID; + } + else + { + __block XMPPJID *result; + + dispatch_sync(xmppQueue, ^{ + result = [myJID retain]; + }); + + return [result autorelease]; + } +} + +- (void)setMyJID:(XMPPJID *)newMyJID +{ + // XMPPJID is an immutable class (copy == retain) + + dispatch_block_t block = ^{ + + if (myJID != newMyJID) + { + [myJID release]; + myJID = [newMyJID retain]; + } + + [[NSNotificationCenter defaultCenter] postNotificationName:XMPPStreamDidChangeMyJIDNotification object:self]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +- (XMPPJID *)remoteJID +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return remoteJID; + } + else + { + __block XMPPJID *result; + + dispatch_sync(xmppQueue, ^{ + result = [remoteJID retain]; + }); + + return [result autorelease]; + } +} + +- (XMPPPresence *)myPresence +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return myPresence; + } + else + { + __block XMPPPresence *result; + + dispatch_sync(xmppQueue, ^{ + result = [myPresence retain]; + }); + + return [result autorelease]; + } +} + +- (NSTimeInterval)keepAliveInterval +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return keepAliveInterval; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(xmppQueue, ^{ + result = keepAliveInterval; + }); + + return result; + } +} + +- (void)setKeepAliveInterval:(NSTimeInterval)interval +{ + dispatch_block_t block = ^{ + + if (keepAliveInterval != interval) + { + if (interval <= 0.0) + keepAliveInterval = interval; + else + keepAliveInterval = MAX(interval, MIN_KEEPALIVE_INTERVAL); + + [self setupKeepAliveTimer]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +- (UInt64)numberOfBytesSent +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return numberOfBytesSent; + } + else + { + __block UInt64 result; + + dispatch_sync(xmppQueue, ^{ + result = numberOfBytesSent; + }); + + return result; + } +} + +- (UInt64)numberOfBytesReceived +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return numberOfBytesReceived; + } + else + { + __block UInt64 result; + + dispatch_sync(xmppQueue, ^{ + result = numberOfBytesReceived; + }); + + return result; + } +} + +- (BOOL)resetByteCountPerConnection +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return (config & kResetByteCountPerConnection) ? YES : NO; + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = (config & kResetByteCountPerConnection) ? YES : NO; + }); + + return result; + } +} + +- (void)setResetByteCountPerConnection:(BOOL)flag +{ + dispatch_block_t block = ^{ + if (flag) + config |= kResetByteCountPerConnection; + else + config &= ~kResetByteCountPerConnection; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + // Asynchronous operation (if outside xmppQueue) + + dispatch_block_t block = ^{ + [multicastDelegate addDelegate:delegate delegateQueue:delegateQueue]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + // Synchronous operation + + dispatch_block_t block = ^{ + [multicastDelegate removeDelegate:delegate delegateQueue:delegateQueue]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); +} + +- (void)removeDelegate:(id)delegate +{ + // Synchronous operation + + dispatch_block_t block = ^{ + [multicastDelegate removeDelegate:delegate]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); +} + +/** + * Returns YES if the stream was opened in P2P mode. + * In other words, the stream was created via initP2PFrom: to use XEP-0174. +**/ +- (BOOL)isP2P +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return (config & kP2PMode) ? YES : NO; + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = (config & kP2PMode) ? YES : NO; + }); + + return result; + } +} + +- (BOOL)isP2PInitiator +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return ((config & kP2PMode) && (flags & kP2PInitiator)); + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = ((config & kP2PMode) && (flags & kP2PInitiator)); + }); + + return result; + } +} + +- (BOOL)isP2PRecipient +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return ((config & kP2PMode) && !(flags & kP2PInitiator)); + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = ((config & kP2PMode) && !(flags & kP2PInitiator)); + }); + + return result; + } +} + +- (BOOL)didStartNegotiation +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + return (flags & kDidStartNegotiation) ? YES : NO; +} + +- (void)setDidStartNegotiation:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + if (flag) + flags |= kDidStartNegotiation; + else + flags &= ~kDidStartNegotiation; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Connection State +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns YES if the connection is closed, and thus no stream is open. + * If the stream is neither disconnected, nor connected, then a connection is currently being established. +**/ +- (BOOL)isDisconnected +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (state == STATE_XMPP_DISCONNECTED); + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * Returns YES if the connection is open, and the stream has been properly established. + * If the stream is neither disconnected, nor connected, then a connection is currently being established. +**/ +- (BOOL)isConnected +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (state == STATE_XMPP_CONNECTED); + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark C2S Connection +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)connectToHost:(NSString *)host onPort:(UInt16)port error:(NSError **)errPtr +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + BOOL result = [asyncSocket connectToHost:host onPort:port error:errPtr]; + + if (result && [self resetByteCountPerConnection]) + { + numberOfBytesSent = 0; + numberOfBytesReceived = 0; + } + + return result; +} + +- (BOOL)connect:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = NO; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_DISCONNECTED) + { + NSString *errMsg = @"Attempting to connect while already connected or connecting."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if ([self isP2P]) + { + NSString *errMsg = @"P2P streams must use either connectTo:withAddress: or connectP2PWithSocket:."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidType userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (myJID == nil) + { + // Note: If you wish to use anonymous authentication, you should still set myJID prior to calling connect. + // You can simply set it to something like "anonymous@", where "" is the proper domain. + // After the authentication process, you can query the myJID property to see what your assigned JID is. + // + // Setting myJID allows the framework to follow the xmpp protocol properly, + // and it allows the framework to connect to servers without a DNS entry. + // + // For example, one may setup a private xmpp server for internal testing on their local network. + // The xmpp domain of the server may be something like "testing.mycompany.com", + // but since the server is internal, an IP (192.168.1.22) is used as the hostname to connect. + // + // Proper connection requires a TCP connection to the IP (192.168.1.22), + // but the xmpp handshake requires the xmpp domain (testing.mycompany.com). + + NSString *errMsg = @"You must set myJID before calling connect."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidProperty userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + // Notify delegates + [multicastDelegate xmppStreamWillConnect:self]; + + if ([hostName length] == 0) + { + // Resolve the hostName via myJID SRV resolution + + state = STATE_XMPP_RESOLVING_SRV; + + [srvResolver release]; + srvResolver = [[XMPPSRVResolver alloc] initWithdDelegate:self delegateQueue:xmppQueue resolverQueue:NULL]; + + [srvResults release]; + srvResults = nil; + srvResultsIndex = 0; + + NSString *srvName = [XMPPSRVResolver srvNameFromXMPPDomain:[myJID domain]]; + + [srvResolver startWithSRVName:srvName timeout:30.0]; + + result = YES; + } + else + { + // Open TCP connection to the configured hostName. + + state = STATE_XMPP_CONNECTING; + + result = [self connectToHost:hostName onPort:hostPort error:&err]; + + if (!result) + { + state = STATE_XMPP_DISCONNECTED; + } + } + + [err retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +- (BOOL)oldSchoolSecureConnect:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Go through the regular connect routine + result = [self connect:&err]; + + if (result) + { + // Mark the secure flag. + // We will check the flag in socket:didConnectToHost:port: + + [self setIsSecure:YES]; + } + + [err retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark P2P Connection +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Starts a P2P connection to the given user and given address. + * This method only works with XMPPStream objects created using the initP2P method. + * + * The given address is specified as a sockaddr structure wrapped in a NSData object. + * For example, a NSData object returned from NSNetservice's addresses method. +**/ +- (BOOL)connectTo:(XMPPJID *)jid withAddress:(NSData *)remoteAddr error:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_DISCONNECTED) + { + NSString *errMsg = @"Attempting to connect while already connected or connecting."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (![self isP2P]) + { + NSString *errMsg = @"Non P2P streams must use the connect: method"; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidType userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + // Turn on P2P initiator flag + flags |= kP2PInitiator; + + // Store remoteJID + [remoteJID release]; + remoteJID = [jid copy]; + + NSAssert((asyncSocket == nil), @"Forgot to release the previous asyncSocket instance."); + + // Notify delegates + [multicastDelegate xmppStreamWillConnect:self]; + + // Update state + state = STATE_XMPP_CONNECTING; + + // Initailize socket + asyncSocket = [(GCDAsyncSocket *)[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:xmppQueue]; + + result = [asyncSocket connectToAddress:remoteAddr error:&err]; + + if (result == NO) + { + state = STATE_XMPP_DISCONNECTED; + } + else if ([self resetByteCountPerConnection]) + { + numberOfBytesSent = 0; + numberOfBytesReceived = 0; + } + + [err retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +/** + * Starts a P2P connection with the given accepted socket. + * This method only works with XMPPStream objects created using the initP2P method. + * + * The given socket should be a socket that has already been accepted. + * The remoteJID will be extracted from the opening stream negotiation. +**/ +- (BOOL)connectP2PWithSocket:(GCDAsyncSocket *)acceptedSocket error:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_DISCONNECTED) + { + NSString *errMsg = @"Attempting to connect while already connected or connecting."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (![self isP2P]) + { + NSString *errMsg = @"Non P2P streams must use the connect: method"; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidType userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (acceptedSocket == nil) + { + NSString *errMsg = @"Parameter acceptedSocket is nil."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidParameter userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + // Turn off P2P initiator flag + flags &= ~kP2PInitiator; + + NSAssert((asyncSocket == nil), @"Forgot to release the previous asyncSocket instance."); + + // Store and configure socket + asyncSocket = [acceptedSocket retain]; + [asyncSocket setDelegate:self delegateQueue:xmppQueue]; + + // Notify delegates + [multicastDelegate xmppStream:self socketDidConnect:asyncSocket]; + + // Update state + state = STATE_XMPP_CONNECTING; + + if ([self resetByteCountPerConnection]) + { + numberOfBytesSent = 0; + numberOfBytesReceived = 0; + } + + // Start the XML stream + [self startNegotiation]; + + [err retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Disconnect +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Closes the connection to the remote host. +**/ +- (void)disconnect +{ + XMPPLogTrace(); + + dispatch_block_t block = ^{ + + if (state != STATE_XMPP_DISCONNECTED) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [multicastDelegate xmppStreamWasToldToDisconnect:self]; + + if (state == STATE_XMPP_RESOLVING_SRV) + { + [srvResolver stop]; + [srvResolver release]; + srvResolver = nil; + + state = STATE_XMPP_DISCONNECTED; + + [multicastDelegate xmppStreamDidDisconnect:self withError:nil]; + } + else + { + [asyncSocket disconnect]; + + // Everthing will be handled in socketDidDisconnect:withError: + } + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); +} + +- (void)disconnectAfterSending +{ + XMPPLogTrace(); + + dispatch_block_t block = ^{ + + if (state != STATE_XMPP_DISCONNECTED) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [multicastDelegate xmppStreamWasToldToDisconnect:self]; + + if (state == STATE_XMPP_RESOLVING_SRV) + { + [srvResolver stop]; + [srvResolver release]; + srvResolver = nil; + + state = STATE_XMPP_DISCONNECTED; + + [multicastDelegate xmppStreamDidDisconnect:self withError:nil]; + } + else + { + [asyncSocket disconnectAfterWriting]; + + // Everthing will be handled in socketDidDisconnect:withError: + } + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Security +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns YES if SSL/TLS has been used to secure the connection. +**/ +- (BOOL)isSecure +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return (flags & kIsSecure) ? YES : NO; + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = (flags & kIsSecure) ? YES : NO; + }); + + return result; + } +} + +- (void)setIsSecure:(BOOL)flag +{ + dispatch_block_t block = ^{ + if(flag) + flags |= kIsSecure; + else + flags &= ~kIsSecure; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +- (BOOL)supportsStartTLS +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + //stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + NSXMLElement *starttls = [features elementForName:@"starttls" xmlns:@"urn:ietf:params:xml:ns:xmpp-tls"]; + + result = (starttls != nil); + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +- (void)sendStartTLSRequest +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + NSString *starttls = @""; + + NSData *outgoingData = [starttls dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", starttls); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; +} + +- (BOOL)secureConnection:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_CONNECTED) + { + NSString *errMsg = @"Please wait until the stream is connected."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (![self supportsStartTLS]) + { + NSString *errMsg = @"The server does not support startTLS."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamUnsupportedAction userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + // Update state + state = STATE_XMPP_STARTTLS_1; + + // Send the startTLS XML request + [self sendStartTLSRequest]; + + // We do not mark the stream as secure yet. + // We're waiting to receive the response from the + // server before we actually start the TLS handshake. + + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Registration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method checks the stream features of the connected server to determine if in-band registartion is supported. + * If we are not connected to a server, this method simply returns NO. +**/ +- (BOOL)supportsInBandRegistration +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + // stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + NSXMLElement *reg = [features elementForName:@"register" xmlns:@"http://jabber.org/features/iq-register"]; + + result = (reg != nil); + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method attempts to register a new user on the server using the given username and password. + * The result of this action will be returned via the delegate methods. + * + * If the XMPPStream is not connected, or the server doesn't support in-band registration, this method does nothing. +**/ +- (BOOL)registerWithPassword:(NSString *)password error:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_CONNECTED) + { + NSString *errMsg = @"Please wait until the stream is connected."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (myJID == nil) + { + NSString *errMsg = @"You must set myJID before calling registerWithPassword:error:."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidProperty userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (![self supportsInBandRegistration]) + { + NSString *errMsg = @"The server does not support in band registration."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamUnsupportedAction userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + NSString *username = [myJID user]; + + NSXMLElement *queryElement = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:register"]; + [queryElement addChild:[NSXMLElement elementWithName:@"username" stringValue:username]]; + [queryElement addChild:[NSXMLElement elementWithName:@"password" stringValue:password]]; + + NSXMLElement *iqElement = [NSXMLElement elementWithName:@"iq"]; + [iqElement addAttributeWithName:@"type" stringValue:@"set"]; + [iqElement addChild:queryElement]; + + NSString *outgoingStr = [iqElement compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Update state + state = STATE_XMPP_REGISTERING; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Authentication +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method checks the stream features of the connected server to determine if SASL Anonymous Authentication (XEP-0175) + * is supported. If we are not connected to a server, this method simply returns NO. + **/ +- (BOOL)supportsAnonymousAuthentication +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + // stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + NSXMLElement *mech = [features elementForName:@"mechanisms" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + + NSArray *mechanisms = [mech elementsForName:@"mechanism"]; + + for (NSXMLElement *mechanism in mechanisms) + { + if ([[mechanism stringValue] isEqualToString:@"ANONYMOUS"]) + { + result = YES; + break; + } + } + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method checks the stream features of the connected server to determine if plain authentication is supported. + * If we are not connected to a server, this method simply returns NO. +**/ +- (BOOL)supportsPlainAuthentication +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + //stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + NSXMLElement *mech = [features elementForName:@"mechanisms" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + + NSArray *mechanisms = [mech elementsForName:@"mechanism"]; + + for (NSXMLElement *mechanism in mechanisms) + { + if ([[mechanism stringValue] isEqualToString:@"PLAIN"]) + { + result = YES; + break; + } + } + + [pool release]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method checks the stream features of the connected server to determine if digest authentication is supported. + * If we are not connected to a server, this method simply returns NO. + * + * This is the preferred authentication technique, and will be used if the server supports it. +**/ +- (BOOL)supportsDigestMD5Authentication +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + // stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + NSXMLElement *mech = [features elementForName:@"mechanisms" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + + NSArray *mechanisms = [mech elementsForName:@"mechanism"]; + + for (NSXMLElement *mechanism in mechanisms) + { + if ([[mechanism stringValue] isEqualToString:@"DIGEST-MD5"]) + { + result = YES; + break; + } + } + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method only applies to servers that don't support XMPP version 1.0, as defined in RFC 3920. + * With these servers, we attempt to discover supported authentication modes via the jabber:iq:auth namespace. +**/ +- (BOOL)supportsDeprecatedPlainAuthentication +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + // stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Search for an iq element within the rootElement. + // Recall that some servers might stupidly add a "jabber:client" namespace which might cause problems + // if we simply used the elementForName method. + + NSXMLElement *iq = nil; + + NSUInteger i, count = [rootElement childCount]; + for (i = 0; i < count; i++) + { + NSXMLNode *childNode = [rootElement childAtIndex:i]; + + if ([childNode kind] == NSXMLElementKind) + { + if ([[childNode name] isEqualToString:@"iq"]) + { + iq = (NSXMLElement *)childNode; + } + } + } + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"jabber:iq:auth"]; + NSXMLElement *plain = [query elementForName:@"password"]; + + result = (plain != nil); + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method only applies to servers that don't support XMPP version 1.0, as defined in RFC 3920. + * With these servers, we attempt to discover supported authentication modes via the jabber:iq:auth namespace. +**/ +- (BOOL)supportsDeprecatedDigestAuthentication +{ + __block BOOL result = NO; + + dispatch_block_t block = ^{ + + // The root element can be properly queried for authentication mechanisms anytime after the + // stream:features are received, and TLS has been setup (if required) + if (state >= STATE_XMPP_POST_NEGOTIATION) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Search for an iq element within the rootElement. + // Recall that some servers might stupidly add a "jabber:client" namespace which might cause problems + // if we simply used the elementForName method. + + NSXMLElement *iq = nil; + + NSUInteger i, count = [rootElement childCount]; + for (i = 0; i < count; i++) + { + NSXMLNode *childNode = [rootElement childAtIndex:i]; + + if ([childNode kind] == NSXMLElementKind) + { + if ([[childNode name] isEqualToString:@"iq"]) + { + iq = (NSXMLElement *)childNode; + } + } + } + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"jabber:iq:auth"]; + NSXMLElement *digest = [query elementForName:@"digest"]; + + result = (digest != nil); + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return result; +} + +/** + * This method attempts to sign-in to the server using the configured myJID and given password. + * If this method immediately fails +**/ +- (BOOL)authenticateWithPassword:(NSString *)password error:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_CONNECTED) + { + NSString *errMsg = @"Please wait until the stream is connected."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (myJID == nil) + { + NSString *errMsg = @"You must set myJID before calling authenticateWithPassword:error:."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidProperty userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if ([self supportsDigestMD5Authentication]) + { + NSString *auth = @""; + + NSData *outgoingData = [auth dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", auth); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Save authentication information + [tempPassword release]; + tempPassword = [password copy]; + + // Update state + state = STATE_XMPP_AUTH_1; + } + else if ([self supportsPlainAuthentication]) + { + // From RFC 4616 - PLAIN SASL Mechanism: + // [authzid] UTF8NUL authcid UTF8NUL passwd + // + // authzid: authorization identity + // authcid: authentication identity (username) + // passwd : password for authcid + + NSString *username = [myJID user]; + + NSString *payload = [NSString stringWithFormat:@"%C%@%C%@", 0, username, 0, password]; + NSString *base64 = [[payload dataUsingEncoding:NSUTF8StringEncoding] base64Encoded]; + + NSXMLElement *auth = [NSXMLElement elementWithName:@"auth" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + [auth addAttributeWithName:@"mechanism" stringValue:@"PLAIN"]; + [auth setStringValue:base64]; + + NSString *outgoingStr = [auth compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Update state + state = STATE_XMPP_AUTH_1; + } + else + { + // The server does not appear to support SASL authentication (at least any type we can use) + // So we'll revert back to the old fashioned jabber:iq:auth mechanism + + NSString *username = [myJID user]; + NSString *resource = [myJID resource]; + + if ([resource length] == 0) + { + // If resource is nil or empty, we need to auto-create one + + resource = [self generateUUID]; + } + + NSXMLElement *queryElement = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:auth"]; + [queryElement addChild:[NSXMLElement elementWithName:@"username" stringValue:username]]; + [queryElement addChild:[NSXMLElement elementWithName:@"resource" stringValue:resource]]; + + if ([self supportsDeprecatedDigestAuthentication]) + { + NSString *rootID = [[[self rootElement] attributeForName:@"id"] stringValue]; + NSString *digestStr = [NSString stringWithFormat:@"%@%@", rootID, password]; + NSData *digestData = [digestStr dataUsingEncoding:NSUTF8StringEncoding]; + + NSString *digest = [[digestData sha1Digest] hexStringValue]; + + [queryElement addChild:[NSXMLElement elementWithName:@"digest" stringValue:digest]]; + } + else + { + [queryElement addChild:[NSXMLElement elementWithName:@"password" stringValue:password]]; + } + + NSXMLElement *iqElement = [NSXMLElement elementWithName:@"iq"]; + [iqElement addAttributeWithName:@"type" stringValue:@"set"]; + [iqElement addChild:queryElement]; + + NSString *outgoingStr = [iqElement compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Update state + state = STATE_XMPP_AUTH_1; + } + + [err retain]; + [pool drain]; + }; + + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +/** + * This method attempts to sign-in to the using SASL Anonymous Authentication (XEP-0175) +**/ +- (BOOL)authenticateAnonymously:(NSError **)errPtr +{ + XMPPLogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_XMPP_CONNECTED) + { + NSString *errMsg = @"Please wait until the stream is connected."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamInvalidState userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + if (![self supportsAnonymousAuthentication]) + { + NSString *errMsg = @"The server does not support anonymous authentication."; + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + err = [NSError errorWithDomain:XMPPStreamErrorDomain code:XMPPStreamUnsupportedAction userInfo:info]; + + [err retain]; + [pool drain]; + + result = NO; + return_from_block; + } + + NSXMLElement *auth = [NSXMLElement elementWithName:@"auth" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + [auth addAttributeWithName:@"mechanism" stringValue:@"ANONYMOUS"]; + + NSString *outgoingStr = [auth compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Update state + state = STATE_XMPP_AUTH_3; + + [err retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + + return result; +} + +- (BOOL)isAuthenticated +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return (flags & kIsAuthenticated) ? YES : NO; + } + else + { + __block BOOL result; + + dispatch_sync(xmppQueue, ^{ + result = (flags & kIsAuthenticated) ? YES : NO; + }); + + return result; + } +} + +- (void)setIsAuthenticated:(BOOL)flag +{ + dispatch_block_t block = ^{ + if(flag) + flags |= kIsAuthenticated; + else + flags &= ~kIsAuthenticated; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark General Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method will return the root element of the document. + * This element contains the opening and tags received from the server + * when the XML stream was opened. + * + * Note: The rootElement is empty, and does not contain all the XML elements the stream has received during it's + * connection. This is done for performance reasons and for the obvious benefit of being more memory efficient. +**/ +- (NSXMLElement *)rootElement +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return rootElement; + } + else + { + __block NSXMLElement *result = nil; + + dispatch_sync(xmppQueue, ^{ + result = [rootElement copy]; + }); + + return [result autorelease]; + } +} + +/** + * Returns the version attribute from the servers's element. + * This should be at least 1.0 to be RFC 3920 compliant. + * If no version number was set, the server is not RFC compliant, and 0 is returned. +**/ +- (float)serverXmppStreamVersionNumber +{ + if (dispatch_get_current_queue() == xmppQueue) + { + return [rootElement attributeFloatValueForName:@"version" withDefaultValue:0.0F]; + } + else + { + __block float result; + + dispatch_sync(xmppQueue, ^{ + result = [rootElement attributeFloatValueForName:@"version" withDefaultValue:0.0F]; + }); + + return result; + } +} + +- (void)sendIQ:(XMPPIQ *)iq withTag:(long)tag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + NSAssert(state == STATE_XMPP_CONNECTED, @"Invoked with incorrect state"); + + + // We're getting ready to send an IQ. + // We need to notify delegates of this action to allow them to optionally alter the IQ element. + + SEL selector = @selector(xmppStream:willSendIQ:); + + if ([multicastDelegate countForSelector:selector] == 0) + { + // None of the delegates implement the method. + // Use a shortcut. + + [self continueSendElement:iq withTag:tag]; + } + else + { + // Notify all interested delegates. + // This must be done serially to allow them to alter the element. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + // Allow delegates to modify outgoing element + + id del; + dispatch_queue_t dq; + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_sync(dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [del xmppStream:self willSendIQ:iq]; + + [innerPool release]; + }); + } + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self continueSendElement:iq withTag:tag]; + + [innerPool release]; + }); + + [outerPool drain]; + }); + } +} + +- (void)sendMessage:(XMPPMessage *)message withTag:(long)tag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + NSAssert(state == STATE_XMPP_CONNECTED, @"Invoked with incorrect state"); + + + // We're getting ready to send a message. + // We need to notify delegates of this action to allow them to optionally alter the message element. + + SEL selector = @selector(xmppStream:willSendMessage:); + + if ([multicastDelegate countForSelector:selector] == 0) + { + // None of the delegates implement the method. + // Use a shortcut. + + [self continueSendElement:message withTag:tag]; + } + else + { + // Notify all interested delegates. + // This must be done serially to allow them to alter the element. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + // Allow delegates to modify outgoing element + + id del; + dispatch_queue_t dq; + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_sync(dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [del xmppStream:self willSendMessage:message]; + + [innerPool release]; + }); + } + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self continueSendElement:message withTag:tag]; + + [innerPool release]; + }); + + [outerPool drain]; + }); + } +} + +- (void)sendPresence:(XMPPPresence *)presence withTag:(long)tag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + NSAssert(state == STATE_XMPP_CONNECTED, @"Invoked with incorrect state"); + + + // We're getting ready to send a presence element. + // We need to notify delegates of this action to allow them to optionally alter the presence element. + + SEL selector = @selector(xmppStream:willSendPresence:); + + if ([multicastDelegate countForSelector:selector] == 0) + { + // None of the delegates implement the method. + // Use a shortcut. + + [self continueSendElement:presence withTag:tag]; + } + else + { + // Notify all interested delegates. + // This must be done serially to allow them to alter the element in a thread-safe manner. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + // Allow delegates to modify outgoing element + + id del; + dispatch_queue_t dq; + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_sync(dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [del xmppStream:self willSendPresence:presence]; + + [innerPool release]; + }); + } + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self continueSendElement:presence withTag:tag]; + + [innerPool release]; + }); + + [outerPool drain]; + }); + } +} + +- (void)continueSendElement:(NSXMLElement *)element withTag:(long)tag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + if (state == STATE_XMPP_CONNECTED) + { + NSString *outgoingStr = [element compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:tag]; + + if ([element isKindOfClass:[XMPPIQ class]]) + { + [multicastDelegate xmppStream:self didSendIQ:(XMPPIQ *)element]; + } + else if ([element isKindOfClass:[XMPPMessage class]]) + { + [multicastDelegate xmppStream:self didSendMessage:(XMPPMessage *)element]; + } + else if ([element isKindOfClass:[XMPPPresence class]]) + { + // Update myPresence if this is a normal presence element. + // In other words, ignore presence subscription stuff, MUC room stuff, etc. + + XMPPPresence *presence = (XMPPPresence *)element; + + // We use the built-in [presence type] which guarantees lowercase strings, + // and will return @"available" if there was no set type (as available is implicit). + + NSString *type = [presence type]; + if ([type isEqualToString:@"available"] || [type isEqualToString:@"unavailable"]) + { + if ([presence toStr] == nil && myPresence != presence) + { + [myPresence release]; + myPresence = [presence retain]; + } + } + + [multicastDelegate xmppStream:self didSendPresence:(XMPPPresence *)element]; + } + } +} + +/** + * Private method. + * Presencts a common method for the various public sendElement methods. +**/ +- (void)sendElement:(NSXMLElement *)element withTag:(long)tag +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + + if ([element isKindOfClass:[XMPPIQ class]]) + { + [self sendIQ:(XMPPIQ *)element withTag:tag]; + } + else if ([element isKindOfClass:[XMPPMessage class]]) + { + [self sendMessage:(XMPPMessage *)element withTag:tag]; + } + else if ([element isKindOfClass:[XMPPPresence class]]) + { + [self sendPresence:(XMPPPresence *)element withTag:tag]; + } + else + { + NSString *elementName = [element name]; + + if ([elementName isEqualToString:@"iq"]) + { + [self sendIQ:[XMPPIQ iqFromElement:element] withTag:tag]; + } + else if ([elementName isEqualToString:@"message"]) + { + [self sendMessage:[XMPPMessage messageFromElement:element] withTag:tag]; + } + else if ([elementName isEqualToString:@"presence"]) + { + [self sendPresence:[XMPPPresence presenceFromElement:element] withTag:tag]; + } + } +} + +/** + * This methods handles sending an XML fragment. + * If the XMPPStream is not connected, this method does nothing. +**/ +- (void)sendElement:(NSXMLElement *)element +{ + dispatch_block_t block = ^{ + + if (state == STATE_XMPP_CONNECTED) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self sendElement:element withTag:TAG_XMPP_WRITE_STREAM]; + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_async(xmppQueue, block); +} + +/** + * This method handles sending an XML fragment. + * If the XMPPStream is not connected, this method does nothing. + * + * After the element has been successfully sent, + * the xmppStream:didSendElementWithTag: delegate method is called. +**/ +- (void)sendElement:(NSXMLElement *)element andGetReceipt:(XMPPElementReceipt **)receiptPtr +{ + if (receiptPtr == nil) + { + [self sendElement:element]; + } + else + { + __block XMPPElementReceipt *receipt = nil; + + dispatch_block_t block = ^{ + + if (state == STATE_XMPP_CONNECTED) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + receipt = [[XMPPElementReceipt alloc] init]; + [receipts addObject:receipt]; + + [self sendElement:element withTag:TAG_XMPP_WRITE_RECEIPT]; + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + *receiptPtr = [receipt autorelease]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Stream Negotiation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method is called to start the initial negotiation process. +**/ +- (void)startNegotiation +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + NSAssert(![self didStartNegotiation], @"Invoked after initial negotiation has started"); + + XMPPLogTrace(); + + // Initialize the XML stream + [self sendOpeningNegotiation]; + + // Inform delegate that the TCP connection is open, and the stream handshake has begun + [multicastDelegate xmppStreamDidStartNegotiation:self]; + + // Initialize socket buffer + if (socketBuffer == nil) + { + socketBuffer = [[NSMutableData alloc] initWithLength:SOCKET_BUFFER_SIZE]; + } + + // And start reading in the server's XML stream + [asyncSocket readDataWithTimeout:TIMEOUT_XMPP_READ_START + buffer:socketBuffer + bufferOffset:0 + maxLength:[socketBuffer length] + tag:TAG_XMPP_READ_START]; +} + +/** + * This method handles sending the opening element which is needed in several situations. +**/ +- (void)sendOpeningNegotiation +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if ( ![self didStartNegotiation]) + { + // TCP connection was just opened - We need to include the opening XML stanza + NSString *s1 = @""; + + NSData *outgoingData = [s1 dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", s1); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_START]; + + [self setDidStartNegotiation:YES]; + } + + if (state != STATE_XMPP_CONNECTING) + { + XMPPLogVerbose(@"%@: Resetting parser...", THIS_FILE); + + // We're restarting our negotiation, so we need to reset the parser. + [parser setDelegate:nil]; + [parser release]; + + parser = [(XMPPParser *)[XMPPParser alloc] initWithDelegate:self]; + } + else if (parser == nil) + { + XMPPLogVerbose(@"%@: Initializing parser...", THIS_FILE); + + // Need to create parser (it was destroyed when the socket was last disconnected) + parser = [(XMPPParser *)[XMPPParser alloc] initWithDelegate:self]; + } + else + { + XMPPLogVerbose(@"%@: Not touching parser...", THIS_FILE); + } + + NSString *xmlns = @"jabber:client"; + NSString *xmlns_stream = @"http://etherx.jabber.org/streams"; + + NSString *temp, *s2; + if ([self isP2P]) + { + if (myJID && remoteJID) + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream, [myJID bare], [remoteJID bare]]; + } + else if (myJID) + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream, [myJID bare]]; + } + else if (remoteJID) + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream, [remoteJID bare]]; + } + else + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream]; + } + } + else + { + if (myJID) + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream, [myJID domain]]; + } + else if ([hostName length] > 0) + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream, hostName]; + } + else + { + temp = @""; + s2 = [NSString stringWithFormat:temp, xmlns, xmlns_stream]; + } + } + + NSData *outgoingData = [s2 dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", s2); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_START]; + + // Update status + state = STATE_XMPP_OPENING; +} + +/** + * This method handles starting TLS negotiation on the socket, using the proper settings. +**/ +- (void)startTLS +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Update state (part 2 - prompting delegates) + state = STATE_XMPP_STARTTLS_2; + + // Create a mutable dictionary for security settings + NSMutableDictionary *settings = [NSMutableDictionary dictionaryWithCapacity:5]; + + // Get a delegate enumerator + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Prompt the delegate(s) to populate the security settings + + SEL selector = @selector(xmppStream:willSecureWithSettings:); + + id delegate; + dispatch_queue_t delegateQueue; + + while ([delegateEnumerator getNextDelegate:&delegate delegateQueue:&delegateQueue forSelector:selector]) + { + dispatch_sync(delegateQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [delegate xmppStream:self willSecureWithSettings:settings]; + + [innerPool drain]; + }); + } + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self continueStartTLS:settings]; + + [innerPool drain]; + }); + + [pool drain]; + }); +} + +- (void)continueStartTLS:(NSMutableDictionary *)settings +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, settings); + + if (state == STATE_XMPP_STARTTLS_2) + { + // If the delegates didn't respond + if ([settings count] == 0) + { + // Use the default settings, and set the peer name + if ([hostName length] > 0) + { + [settings setObject:hostName forKey:(NSString *)kCFStreamSSLPeerName]; + } + } + + [asyncSocket startTLS:settings]; + [self setIsSecure:YES]; + + // Note: We don't need to wait for asyncSocket to complete TLS negotiation. + // We can just continue reading/writing to the socket, and it will handle queueing everything for us! + + if ([self didStartNegotiation]) + { + // Now we start our negotiation over again... + [self sendOpeningNegotiation]; + } + else + { + // First time starting negotiation + [self startNegotiation]; + } + + // We paused reading from the socket. + // We're ready to continue now. + [asyncSocket readDataWithTimeout:TIMEOUT_XMPP_READ_STREAM + buffer:socketBuffer + bufferOffset:0 + maxLength:[socketBuffer length] + tag:TAG_XMPP_READ_STREAM]; + } +} + +/** + * This method is called anytime we receive the server's stream features. + * This method looks at the stream features, and handles any requirements so communication can continue. +**/ +- (void)handleStreamFeatures +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Extract the stream features + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + + // Check to see if TLS is required + // Don't forget about that NSXMLElement bug you reported to apple (xmlns is required or element won't be found) + NSXMLElement *f_starttls = [features elementForName:@"starttls" xmlns:@"urn:ietf:params:xml:ns:xmpp-tls"]; + + if (f_starttls) + { + if ([f_starttls elementForName:@"required"]) + { + // TLS is required for this connection + + // Update state + state = STATE_XMPP_STARTTLS_1; + + // Send the startTLS XML request + [self sendStartTLSRequest]; + + // We do not mark the stream as secure yet. + // We're waiting to receive the response from the + // server before we actually start the TLS handshake. + + // We're already listening for the response... + return; + } + } + + // Check to see if resource binding is required + // Don't forget about that NSXMLElement bug you reported to apple (xmlns is required or element won't be found) + NSXMLElement *f_bind = [features elementForName:@"bind" xmlns:@"urn:ietf:params:xml:ns:xmpp-bind"]; + + if (f_bind) + { + // Binding is required for this connection + state = STATE_XMPP_BINDING; + + NSString *requestedResource = [myJID resource]; + + if ([requestedResource length] > 0) + { + // Ask the server to bind the user specified resource + + NSXMLElement *resource = [NSXMLElement elementWithName:@"resource"]; + [resource setStringValue:requestedResource]; + + NSXMLElement *bind = [NSXMLElement elementWithName:@"bind" xmlns:@"urn:ietf:params:xml:ns:xmpp-bind"]; + [bind addChild:resource]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:bind]; + + NSString *outgoingStr = [iq compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + } + else + { + // The user didn't specify a resource, so we ask the server to bind one for us + + NSXMLElement *bind = [NSXMLElement elementWithName:@"bind" xmlns:@"urn:ietf:params:xml:ns:xmpp-bind"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:bind]; + + NSString *outgoingStr = [iq compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + } + + // We're already listening for the response... + return; + } + + // It looks like all has gone well, and the connection should be ready to use now + state = STATE_XMPP_CONNECTED; + + if (![self isAuthenticated]) + { + [self setupKeepAliveTimer]; + + // Notify delegates + [multicastDelegate xmppStreamDidConnect:self]; + } +} + +- (void)handleStartTLSResponse:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // We're expecting a proceed response + // If we get anything else we can safely assume it's the equivalent of a failure response + if ( ![[response name] isEqualToString:@"proceed"]) + { + // We can close our TCP connection now + [self disconnect]; + + // The socketDidDisconnect:withError: method will handle everything else + return; + } + + // Start TLS negotiation + [self startTLS]; +} + +/** + * After the registerUser:withPassword: method is invoked, a registration message is sent to the server. + * We're waiting for the result from this registration request. +**/ +- (void)handleRegistration:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if ([[response attributeStringValueForName:@"type"] isEqualToString:@"error"]) + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotRegister:response]; + } + else + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStreamDidRegister:self]; + } +} + +/** + * After the authenticateUser:withPassword:resource method is invoked, a authentication message is sent to the server. + * If the server supports digest-md5 sasl authentication, it is used. Otherwise plain sasl authentication is used, + * assuming the server supports it. + * + * Now if digest-md5 was used, we sent a challenge request, and we're waiting for a challenge response. + * If plain sasl was used, we sent our authentication information, and we're waiting for a success response. +**/ +- (void)handleAuth1:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if ([self supportsDigestMD5Authentication]) + { + // We're expecting a challenge response + // If we get anything else we can safely assume it's the equivalent of a failure response + if ( ![[response name] isEqualToString:@"challenge"]) + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } + else + { + // Create authentication object from the given challenge + // We'll release this object at the end of this else block + XMPPDigestAuthentication *auth = [[XMPPDigestAuthentication alloc] initWithChallenge:response]; + + NSString *virtualHostName = [myJID domain]; + NSString *serverHostName = hostName; + + // Sometimes the realm isn't specified + // In this case I believe the realm is implied as the virtual host name + if (![auth realm]) + { + if([virtualHostName length] > 0) + [auth setRealm:virtualHostName]; + else + [auth setRealm:serverHostName]; + } + + // Set digest-uri + if([virtualHostName length] > 0) + [auth setDigestURI:[NSString stringWithFormat:@"xmpp/%@", virtualHostName]]; + else + [auth setDigestURI:[NSString stringWithFormat:@"xmpp/%@", serverHostName]]; + + // Set username and password + [auth setUsername:[myJID user] password:tempPassword]; + + // Create and send challenge response element + NSXMLElement *cr = [NSXMLElement elementWithName:@"response" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + [cr setStringValue:[auth base64EncodedFullResponse]]; + + NSString *outgoingStr = [cr compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Release unneeded resources + [auth release]; + [tempPassword release]; tempPassword = nil; + + // Update state + state = STATE_XMPP_AUTH_2; + } + } + else if ([self supportsPlainAuthentication]) + { + // We're expecting a success response + // If we get anything else we can safely assume it's the equivalent of a failure response + if ( ![[response name] isEqualToString:@"success"]) + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } + else + { + // We are successfully authenticated (via sasl:plain) + [self setIsAuthenticated:YES]; + + // Now we start our negotiation over again... + [self sendOpeningNegotiation]; + } + } + else + { + // We used the old fashioned jabber:iq:auth mechanism + + if ([[response attributeStringValueForName:@"type"] isEqualToString:@"error"]) + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } + else + { + // We are successfully authenticated (via non-sasl:digest) + // And we've binded our resource as well + [self setIsAuthenticated:YES]; + + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStreamDidAuthenticate:self]; + } + } +} + +/** + * This method handles the result of our challenge response we sent in handleAuth1 using digest-md5 sasl. +**/ +- (void)handleAuth2:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if ([[response name] isEqualToString:@"challenge"]) + { + XMPPDigestAuthentication *auth = [[[XMPPDigestAuthentication alloc] initWithChallenge:response] autorelease]; + + if(![auth rspauth]) + { + // We're getting another challenge??? + // I'm not sure what this could possibly be, so for now I'll assume it's a failure + + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } + else + { + // We received another challenge, but it's really just an rspauth + // This is supposed to be included in the success element (according to the updated RFC) + // but many implementations incorrectly send it inside a second challenge request. + + // Create and send empty challenge response element + NSXMLElement *cr = [NSXMLElement elementWithName:@"response" xmlns:@"urn:ietf:params:xml:ns:xmpp-sasl"]; + + NSString *outgoingStr = [cr compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // The state remains in STATE_XMPP_AUTH_2 + } + } + else if ([[response name] isEqualToString:@"success"]) + { + // We are successfully authenticated (via sasl:digest-md5) + [self setIsAuthenticated:YES]; + + // Now we start our negotiation over again... + [self sendOpeningNegotiation]; + } + else + { + // We received some kind of element + + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } +} + +/** + * This method handles the result of our SASL Anonymous Authentication challenge +**/ +- (void)handleAuth3:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // We're expecting a success response + // If we get anything else we can safely assume it's the equivalent of a failure response + if ( ![[response name] isEqualToString:@"success"]) + { + // Revert back to connected state (from authenticating state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } + else + { + // We are successfully authenticated (via sasl:x-facebook-platform or sasl:plain) + [self setIsAuthenticated:YES]; + + // Now we start our negotiation over again... + [self sendOpeningNegotiation]; + } +} + +- (void)handleBinding:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + NSXMLElement *r_bind = [response elementForName:@"bind" xmlns:@"urn:ietf:params:xml:ns:xmpp-bind"]; + NSXMLElement *r_jid = [r_bind elementForName:@"jid"]; + + if (r_jid) + { + // We're properly binded to a resource now + // Extract and save our resource (it may not be what we originally requested) + NSString *fullJIDStr = [r_jid stringValue]; + + [self setMyJID:[XMPPJID jidWithString:fullJIDStr]]; + + // And we may now have to do one last thing before we're ready - start an IM session + NSXMLElement *features = [rootElement elementForName:@"stream:features"]; + + // Check to see if a session is required + // Don't forget about that NSXMLElement bug you reported to apple (xmlns is required or element won't be found) + NSXMLElement *f_session = [features elementForName:@"session" xmlns:@"urn:ietf:params:xml:ns:xmpp-session"]; + + if (f_session) + { + NSXMLElement *session = [NSXMLElement elementWithName:@"session"]; + [session setXmlns:@"urn:ietf:params:xml:ns:xmpp-session"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:session]; + + NSString *outgoingStr = [iq compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Update state + state = STATE_XMPP_START_SESSION; + } + else + { + // Revert back to connected state (from binding state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStreamDidAuthenticate:self]; + } + } + else + { + // It appears the server didn't allow our resource choice + // We'll simply let the server choose then + + NSXMLElement *bind = [NSXMLElement elementWithName:@"bind" xmlns:@"urn:ietf:params:xml:ns:xmpp-bind"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:bind]; + + NSString *outgoingStr = [iq compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // The state remains in STATE_XMPP_BINDING + } +} + +- (void)handleStartSessionResponse:(NSXMLElement *)response +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if ([[response attributeStringValueForName:@"type"] isEqualToString:@"result"]) + { + // Revert back to connected state (from start session state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStreamDidAuthenticate:self]; + } + else + { + // Revert back to connected state (from start session state) + state = STATE_XMPP_CONNECTED; + + [multicastDelegate xmppStream:self didNotAuthenticate:response]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPSRVResolver Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)tryNextSrvResult +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + NSError *connectError = nil; + BOOL success = NO; + + while (srvResultsIndex < [srvResults count]) + { + XMPPSRVRecord *srvRecord = [srvResults objectAtIndex:srvResultsIndex]; + NSString *srvHost = srvRecord.target; + UInt16 srvPort = srvRecord.port; + + success = [self connectToHost:srvHost onPort:srvPort error:&connectError]; + + if (success) + { + break; + } + else + { + srvResultsIndex++; + } + } + + if (!success) + { + // SRV resolution of the JID domain failed. + // As per the RFC: + // + // "If the SRV lookup fails, the fallback is a normal IPv4/IPv6 address record resolution + // to determine the IP address, using the "xmpp-client" port 5222, registered with the IANA." + // + // In other words, just try connecting to the domain specified in the JID. + + success = [self connectToHost:[myJID domain] onPort:5222 error:&connectError]; + } + + if (!success) + { + state = STATE_XMPP_DISCONNECTED; + + [multicastDelegate xmppStreamDidDisconnect:self withError:connectError]; + } +} + +- (void)srvResolver:(XMPPSRVResolver *)sender didResolveRecords:(NSArray *)records +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + if (sender != srvResolver) return; + + XMPPLogTrace(); + + srvResults = [records copy]; + srvResultsIndex = 0; + + state = STATE_XMPP_CONNECTING; + + [self tryNextSrvResult]; +} + +- (void)srvResolver:(XMPPSRVResolver *)sender didNotResolveDueToError:(NSError *)error +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + if (sender != srvResolver) return; + + XMPPLogTrace(); + + state = STATE_XMPP_CONNECTING; + + [self tryNextSrvResult]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark AsyncSocket Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Called when a socket connects and is ready for reading and writing. "host" will be an IP address, not a DNS name. +**/ +- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port +{ + // This method is invoked on the xmppQueue. + // + // The TCP connection is now established. + + XMPPLogTrace(); + + [multicastDelegate xmppStream:self socketDidConnect:sock]; + + [srvResolver release]; + srvResolver = nil; + + [srvResults release]; + srvResults = nil; + + // Are we using old-style SSL? (Not the upgrade to TLS technique specified in the XMPP RFC) + if ([self isSecure]) + { + // The connection must be secured immediately (just like with HTTPS) + [self startTLS]; + } + else + { + [self startNegotiation]; + } +} + +- (void)socketDidSecure:(GCDAsyncSocket *)sock +{ + // This method is invoked on the xmppQueue. + + XMPPLogTrace(); + + [multicastDelegate xmppStreamDidSecure:self]; +} + +/** + * Called when a socket has completed reading the requested data. Not called if there is an error. +**/ +- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag +{ + // This method is invoked on the xmppQueue. + + XMPPLogTrace(); + + lastSendReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + + if (XMPP_LOG_RECV_PRE) + { + NSString *dataAsStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]; + + XMPPLogRecvPre(@"RECV: %@", dataAsStr); + + [dataAsStr release]; + } + + numberOfBytesReceived += [data length]; + + dispatch_async(parserQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [parser parseData:data]; + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + // Continue reading for XML elements. + + if (state == STATE_XMPP_OPENING) + { + [asyncSocket readDataWithTimeout:TIMEOUT_XMPP_READ_START + buffer:socketBuffer + bufferOffset:0 + maxLength:[socketBuffer length] + tag:TAG_XMPP_READ_START]; + } + else if (state != STATE_XMPP_STARTTLS_2) + { + [asyncSocket readDataWithTimeout:TIMEOUT_XMPP_READ_STREAM + buffer:socketBuffer + bufferOffset:0 + maxLength:[socketBuffer length] + tag:TAG_XMPP_READ_STREAM]; + } + + [innerPool drain]; + }); + + [pool drain]; + }); +} + +/** + * Called after data with the given tag has been successfully sent. +**/ +- (void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag +{ + // This method is invoked on the xmppQueue. + + XMPPLogTrace(); + + lastSendReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + + if (tag == TAG_XMPP_WRITE_RECEIPT) + { + if ([receipts count] == 0) + { + XMPPLogWarn(@"%@: Found TAG_XMPP_WRITE_RECEIPT with no pending receipts!", THIS_FILE); + return; + } + + XMPPElementReceipt *receipt = [receipts objectAtIndex:0]; + [receipt signalSuccess]; + [receipts removeObjectAtIndex:0]; + } +} + +/** + * Called when a socket disconnects with or without error. +**/ +- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err +{ + // This method is invoked on the xmppQueue. + + XMPPLogTrace(); + + if (srvResults && (++srvResultsIndex < [srvResults count])) + { + [self tryNextSrvResult]; + } + else + { + // Update state + state = STATE_XMPP_DISCONNECTED; + + // Release socket buffer + [socketBuffer release]; + socketBuffer = nil; + + // Release the parser (to free underlying resources) + [parser setDelegate:nil]; + [parser release]; + parser = nil; + + // Clear any saved authentication information + [tempPassword release]; tempPassword = nil; + + // Clear stored elements + [myPresence release]; myPresence = nil; + [rootElement release]; rootElement = nil; + + // Stop the keep alive timer + if (keepAliveTimer) + { + dispatch_source_cancel(keepAliveTimer); + keepAliveTimer = NULL; + } + + // Clear srv results + [srvResolver release]; srvResolver = nil; + [srvResults release]; srvResults = nil; + + // Clear any pending receipts + for (XMPPElementReceipt *receipt in receipts) + { + [receipt signalFailure]; + } + [receipts removeAllObjects]; + + // Clear flags + flags = 0; + + // Notify delegate + + if (parserError) + { + [multicastDelegate xmppStreamDidDisconnect:self withError:parserError]; + + [parserError release]; + parserError = nil; + } + else + { + [multicastDelegate xmppStreamDidDisconnect:self withError:err]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPParser Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Called when the xmpp parser has read in the entire root element. +**/ +- (void)xmppParser:(XMPPParser *)sender didReadRoot:(NSXMLElement *)root +{ + NSAssert(dispatch_get_current_queue() == parserQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + dispatch_async(xmppQueue, ^{ + + if (sender != parser) return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogRecvPost(@"RECV: %@", [root compactXMLString]); + + // At this point we've sent our XML stream header, and we've received the response XML stream header. + // We save the root element of our stream for future reference. + // Digest Access authentication requires us to know the ID attribute from the element. + + [rootElement release]; + rootElement = [root retain]; + + if ([self isP2P]) + { + // XEP-0174 specifies that SHOULD be sent by the receiver. + // In other words, if we're the recipient we will now send our features. + // But if we're the initiator, we can't depend on receiving their features. + + // Either way, we're connected at this point. + state = STATE_XMPP_CONNECTED; + + if ([self isP2PRecipient]) + { + // Extract the remoteJID: + // + // + + NSString *from = [[rootElement attributeForName:@"from"] stringValue]; + remoteJID = [[XMPPJID jidWithString:from] retain]; + + // Send our stream features. + // To do so we need to ask the delegate to fill it out for us. + + NSXMLElement *streamFeatures = [NSXMLElement elementWithName:@"stream:features"]; + + [multicastDelegate xmppStream:self willSendP2PFeatures:streamFeatures]; + + NSString *outgoingStr = [streamFeatures compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + } + + // Make sure the delegate didn't disconnect us in the xmppStream:willSendP2PFeatures: method. + + if ([self isConnected]) + { + [multicastDelegate xmppStreamDidConnect:self]; + } + } + else + { + // Check for RFC compliance + if ([self serverXmppStreamVersionNumber] >= 1.0) + { + // Update state - we're now onto stream negotiations + state = STATE_XMPP_NEGOTIATING; + + // Note: We're waiting for the now + } + else + { + // The server isn't RFC comliant, and won't be sending any stream features. + + // We would still like to know what authentication features it supports though, + // so we'll use the jabber:iq:auth namespace, which was used prior to the RFC spec. + + // Update state - we're onto psuedo negotiation + state = STATE_XMPP_NEGOTIATING; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:auth"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"get"]; + [iq addChild:query]; + + NSString *outgoingStr = [iq compactXMLString]; + NSData *outgoingData = [outgoingStr dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogSend(@"SEND: %@", outgoingStr); + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Now wait for the response IQ + } + } + + [pool drain]; + }); +} + +- (void)xmppParser:(XMPPParser *)sender didReadElement:(NSXMLElement *)element +{ + NSAssert(dispatch_get_current_queue() == parserQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + dispatch_async(xmppQueue, ^{ + + if (sender != parser) return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogRecvPost(@"RECV: %@", [element compactXMLString]); + + NSString *elementName = [element name]; + + if ([elementName isEqualToString:@"stream:error"] || [elementName isEqualToString:@"error"]) + { + [multicastDelegate xmppStream:self didReceiveError:element]; + + [pool drain]; + return; + } + + if (state == STATE_XMPP_NEGOTIATING) + { + // We've just read in the stream features + // We consider this part of the root element, so we'll add it (replacing any previously sent features) + [rootElement setChildren:[NSArray arrayWithObject:element]]; + + // Call a method to handle any requirements set forth in the features + [self handleStreamFeatures]; + } + else if (state == STATE_XMPP_STARTTLS_1) + { + // The response from our starttls message + [self handleStartTLSResponse:element]; + } + else if (state == STATE_XMPP_REGISTERING) + { + // The iq response from our registration request + [self handleRegistration:element]; + } + else if (state == STATE_XMPP_AUTH_1) + { + // The challenge response from our auth message + [self handleAuth1:element]; + } + else if (state == STATE_XMPP_AUTH_2) + { + // The response from our challenge response + [self handleAuth2:element]; + } + else if (state == STATE_XMPP_AUTH_3) + { + // The response from our x-facebook-platform or authenticateAnonymously challenge + [self handleAuth3:element]; + } + else if (state == STATE_XMPP_BINDING) + { + // The response from our binding request + [self handleBinding:element]; + } + else if (state == STATE_XMPP_START_SESSION) + { + // The response from our start session request + [self handleStartSessionResponse:element]; + } + else + { + if ([elementName isEqualToString:@"iq"]) + { + XMPPIQ *iq = [XMPPIQ iqFromElement:element]; + + // Notify all interested delegates about the received IQ. + // Keep track of whether the delegates respond to the IQ. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + id del; + dispatch_queue_t dq; + + SEL selector = @selector(xmppStream:didReceiveIQ:); + + dispatch_semaphore_t delSemaphore = dispatch_semaphore_create(0); + dispatch_group_t delGroup = dispatch_group_create(); + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_group_async(delGroup, dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + if ([del xmppStream:self didReceiveIQ:iq]) + { + dispatch_semaphore_signal(delSemaphore); + } + + [innerPool release]; + }); + } + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + dispatch_group_wait(delGroup, DISPATCH_TIME_FOREVER); + + // Did any of the delegates respond to the IQ? + + BOOL responded = (dispatch_semaphore_wait(delSemaphore, DISPATCH_TIME_NOW) == 0); + + // An entity that receives an IQ request of type "get" or "set" MUST reply + // with an IQ response of type "result" or "error". + // + // The response MUST preserve the 'id' attribute of the request. + + if (!responded && [iq requiresResponse]) + { + // Return error message: + // + // + // + // + // + // + // + + NSXMLElement *reason = [NSXMLElement elementWithName:@"feature-not-implemented" + xmlns:@"urn:ietf:params:xml:ns:xmpp-stanzas"]; + + NSXMLElement *error = [NSXMLElement elementWithName:@"error"]; + [error addAttributeWithName:@"type" stringValue:@"cancel"]; + [error addAttributeWithName:@"code" stringValue:@"501"]; + [error addChild:reason]; + + XMPPIQ *iqResponse = [XMPPIQ iqWithType:@"error" + to:[iq from] + elementID:[iq elementID] + child:error]; + + NSXMLElement *iqChild = [iq childElement]; + if (iqChild) + { + NSXMLNode *iqChildCopy = [iqChild copy]; + [iqResponse insertChild:iqChildCopy atIndex:0]; + [iqChildCopy release]; + } + + // Purposefully go through the sendElement: method + // so that it gets dispatched onto the xmppQueue, + // and so that modules may get notified of the outgoing error message. + + [self sendElement:iqResponse]; + } + + dispatch_release(delSemaphore); + dispatch_release(delGroup); + + [outerPool drain]; + }); + + } + else if ([elementName isEqualToString:@"message"]) + { + [multicastDelegate xmppStream:self didReceiveMessage:[XMPPMessage messageFromElement:element]]; + } + else if ([elementName isEqualToString:@"presence"]) + { + [multicastDelegate xmppStream:self didReceivePresence:[XMPPPresence presenceFromElement:element]]; + } + else if ([self isP2P] && + ([elementName isEqualToString:@"stream:features"] || [elementName isEqualToString:@"features"])) + { + [multicastDelegate xmppStream:self didReceiveP2PFeatures:element]; + } + else + { + [multicastDelegate xmppStream:self didReceiveError:element]; + } + } + + [pool drain]; + }); +} + +- (void)xmppParserDidEnd:(XMPPParser *)sender +{ + NSAssert(dispatch_get_current_queue() == parserQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + dispatch_async(xmppQueue, ^{ + + if (sender != parser) return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [asyncSocket disconnect]; + + [pool drain]; + }); +} + +- (void)xmppParser:(XMPPParser *)sender didFail:(NSError *)error +{ + NSAssert(dispatch_get_current_queue() == parserQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + dispatch_async(xmppQueue, ^{ + + if (sender != parser) return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [parserError release]; + parserError = [error retain]; + + [asyncSocket disconnect]; + + [pool drain]; + }); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Keep Alive +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setupKeepAliveTimer +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if (keepAliveTimer) + { + dispatch_source_cancel(keepAliveTimer); + keepAliveTimer = NULL; + } + + if (state == STATE_XMPP_CONNECTED) + { + if (keepAliveInterval > 0) + { + keepAliveTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, xmppQueue); + + dispatch_source_set_event_handler(keepAliveTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self keepAlive]; + [pool drain]; + }); + + dispatch_source_t theKeepAliveTimer = keepAliveTimer; + + dispatch_source_set_cancel_handler(keepAliveTimer, ^{ + XMPPLogVerbose(@"dispatch_release(keepAliveTimer)"); + dispatch_release(theKeepAliveTimer); + }); + + // Everytime we send or receive data, we update our lastSendReceiveTime. + // We set our timer to fire several times per keepAliveInterval. + // This allows us to maintain a single timer, + // and an acceptable timer resolution (assuming larger keepAliveIntervals). + + NSTimeInterval interval = keepAliveInterval / 4.0; + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (interval * NSEC_PER_SEC)); + + dispatch_source_set_timer(keepAliveTimer, tt, DISPATCH_TIME_FOREVER, 1.0); + dispatch_resume(keepAliveTimer); + } + } +} + +- (void)keepAlive +{ + NSAssert(dispatch_get_current_queue() == xmppQueue, @"Invoked on incorrect queue"); + + if (state == STATE_XMPP_CONNECTED) + { + dispatch_time_t now = dispatch_time(DISPATCH_TIME_NOW, 0); + NSTimeInterval elapsed = ((now - lastSendReceiveTime) / NSEC_PER_SEC); + + if (elapsed >= keepAliveInterval) + { + NSData *outgoingData = [@" " dataUsingEncoding:NSUTF8StringEncoding]; + + numberOfBytesSent += [outgoingData length]; + + [asyncSocket writeData:outgoingData + withTimeout:TIMEOUT_XMPP_WRITE + tag:TAG_XMPP_WRITE_STREAM]; + + // Force update the lastSendReceiveTime here just to be safe. + // + // In case the TCP socket comes to a crawl with a giant element in the queue, + // which would prevent the socket:didWriteDataWithTag: method from being called for some time. + + lastSendReceiveTime = now; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Module Plug-In System +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)registerModule:(XMPPModule *)module +{ + if (module == nil) return; + + // Asynchronous operation + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Register module + + [registeredModules add:module]; + + // Add auto delegates (if there are any) + + NSString *className = NSStringFromClass([module class]); + GCDMulticastDelegate *autoDelegates = [autoDelegateDict objectForKey:className]; + + GCDMulticastDelegateEnumerator *autoDelegatesEnumerator = [autoDelegates delegateEnumerator]; + id delegate; + dispatch_queue_t delegateQueue; + + while ([autoDelegatesEnumerator getNextDelegate:&delegate delegateQueue:&delegateQueue]) + { + [module addDelegate:delegate delegateQueue:delegateQueue]; + } + + // Notify our own delegate(s) + + [multicastDelegate xmppStream:self didRegisterModule:module]; + + [pool release]; + }); +} + +- (void)unregisterModule:(XMPPModule *)module +{ + if (module == nil) return; + + // Synchronous operation + + dispatch_sync(xmppQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Notify our own delegate(s) + + [multicastDelegate xmppStream:self willUnregisterModule:module]; + + // Remove auto delegates (if there are any) + + NSString *className = NSStringFromClass([module class]); + GCDMulticastDelegate *autoDelegates = [autoDelegateDict objectForKey:className]; + + GCDMulticastDelegateEnumerator *autoDelegatesEnumerator = [autoDelegates delegateEnumerator]; + id delegate; + dispatch_queue_t delegateQueue; + + while ([autoDelegatesEnumerator getNextDelegate:&delegate delegateQueue:&delegateQueue]) + { + [module removeDelegate:delegate delegateQueue:delegateQueue]; + } + + // Unregister modules + + [registeredModules remove:module]; + + [pool release]; + }); +} + +- (void)autoAddDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue toModulesOfClass:(Class)aClass +{ + if (delegate == nil) return; + if (aClass == nil) return; + + // Asynchronous operation + + dispatch_async(xmppQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSString *className = NSStringFromClass(aClass); + + // Add the delegate to all currently registered modules of the given class. + + DDListEnumerator *registeredModulesEnumerator = [registeredModules listEnumerator]; + XMPPModule *module; + + while ((module = (XMPPModule *)[registeredModulesEnumerator nextElement])) + { + if ([module isKindOfClass:aClass]) + { + [module addDelegate:delegate delegateQueue:delegateQueue]; + } + } + + // Add the delegate to list of auto delegates for the given class. + // It will be added as a delegate to future registered modules of the given class. + + id delegates = [autoDelegateDict objectForKey:className]; + + if (delegates == nil) + { + delegates = [[[GCDMulticastDelegate alloc] init] autorelease]; + + [autoDelegateDict setObject:delegates forKey:className]; + } + + [delegates addDelegate:delegate delegateQueue:delegateQueue]; + + [pool drain]; + }); +} + +- (void)removeAutoDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue fromModulesOfClass:(Class)aClass +{ + if (aClass == nil) + { + // Remove the delegate from all currently registered modules of ANY class. + + DDListEnumerator *registeredModulesEnumerator = [registeredModules listEnumerator]; + XMPPModule *module; + + while ((module = (XMPPModule *)[registeredModulesEnumerator nextElement])) + { + [module removeDelegate:delegate delegateQueue:delegateQueue]; + } + + // Remove the delegate from list of auto delegates for all classes, + // so that it will not be auto added as a delegate to future registered modules. + + for (GCDMulticastDelegate *delegates in [autoDelegateDict objectEnumerator]) + { + [delegates removeDelegate:delegate delegateQueue:delegateQueue]; + } + } + else + { + NSString *className = NSStringFromClass(aClass); + + // Remove the delegate from all currently registered modules of the given class. + + DDListEnumerator *registeredModulesEnumerator = [registeredModules listEnumerator]; + XMPPModule *module; + + while ((module = [registeredModulesEnumerator nextElement])) + { + if ([module isKindOfClass:aClass]) + { + [module removeDelegate:delegate delegateQueue:delegateQueue]; + } + } + + // Remove the delegate from list of auto delegates for the given class, + // so that it will not be added as a delegate to future registered modules of the given class. + + GCDMulticastDelegate *delegates = [autoDelegateDict objectForKey:className]; + [delegates removeDelegate:delegate delegateQueue:delegateQueue]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSString *)generateUUID +{ + NSString *result = nil; + + CFUUIDRef uuid = CFUUIDCreate(NULL); + if (uuid) + { + result = NSMakeCollectable(CFUUIDCreateString(NULL, uuid)); + CFRelease(uuid); + } + + return [result autorelease]; +} + +- (NSString *)generateUUID +{ + return [[self class] generateUUID]; +} + +- (NSThread *)xmppUtilityThread +{ + // This is a read-only variable, set in the init method and never altered. + // Thus we supply direct access to it in this method. + + return xmppUtilityThread; +} + +- (NSRunLoop *)xmppUtilityRunLoop +{ + __block NSRunLoop *result; + + dispatch_block_t block = ^{ + result = [xmppUtilityRunLoop retain]; + }; + + if (dispatch_get_current_queue() == xmppQueue) + block(); + else + dispatch_sync(xmppQueue, block); + + return [result autorelease]; +} + +- (void)setXmppUtilityRunLoop:(NSRunLoop *)runLoop +{ + dispatch_async(xmppQueue, ^{ + if (xmppUtilityRunLoop == nil) + { + xmppUtilityRunLoop = [runLoop retain]; + } + }); +} + ++ (void)xmppThreadMain +{ + // This is the xmppUtilityThread. + // It is designed to be used only if absolutely necessary. + // If there is a GCD alternative, it should be used instead. + + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + // Set XMPPStream's xmppUtilityRunLoop variable. + // + // And when done, remove the xmppStream reference from the dictionary so it's no longer retained. + + XMPPStream *creator = [[[NSThread currentThread] threadDictionary] objectForKey:@"XMPPStream"]; + [creator setXmppUtilityRunLoop:[NSRunLoop currentRunLoop]]; + [[[NSThread currentThread] threadDictionary] removeObjectForKey:@"XMPPStream"]; + + // We can't iteratively run the run loop unless it has at least one source or timer. + // So we'll create a timer that will probably never fire. + + [NSTimer scheduledTimerWithTimeInterval:DBL_MAX + target:self + selector:@selector(xmppThreadIgnore:) + userInfo:nil + repeats:YES]; + + BOOL isCancelled = NO; + BOOL hasRunLoopSources = YES; + + while (!isCancelled && hasRunLoopSources) + { + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + hasRunLoopSources = [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode + beforeDate:[NSDate distantFuture]]; + + isCancelled = [[NSThread currentThread] isCancelled]; + [innerPool drain]; + } + + [outerPool drain]; +} + ++ (void)xmppThreadStop +{ + [[NSThread currentThread] cancel]; +} + ++ (void)xmppThreadIgnore:(NSTimer *)aTimer +{ + // Ignore +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPElementReceipt + +- (id)init +{ + if ((self = [super init])) + { + complete = NO; + failed = NO; + + semaphore = dispatch_semaphore_create(0); + } + return self; +} + +- (void)signalSuccess +{ + complete = YES; + failed = NO; + + OSMemoryBarrier(); + dispatch_semaphore_signal(semaphore); +} + +- (void)signalFailure +{ + complete = YES; + failed = YES; + + OSMemoryBarrier(); + dispatch_semaphore_signal(semaphore); +} + +- (BOOL)wait:(NSTimeInterval)timeout_seconds +{ + OSMemoryBarrier(); + + if (complete) return !failed; + + dispatch_time_t timeout_nanos; + + if (timeout_seconds < 0.0) + timeout_nanos = DISPATCH_TIME_NOW; + else + timeout_nanos = dispatch_time(DISPATCH_TIME_NOW, (timeout_seconds * NSEC_PER_SEC)); + + // dispatch_semaphore_wait + // + // Decrement the counting semaphore. If the resulting value is less than zero, + // this function waits in FIFO order for a signal to occur before returning. + // + // Returns zero on success, or non-zero if the timeout occurred. + // + // Note: If the timeout occurs, the semaphore value is incremented (without signaling). + + long result = dispatch_semaphore_wait(semaphore, timeout_nanos); + + if (result == 0) + { + OSMemoryBarrier(); + + return complete && !failed; + } + else + { + return NO; + } +} + +- (void)dealloc +{ + dispatch_release(semaphore); + + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPDigestAuthentication + +- (id)initWithChallenge:(NSXMLElement *)challenge +{ + if((self = [super init])) + { + // Convert the base 64 encoded data into a string + NSData *base64Data = [[challenge stringValue] dataUsingEncoding:NSASCIIStringEncoding]; + NSData *decodedData = [base64Data base64Decoded]; + + NSString *authStr = [[[NSString alloc] initWithData:decodedData encoding:NSUTF8StringEncoding] autorelease]; + + XMPPLogVerbose(@"%@: Decoded challenge: %@", THIS_FILE, authStr); + + // Extract all the key=value pairs, and put them in a dictionary for easy lookup + NSMutableDictionary *auth = [NSMutableDictionary dictionaryWithCapacity:5]; + + NSArray *components = [authStr componentsSeparatedByString:@","]; + + int i; + for(i = 0; i < [components count]; i++) + { + NSString *component = [components objectAtIndex:i]; + + NSRange separator = [component rangeOfString:@"="]; + if(separator.location != NSNotFound) + { + NSMutableString *key = [[component substringToIndex:separator.location] mutableCopy]; + NSMutableString *value = [[component substringFromIndex:separator.location+1] mutableCopy]; + + if(key) CFStringTrimWhitespace((CFMutableStringRef)key); + if(value) CFStringTrimWhitespace((CFMutableStringRef)value); + + if([value hasPrefix:@"\""] && [value hasSuffix:@"\""] && [value length] > 2) + { + // Strip quotes from value + [value deleteCharactersInRange:NSMakeRange(0, 1)]; + [value deleteCharactersInRange:NSMakeRange([value length]-1, 1)]; + } + + [auth setObject:value forKey:key]; + + [value release]; + [key release]; + } + } + + // Extract and retain the elements we need + rspauth = [[auth objectForKey:@"rspauth"] copy]; + realm = [[auth objectForKey:@"realm"] copy]; + nonce = [[auth objectForKey:@"nonce"] copy]; + qop = [[auth objectForKey:@"qop"] copy]; + + // Generate cnonce + cnonce = [[XMPPStream generateUUID] retain]; + } + return self; +} + +- (void)dealloc +{ + [rspauth release]; + [realm release]; + [nonce release]; + [qop release]; + [username release]; + [password release]; + [cnonce release]; + [nc release]; + [digestURI release]; + [super dealloc]; +} + +- (NSString *)rspauth +{ + return [[rspauth copy] autorelease]; +} + +- (NSString *)realm +{ + return [[realm copy] autorelease]; +} + +- (void)setRealm:(NSString *)newRealm +{ + if(![realm isEqual:newRealm]) + { + [realm release]; + realm = [newRealm copy]; + } +} + +- (void)setDigestURI:(NSString *)newDigestURI +{ + if(![digestURI isEqual:newDigestURI]) + { + [digestURI release]; + digestURI = [newDigestURI copy]; + } +} + +- (void)setUsername:(NSString *)newUsername password:(NSString *)newPassword +{ + if(![username isEqual:newUsername]) + { + [username release]; + username = [newUsername copy]; + } + + if(![password isEqual:newPassword]) + { + [password release]; + password = [newPassword copy]; + } +} + +- (NSString *)response +{ + NSString *HA1str = [NSString stringWithFormat:@"%@:%@:%@", username, realm, password]; + NSString *HA2str = [NSString stringWithFormat:@"AUTHENTICATE:%@", digestURI]; + + NSData *HA1dataA = [[HA1str dataUsingEncoding:NSUTF8StringEncoding] md5Digest]; + NSData *HA1dataB = [[NSString stringWithFormat:@":%@:%@", nonce, cnonce] dataUsingEncoding:NSUTF8StringEncoding]; + + NSMutableData *HA1data = [NSMutableData dataWithCapacity:([HA1dataA length] + [HA1dataB length])]; + [HA1data appendData:HA1dataA]; + [HA1data appendData:HA1dataB]; + + NSString *HA1 = [[HA1data md5Digest] hexStringValue]; + + NSString *HA2 = [[[HA2str dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue]; + + NSString *responseStr = [NSString stringWithFormat:@"%@:%@:00000001:%@:auth:%@", + HA1, nonce, cnonce, HA2]; + + NSString *response = [[[responseStr dataUsingEncoding:NSUTF8StringEncoding] md5Digest] hexStringValue]; + + return response; +} + +- (NSString *)base64EncodedFullResponse +{ + NSMutableString *buffer = [NSMutableString stringWithCapacity:100]; + [buffer appendFormat:@"username=\"%@\",", username]; + [buffer appendFormat:@"realm=\"%@\",", realm]; + [buffer appendFormat:@"nonce=\"%@\",", nonce]; + [buffer appendFormat:@"cnonce=\"%@\",", cnonce]; + [buffer appendFormat:@"nc=00000001,"]; + [buffer appendFormat:@"qop=auth,"]; + [buffer appendFormat:@"digest-uri=\"%@\",", digestURI]; + [buffer appendFormat:@"response=%@,", [self response]]; + [buffer appendFormat:@"charset=utf-8"]; + + XMPPLogSend(@"decoded response: %@", buffer); + + NSData *utf8data = [buffer dataUsingEncoding:NSUTF8StringEncoding]; + + return [utf8data base64Encoded]; +} + +@end diff --git a/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.h b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.h new file mode 100644 index 0000000..2d857ca --- /dev/null +++ b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.h @@ -0,0 +1,97 @@ +#import +#import + +/** + * This class provides an optional base class that may be used to implement + * a CoreDataStorage class for an xmpp extension (or perhaps any core data storage class). + * + * It operates on its own dispatch queue which allows it to easily provide storage for multiple extension instance. + * More importantly, it smartly buffers its save operations to maximize performance! + * + * It does this using two techniques: + * + * First, it monitors the number of pending requests. + * When a operation is requested of the class, it increments an atomic variable, and schedules the request. + * After the request has been processed, it decrements the atomic variable. + * At this point it knows if there are other pending requests, + * and it uses the information to decide if it should save now, + * or postpone the save operation until the pending requests have been executed. + * + * Second, it monitors the number of unsaved changes. + * Since NSManagedObjectContext retains any changed objects until they are saved to disk + * it is an important memory management concern to keep the number of changed objects within a healthy range. + * This class uses a configurable saveThreshold to save at appropriate times. + * + * This class also offers several useful features such as + * preventing multiple instances from using the same database file (conflict) + * and caching of xmppStream.myJID to improve performance. + * + * For more information on how to extend this class, + * please see the XMPPCoreDataStorageProtected.h header file. + * + * The framework comes with several classes that extend this base class such as: + * - XMPPRosterCoreDataStorage (Extensions/Roster) + * - XMPPCapabilitiesCoreDataStorage (Extensions/XEP-0115) + * - XMPPvCardCoreDataStorage (Extensions/XEP-0054) + * + * Feel free to skim over these as reference implementations. +**/ + +@interface XMPPCoreDataStorage : NSObject { +@private + + NSMutableDictionary *myJidCache; + + int32_t pendingRequests; + + NSManagedObjectModel *managedObjectModel; + NSPersistentStoreCoordinator *persistentStoreCoordinator; + NSManagedObjectContext *managedObjectContext; + +@protected + + NSString *databaseFileName; + NSUInteger saveThreshold; + + dispatch_queue_t storageQueue; +} + +/** + * Initializes the core data storage instance, with the given database store filename. + * It is recommended your filname use the "sqlite" file extension. + * If you pass nil, the default value of is automatically used. + * + * If you attempt to create an instance of this class with the same databaseFileName as another existing instance, + * this method will return nil. +**/ +- (id)initWithDatabaseFilename:(NSString *)databaseFileName; + +/** + * Readonly access to the databaseFileName used during initialization. + * If nil was passed to the init method, returns the actual databaseFileName being used (the default filename). +**/ +@property (readonly) NSString *databaseFileName; + +/** + * The saveThreshold specifies the maximum number of unsaved changes to NSManagedObjects before a save is triggered. + * + * Since NSManagedObjectContext retains any changed objects until they are saved to disk + * it is an important memory management concern to keep the number of changed objects within a healthy range. +**/ +@property (readwrite) NSUInteger saveThreshold; + +/** + * Provides access the the thread-safe components of the CoreData stack. + * + * Please note: + * The managedObjectContext is private to the storageQueue. + * You must create and use your own managedObjectContext. + * + * If you think you can simply add a property for the private managedObjectContext, + * then you need to go read the documentation for core data, + * specifically the section entitled "Concurrency with Core Data". +**/ +@property (readonly) NSManagedObjectModel *managedObjectModel; +@property (readonly) NSPersistentStoreCoordinator *persistentStoreCoordinator; + +@end diff --git a/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.m b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.m new file mode 100644 index 0000000..7846813 --- /dev/null +++ b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorage.m @@ -0,0 +1,656 @@ +#import "XMPPCoreDataStorage.h" +#import "XMPPStream.h" +#import "XMPPInternal.h" +#import "XMPPJID.h" +#import "XMPPLogging.h" +#import "NSNumber+XMPP.h" + +#import +#import + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_VERBOSE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + + +@implementation XMPPCoreDataStorage + +static NSMutableSet *databaseFileNames; + ++ (void)initialize +{ + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + + databaseFileNames = [[NSMutableSet alloc] init]; + }); +} + ++ (BOOL)registerDatabaseFileName:(NSString *)dbFileName +{ + BOOL result = NO; + + @synchronized(databaseFileNames) + { + if (![databaseFileNames containsObject:dbFileName]) + { + [databaseFileNames addObject:dbFileName]; + result = YES; + } + } + + return result; +} + ++ (void)unregisterDatabaseFileName:(NSString *)dbFileName +{ + @synchronized(databaseFileNames) + { + [databaseFileNames removeObject:dbFileName]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Override Me +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)defaultFileName +{ + // Override me, if needed, to provide customized behavior. + // + // This method is used for two things: + // + // 1. It provides the name of the ManagedObjectModel file (*.xdatamodel / *.mom / *.momd) sans file extension. + // In other words, this method is queried when setting up the persistentStoreCoordinator. + // + // 2. It is used by default implementation of the defaultDatabaseFileName method. + // See below. + // + // The default implementation returns the name of the subclass, stripping any suffix of "CoreDataStorage". + // E.g., if your subclass was named "XMPPExtensionCoreDataStorage", then this method would return "XMPPExtension". + // + // Note that a file extension should NOT be included. + + NSString *className = NSStringFromClass([self class]); + NSString *suffix = @"CoreDataStorage"; + + if ([className hasSuffix:suffix] && ([className length] > [suffix length])) + { + return [className substringToIndex:([className length] - [suffix length])]; + } + else + { + return className; + } +} + +- (NSString *)defaultDatabaseFileName +{ + // Override me, if needed, to provide customized behavior. + // + // This method is queried if the initWithDatabaseFileName method is invoked with a nil parameter. + // + // You are encouraged to use the sqlite file extension. + + return [NSString stringWithFormat:@"%@.sqlite", [self defaultFileName]]; +} + +- (void)willCreatePersistentStore:(NSString *)filePath +{ + // Override me, if needed, to provide customized behavior. + // + // For example, if you are using the database for non-persistent data you may want to delete the database + // file if it already exists on disk. +} + +- (void)didNotAddPersistentStorePath:(NSString *)path error:(NSError *)error +{ + // Override me, if needed, to provide customized behavior. + // + // For example, if you are using the database for non-persistent data and the model changes, + // you may want to delete the database file if it already exists on disk. + +#if TARGET_OS_IPHONE + XMPPLogError(@"%@:\n" + @"=====================================================================================\n" + @"Error creating persistent store:\n%@\n" + @"Chaned core data model recently?\n" + @"Quick Fix: Delete the app from device and reinstall.\n" + @"=====================================================================================", + [self class], error); +#else + XMPPLogError(@"%@:\n" + @"=====================================================================================\n" + @"Error creating persistent store:\n%@\n" + @"Chaned core data model recently?\n" + @"Quick Fix: Delete the database: %@\n" + @"=====================================================================================", + [self class], error, path); +#endif + +} + +- (void)didCreateManagedObjectContext +{ + // Override me to provide customized behavior. + // + // For example, you may want to perform cleanup of any non-persistent data before you start using the database. +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Setup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@synthesize databaseFileName; + +- (id)init +{ + return [self initWithDatabaseFilename:nil]; +} + +- (id)initWithDatabaseFilename:(NSString *)aDatabaseFileName +{ + if ((self = [super init])) + { + if (aDatabaseFileName) + databaseFileName = [aDatabaseFileName copy]; + else + databaseFileName = [self defaultDatabaseFileName]; + + if (![[self class] registerDatabaseFileName:databaseFileName]) + { + [self dealloc]; + return nil; + } + + saveThreshold = 500; + storageQueue = dispatch_queue_create(class_getName([self class]), NULL); + + myJidCache = [[NSMutableDictionary alloc] init]; + + [[NSNotificationCenter defaultCenter] addObserver:self + selector:@selector(updateJidCache:) + name:XMPPStreamDidChangeMyJIDNotification + object:nil]; + } + return self; +} + +- (BOOL)configureWithParent:(id)aParent queue:(dispatch_queue_t)queue +{ + // This is the standard configure method used by xmpp extensions to configure a storage class. + // + // Feel free to override this method if needed, + // and just invoke super at some point to make sure everything is kosher at this level as well. + + NSParameterAssert(aParent != nil); + NSParameterAssert(queue != NULL); + + if (queue == storageQueue) + { + // This class is designed to be run on a separate dispatch queue from its parent. + // This allows us to optimize the database save operations by buffering them, + // and executing them when demand on the storage instance is low. + + return NO; + } + + return YES; +} + +- (NSUInteger)saveThreshold +{ + if (dispatch_get_current_queue() == storageQueue) + { + return saveThreshold; + } + else + { + __block NSUInteger result; + + dispatch_sync(storageQueue, ^{ + result = saveThreshold; + }); + + return result; + } +} + +- (void)setSaveThreshold:(NSUInteger)newSaveThreshold +{ + dispatch_block_t block = ^{ + saveThreshold = newSaveThreshold; + }; + + if (dispatch_get_current_queue() == storageQueue) + block(); + else + dispatch_async(storageQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Stream JID Caching +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// We cache a stream's myJID to avoid constantly querying the xmppStream for it. +// +// The motivation behind this is the fact that to query the xmppStream for its myJID +// requires going through the xmppStream's internal dispatch queue. (A dispatch_sync). +// It's not necessarily that this is an expensive operation, +// but the storage classes sometimes require this information for just about every operation they perform. +// For a variable that changes infrequently, caching the value can reduce some overhead. +// In addition, if we can stay out of xmppStream's internal dispatch queue, +// we free it to perform more xmpp processing tasks. + +- (XMPPJID *)myJIDForXMPPStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + + NSNumber *key = [[NSNumber alloc] initWithPtr:stream]; + + XMPPJID *result = (XMPPJID *)[myJidCache objectForKey:key]; + if (!result) + { + result = [stream myJID]; + + if (result) + [myJidCache setObject:result forKey:key]; + else + [myJidCache removeObjectForKey:key]; + } + + [key release]; + return result; +} + +- (void)updateJidCache:(NSNotification *)notification +{ + // Notifications are delivered on the thread/queue that posted them. + // In this case, they are delivered on xmppStream's internal processing queue. + + XMPPStream *stream = (XMPPStream *)[notification object]; + + dispatch_async(storageQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSNumber *key = [NSNumber numberWithPtr:stream]; + if ([myJidCache objectForKey:key]) + { + XMPPJID *newMyJID = [stream myJID]; + + if (newMyJID) + [myJidCache setObject:newMyJID forKey:key]; + else + [myJidCache removeObjectForKey:key]; + } + + [pool drain]; + }); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Core Data Setup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)persistentStoreDirectory +{ + NSArray *paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES); + NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory(); + + // Attempt to find a name for this application + NSString *appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleDisplayName"]; + if (appName == nil) { + appName = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleName"]; + } + + if (appName == nil) { + appName = @"xmppframework"; + } + + + NSString *result = [basePath stringByAppendingPathComponent:appName]; + + NSFileManager *fileManager = [NSFileManager defaultManager]; + + if (![fileManager fileExistsAtPath:result]) + { + [fileManager createDirectoryAtPath:result withIntermediateDirectories:YES attributes:nil error:nil]; + } + + return result; +} + +- (NSManagedObjectModel *)managedObjectModel +{ + // This is a public method. + // It may be invoked on any thread/queue. + + dispatch_block_t block = ^{ + + if (managedObjectModel) + { + return; + } + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogVerbose(@"%@: Creating managedObjectModel", [self class]); + + NSString *path = [[NSBundle mainBundle] pathForResource:[self defaultFileName] ofType:@"mom"]; + + if (path == nil) { + // The model may be versioned or created with Xcode 4, try momd as an extension. + path = [[NSBundle mainBundle] pathForResource:[self defaultFileName] ofType:@"momd"]; + } + + if (path) + { + // If path is nil, then NSURL or NSManagedObjectModel will throw an exception + + NSURL *url = [NSURL fileURLWithPath:path]; + + managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:url]; + } + else + { + XMPPLogWarn(@"%@: Couldn't find managedObjectModel file - %@", [self class], [self defaultFileName]); + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == storageQueue) + block(); + else + dispatch_sync(storageQueue, block); + + return managedObjectModel; +} + +- (BOOL)addPersistentStorePath:(NSString *)storePath error:(NSError **)error +{ + // This is a private method. + // + // If you even comtemplate ignoring this warning, + // then you need to go read the documentation for core data, + // specifically the section entitled "Concurrency with Core Data". + // + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + // + // Do NOT remove the assert statment above! + // Read the comments above! + // + + NSAssert1(storePath, @"%@: Error creating persistentStoreCoordinator - Nil persistentStoreDirectory", [self class]); + + // If storePath is nil, then NSURL will throw an exception + NSURL *storeUrl = [NSURL fileURLWithPath:storePath]; + + // Support for automatic lightweight migrations + NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys: + [NSNumber numberWithBool:YES], NSMigratePersistentStoresAutomaticallyOption, + [NSNumber numberWithBool:YES], NSInferMappingModelAutomaticallyOption, + nil]; + + NSPersistentStore *persistentStore; + persistentStore = [persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType + configuration:nil + URL:storeUrl + options:options + error:error]; + + return persistentStore != nil; +} + +- (NSPersistentStoreCoordinator *)persistentStoreCoordinator +{ + // This is a public method. + // It may be invoked on any thread/queue. + + dispatch_block_t block = ^{ + + if (persistentStoreCoordinator) + { + return; + } + + NSManagedObjectModel *mom = [self managedObjectModel]; + if (mom == nil) + { + return; + } + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogVerbose(@"%@: Creating persistentStoreCoordinator", [self class]); + + persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:mom]; + + NSString *docsPath = [self persistentStoreDirectory]; + NSString *storePath = [docsPath stringByAppendingPathComponent:databaseFileName]; + if (storePath) + { + // If storePath is nil, then NSURL will throw an exception + + [self willCreatePersistentStore:storePath]; + + NSError *error = nil; + + if (![self addPersistentStorePath:storePath error:&error]) + { + [self didNotAddPersistentStorePath:storePath error:error]; + } + } + else + { + XMPPLogWarn(@"%@: Error creating persistentStoreCoordinator - Nil persistentStoreDirectory", [self class]); + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == storageQueue) + block(); + else + dispatch_sync(storageQueue, block); + + return persistentStoreCoordinator; +} + +- (NSManagedObjectContext *)managedObjectContext +{ + // This is a private method. + // + // NSManagedObjectContext is NOT thread-safe. + // Therefore it is VERY VERY BAD to use our private managedObjectContext outside our private storageQueue. + // + // You should NOT remove the assert statement below! + // You should NOT give external classes access to the storageQueue! (Excluding subclasses obviously.) + // + // When you want a managedObjectContext of your own (again, excluding subclasses), + // you should create your own using the public persistentStoreCoordinator. + // + // If you even comtemplate ignoring this warning, + // then you need to go read the documentation for core data, + // specifically the section entitled "Concurrency with Core Data". + // + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + // + // Do NOT remove the assert statment above! + // Read the comments above! + // + + if (managedObjectContext) + { + return managedObjectContext; + } + + NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator]; + if (coordinator) + { + XMPPLogVerbose(@"%@: Creating managedObjectContext", [self class]); + + managedObjectContext = [[NSManagedObjectContext alloc] init]; + [managedObjectContext setPersistentStoreCoordinator:coordinator]; + + [self didCreateManagedObjectContext]; + } + + return managedObjectContext; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSUInteger)numberOfUnsavedChanges +{ + NSManagedObjectContext *moc = [self managedObjectContext]; + + NSUInteger unsavedCount = 0; + unsavedCount += [[moc updatedObjects] count]; + unsavedCount += [[moc insertedObjects] count]; + unsavedCount += [[moc deletedObjects] count]; + + return unsavedCount; +} + +- (void)save +{ + // I'm fairly confident that the implementation of [NSManagedObjectContext save:] + // internally checks to see if it has anything to save before it actually does anthing. + // So there's no need for us to do it here, especially since this method is usually + // called from maybeSave below, which already does this check. + + NSError *error = nil; + if (![[self managedObjectContext] save:&error]) + { + XMPPLogWarn(@"%@: Error saving - %@ %@", [self class], error, [error userInfo]); + + [[self managedObjectContext] rollback]; + } +} + +- (void)maybeSave:(int32_t)currentPendingRequests +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + + if ([[self managedObjectContext] hasChanges]) + { + if (currentPendingRequests == 0) + { + XMPPLogVerbose(@"%@: Triggering save (pendingRequests=%i)", [self class], currentPendingRequests); + + [self save]; + } + else + { + NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + if (unsavedCount >= saveThreshold) + { + XMPPLogVerbose(@"%@: Triggering save (unsavedCount=%lu)", [self class], (unsigned long)unsavedCount); + + [self save]; + } + } + } +} + +- (void)maybeSave +{ + // Convenience method in the very rare case that a subclass would need to invoke maybeSave manually. + + [self maybeSave:OSAtomicAdd32(0, &pendingRequests)]; +} + +- (void)executeBlock:(dispatch_block_t)block +{ + // By design this method should not be invoked from the storageQueue. + // + // If you remove the assert statement below, you are destroying the sole purpose for this class, + // which is to optimize the disk IO by buffering save operations. + // + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + // + // For a full discussion of this method, please see XMPPCoreDataStorageProtocol.h + // + // dispatch_Sync + // ^ + + OSAtomicIncrement32(&pendingRequests); + dispatch_sync(storageQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + block(); + + // Since this is a synchronous request, we want to return as quickly as possible. + // So we delay the maybeSave operation til later. + + dispatch_async(storageQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self maybeSave:OSAtomicDecrement32(&pendingRequests)]; + + [innerPool drain]; + }); + + [pool drain]; + }); +} + +- (void)scheduleBlock:(dispatch_block_t)block +{ + // By design this method should not be invoked from the storageQueue. + // + // If you remove the assert statement below, you are destroying the sole purpose for this class, + // which is to optimize the disk IO by buffering save operations. + // + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + // + // For a full discussion of this method, please see XMPPCoreDataStorageProtocol.h + // + // dispatch_Async + // ^ + + OSAtomicIncrement32(&pendingRequests); + dispatch_async(storageQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + block(); + + [self maybeSave:OSAtomicDecrement32(&pendingRequests)]; + [pool drain]; + }); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Memory Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)dealloc +{ + [[NSNotificationCenter defaultCenter] removeObserver:self]; + + [[self class] unregisterDatabaseFileName:databaseFileName]; + + [databaseFileName release]; + [myJidCache release]; + + if (storageQueue) + { + dispatch_release(storageQueue); + } + + [managedObjectContext release]; + [persistentStoreCoordinator release]; + [managedObjectModel release]; + + [super dealloc]; +} + +@end diff --git a/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorageProtected.h b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorageProtected.h new file mode 100644 index 0000000..be8569e --- /dev/null +++ b/xmpp/Extensions/CoreDataStorage/XMPPCoreDataStorageProtected.h @@ -0,0 +1,237 @@ +#import "XMPPCoreDataStorage.h" + +@class XMPPJID; +@class XMPPStream; + +/** + * The methods in this class are to be used ONLY by subclasses of XMPPCoreDataStorage. +**/ + +@interface XMPPCoreDataStorage (Protected) + +#pragma mark Override Me + +/** + * Override me, if needed, to provide customized behavior. + * + * This method is used for two things: + * + * 1. It provides the name of the ManagedObjectModel file (*.xdatamodel / *.mom) sans file extension. + * In other words, this method is queried when setting up the persistentStoreCoordinator. + * + * 2. It is used by default implementation of the defaultDatabaseFileName method. + * See below. + * + * The default implementation returns the name of the subclass, stripping any suffix of "CoreDataStorage". + * E.g., if your subclass was named "XMPPExtensionCoreDataStorage", then this method would return "XMPPExtension". + * + * Note that a file extension should NOT be included. +**/ +- (NSString *)defaultFileName; + +/** + * Override me, if needed, to provide customized behavior. + * + * This method is queried if the initWithDatabaseFileName method is invoked with a nil parameter. + * The default implementation returns: + * + * [NSString stringWithFormat:@"%@.sqlite", [self defaultFileName]]; + * + * You are encouraged to use the sqlite file extension. +**/ +- (NSString *)defaultDatabaseFileName; + +/** + * Override me, if needed, to provide customized behavior. + * + * For example, if you are using the database for non-persistent data you may want to delete the database + * file if it already exists on disk. + * + * The default implementation does nothing. +**/ +- (void)willCreatePersistentStore:(NSString *)filePath; + +/** + * Override me, if needed, to provide customized behavior. + * + * For example, if you are using the database for non-persistent data and the model changes, you may want + * to delete the database file if it already exists on disk and a core data migration is not worthwhile. + * + * The default implementation writes to the XMPP error log. +**/ +- (void)didNotAddPersistentStorePath:(NSString *)filePath error:(NSError *)error; + +/** + * Override me, if needed, to provide customized behavior. + * + * For example, you may want to perform cleanup of any non-persistent data before you start using the database. + * + * The default implementation does nothing. +**/ +- (void)didCreateManagedObjectContext; + +#pragma mark Setup + +/** + * This is the standard configure method used by xmpp extensions to configure a storage class. + * + * Feel free to override this method if needed, + * and just invoke super at some point to make sure everything is kosher at this level as well. + * + * Note that the default implementation allows the storage class to be used by multiple xmpp streams. + * If you design your storage class to be used by a single stream, then you should implement this method + * to ensure that your class can only be configured by one parent. + * If you do, again, don't forget to invoke super at some point. +**/ +- (BOOL)configureWithParent:(id)aParent queue:(dispatch_queue_t)queue; + +#pragma mark Stream JID caching + +/** + * This class provides a caching service for xmppStream.myJID to avoid constantly querying the xmppStream for it. + * + * The motivation behind this is the fact that to query the xmppStream for its myJID + * requires going through the xmppStream's internal dispatch queue. (A dispatch_sync). + * It's not necessarily that this is an expensive operation, + * but storage classes sometimes require this information for just about every operation they perform. + * For a variable that changes infrequently, caching the value can reduce some overhead. + * In addition, if we can stay out of xmppStream's internal dispatch queue, + * we free it to perform more xmpp processing tasks. + * + * If the xmppStream.myJID changes, the cache will automatically be updated. + * + * If you store any variant of xmppStream.myJID (bare, full, domain, etc) in your database + * you are strongly encouraged to use the caching service. + * + * For example, say you're implementing a core data storage caching mechanism for Private XML Storage (XEP-0049). + * The data you're caching is explictly tied to the stream's bare myJID. ([xmppStream.myJID bare]) + * You want your storage class to support multiple xmpp streams, + * so you add a field to the database called streamBareJidStr (or whatever). + * Given an xmppStream, you can use the built-in cache to quickly get the xmppStream.myJid property: + * + * [self myJidForXMPPStream:stream] + * + * This method will retrieve the myJID property of the given xmppStream the first time, + * and then cache it for future lookups. The cache is automatically updated if the xmppStream.myJID ever changes. +**/ +- (XMPPJID *)myJIDForXMPPStream:(XMPPStream *)stream; + +#pragma mark Core Data + +/** + * The standard persistentStoreDirectory method. +**/ +- (NSString *)persistentStoreDirectory; + +/** + * Adds the persistent store path to the persistent store coordinator. + * + * Returns true if the persistent store is created. + * + * This method may be overridden if the model changes and the change can't be handled by lightweight migration. +**/ +- (BOOL)addPersistentStorePath:(NSString *)storePath error:(NSError **)error; + +/** + * Provides access to the managedObjectContext. + * + * Keep in mind that NSManagedObjectContext is NOT thread-safe. + * So you can ONLY access this property from within the context of the storageQueue. + * + * Important: + * The primary purpose of this class is to optimize disk IO by buffering save operations to the managedObjectContext. + * It does this using the methods outlined in the 'Performance Optimizations' section below. + * If you manually save the managedObjectContext you are destroying these optimizations. +**/ +@property (readonly) NSManagedObjectContext *managedObjectContext; + +#pragma mark Performance Optimizations + +/** + * Queries the managedObjectContext to determine the number of unsaved managedObjects. +**/ +- (NSUInteger)numberOfUnsavedChanges; + +/** + * You will not often need to manually call this method. + * It is called automatically, at appropriate and optimized times, via the executeBlock and scheduleBlock methods. + * + * The one exception to this is when you are inserting/deleting/updating a large number of objects in a loop. + * It is recommended that you invoke save from within the loop. + * E.g.: + * + * NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + * for (NSManagedObject *obj in fetchResults) + * { + * [[self managedObjectContext] deleteObject:obj]; + * + * if (++unsavedCount >= saveThreshold) + * { + * [self save]; + * unsavedCount = 0; + * } + * } + * + * See also the documentation for executeBlock and scheduleBlock below. +**/ +- (void)save; // Read the comments above ! + +/** + * You will rarely need to manually call this method. + * It is called automatically, at appropriate and optimized times, via the executeBlock and scheduleBlock methods. + * + * This method makes informed decisions as to whether it should save the managedObjectContext changes to disk. + * Since this disk IO is a slow process, it is better to buffer writes during high demand. + * This method takes into account the number of pending requests waiting on the storage instance, + * as well as the number of unsaved changes (which reside in NSManagedObjectContext's internal memory). + * + * Please see the documentation for executeBlock and scheduleBlock below. +**/ +- (void)maybeSave; // Read the comments above ! + +/** + * This method synchronously invokes the given block (dispatch_sync) on the storageQueue. + * + * Prior to dispatching the block it increments (atomically) the number of pending requests. + * After the block has been executed, it decrements (atomically) the number of pending requests, + * and then invokes the maybeSave method which implements the logic behind the optimized disk IO. + * + * If you use the executeBlock and scheduleBlock methods for all your database operations, + * you will automatically inherit optimized disk IO for free. + * + * If you manually invoke [managedObjectContext save:] you are destroying the optimizations provided by this class. + * + * The block handed to this method is automatically wrapped in a NSAutoreleasePool, + * so there is no need to create these yourself as this method automatically handles it for you. + * + * The architecture of this class purposefully puts the CoreDataStorage instance on a separate dispatch_queue + * from the parent XmppExtension. Not only does this allow a single storage instance to service multiple extension + * instances, but it provides the mechanism for the disk IO optimizations. The theory behind the optimizations + * is to delay a save of the data (a slow operation) until the storage class is no longer being used. With xmpp + * it is often the case that a burst of data causes a flurry of queries and/or updates for a storage class. + * Thus the theory is to delay the slow save operation until later when the flurry has ended and the storage + * class no longer has any pending requests. + * + * This method is designed to be invoked from within the XmppExtension storage protocol methods. + * In other words, it is expecting to be invoked from a dispatch_queue other than the storageQueue. + * If you attempt to invoke this method from within the storageQueue, an exception is thrown. + * Therefore care should be taken when designing your implementation. + * The recommended procedure is as follows: + * + * All of the methods that implement the XmppExtension storage protocol invoke either executeBlock or scheduleBlock. + * However, none of these methods invoke each other (they are only to be invoked from the XmppExtension instance). + * Instead, create internal utility methods that may be invoked. + * + * For an example, see the XMPPRosterCoreDataStorage implementation's _userForJID:xmppStream: method. +**/ +- (void)executeBlock:(dispatch_block_t)block; + +/** + * This method asynchronously invokes the given block (dispatch_async) on the storageQueue. + * + * It works very similarly to the executeBlock method. + * See the executeBlock method above for a full discussion. +**/ +- (void)scheduleBlock:(dispatch_block_t)block; + +@end diff --git a/xmpp/Extensions/Reconnect/XMPPReconnect.h b/xmpp/Extensions/Reconnect/XMPPReconnect.h new file mode 100755 index 0000000..103472e --- /dev/null +++ b/xmpp/Extensions/Reconnect/XMPPReconnect.h @@ -0,0 +1,170 @@ +#import +#import +#import "XMPPModule.h" + +#define DEFAULT_XMPP_RECONNECT_DELAY 2.0 + +#define DEFAULT_XMPP_RECONNECT_TIMER_INTERVAL 20.0 + + +@protocol XMPPReconnectDelegate; + +/** + * XMPPReconnect handles automatically reconnecting to the xmpp server due to accidental disconnections. + * That is, a disconnection that is not the result of calling disconnect on the xmpp stream. + * + * Accidental disconnections may happen for a variety of reasons. + * The most common are general connectivity issues such as disconnection from a WiFi access point. + * + * However, there are several of issues that occasionaly occur. + * There are some routers on the market that disconnect TCP streams after a period of inactivity. + * In addition to this, there have been iPhone revisions where the OS networking stack would pull the same crap. + * These issue have been largely overcome due to the keepalive implementation in XMPPStream. + * + * Regardless of how the disconnect happens, the XMPPReconnect class can help to automatically re-establish + * the xmpp stream so as to have minimum impact on the user (and hopefully they don't even notice). + * + * Once a stream has been opened and authenticated, this class will detect any accidental disconnections. + * If one occurs, an attempt will be made to automatically reconnect after a short delay. + * This delay is configurable via the reconnectDelay property. + * At the same time the class will begin monitoring the network for reachability changes. + * When the reachability of the xmpp host has changed, a reconnect may be tried again. + * In addition to all this, a timer may optionally be used to attempt a reconnect periodically. + * The timer is started if the initial reconnect fails. + * This reconnect timer is fully configurable (may be enabled/disabled, and it's timeout may be changed). + * + * In all cases, prior to attempting a reconnect, + * this class will invoke the shouldAttemptAutoReconnect delegate method. + * The delegate may use this opportunity to optionally decline the auto reconnect attempt. + * + * Auto reconnect may be disabled at any time via the autoReconnect property. + * + * Note that auto reconnect will only occur for a stream that has been opened and authenticated. + * So it will do nothing, for example, if there is no internet connectivity when your application + * first launches, and the xmpp stream is unable to connect to the host. + * In cases such as this it may be desireable to start monitoring the network for reachability changes. + * This way when internet connectivity is restored, one can immediately connect the xmpp stream. + * This is possible via the manualStart method, + * which will trigger the class into action just as if an accidental disconnect occurred. +**/ + +@interface XMPPReconnect : XMPPModule +{ + Byte flags; + NSTimeInterval reconnectDelay; + + dispatch_source_t reconnectTimer; + NSTimeInterval reconnectTimerInterval; + + SCNetworkReachabilityRef reachability; + + int reconnectTicket; + +#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_5 + SCNetworkConnectionFlags previousReachabilityFlags; +#else + SCNetworkReachabilityFlags previousReachabilityFlags; +#endif +} + +/** + * Whether auto reconnect is enabled or disabled. + * + * The default value is YES (enabled). + * + * Note: Altering this property will only affect future accidental disconnections. + * For example, if autoReconnect was true, and you disable this property after an accidental disconnection, + * this will not stop the current reconnect process. + * In order to stop a current reconnect process use the stop method. + * + * Similarly, if autoReconnect was false, and you enable this property after an accidental disconnection, + * this will not start a reconnect process. + * In order to start a reconnect process use the manualStart method. +**/ +@property (nonatomic, assign) BOOL autoReconnect; + +/** + * When the accidental disconnection first happens, + * a short delay may be used before attempting the reconnection. + * + * The default value is DEFAULT_XMPP_RECONNECT_DELAY (defined at the top of this file). + * + * To disable this feature, set the value to zero. + * + * Note: NSTimeInterval is a double that specifies the time in seconds. +**/ +@property (nonatomic, assign) NSTimeInterval reconnectDelay; + +/** + * A reconnect timer may optionally be used to attempt a reconnect periodically. + * The timer will be started after the initial reconnect delay. + * + * The default value is DEFAULT_XMPP_RECONNECT_TIMER_INTERVAL (defined at the top of this file). + * + * To disable this feature, set the value to zero. + * + * Note: NSTimeInterval is a double that specifies the time in seconds. +**/ +@property (nonatomic, assign) NSTimeInterval reconnectTimerInterval; + +/** + * As opposed to using autoReconnect, this method may be used to manually start the reconnect process. + * This may be useful, for example, if one needs network monitoring in order to setup the inital xmpp connection. + * Or if one wants autoReconnect but only in very limited situations which they prefer to control manually. + * + * After invoking this method one can expect the class to act as if an accidental disconnect just occurred. + * That is, a reconnect attempt will be tried after reconnectDelay seconds, + * and the class will begin monitoring the network for changes in reachability to the xmpp host. + * + * A manual start of the reconnect process will effectively end once the xmpp stream has been opened. + * That is, if you invoke manualStart and the xmpp stream is later opened, + * then future disconnections will not result in an auto reconnect process (unless the autoReconnect property applies). + * + * This method does nothing if the xmpp stream is not disconnected. +**/ +- (void)manualStart; + +/** + * Stops the current reconnect process. + * + * This method will stop the current reconnect process regardless of whether the + * reconnect process was started due to the autoReconnect property or due to a call to manualStart. + * + * Stopping the reconnect process does NOT prevent future auto reconnects if the property is enabled. + * That is, if the autoReconnect property is still enabled, and the xmpp stream is later opened, authenticated and + * accidentally disconnected, this class will still attempt an automatic reconnect. + * + * Stopping the reconnect process does NOT prevent future calls to manualStart from working. + * + * It only stops the CURRENT reconnect process. +**/ +- (void)stop; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPReconnectDelegate +@optional + +/** + * This method may be used to fine tune when we + * should and should not attempt an auto reconnect. + * + * For example, if on the iPhone, one may want to prevent auto reconnect when WiFi is not available. +**/ +#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_5 + +- (void)xmppReconnect:(XMPPReconnect *)sender didDetectAccidentalDisconnect:(SCNetworkConnectionFlags)connectionFlags; +- (BOOL)xmppReconnect:(XMPPReconnect *)sender shouldAttemptAutoReconnect:(SCNetworkConnectionFlags)connectionFlags; + +#else + +- (void)xmppReconnect:(XMPPReconnect *)sender didDetectAccidentalDisconnect:(SCNetworkReachabilityFlags)connectionFlags; +- (BOOL)xmppReconnect:(XMPPReconnect *)sender shouldAttemptAutoReconnect:(SCNetworkReachabilityFlags)reachabilityFlags; + +#endif + +@end diff --git a/xmpp/Extensions/Reconnect/XMPPReconnect.m b/xmpp/Extensions/Reconnect/XMPPReconnect.m new file mode 100755 index 0000000..e22847b --- /dev/null +++ b/xmpp/Extensions/Reconnect/XMPPReconnect.m @@ -0,0 +1,645 @@ +#import "XMPPReconnect.h" +#import "XMPPStream.h" +#import "XMPPLogging.h" +#import "NSXMLElement+XMPP.h" + + +#define IMPOSSIBLE_REACHABILITY_FLAGS 0xFFFFFFFF + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_VERBOSE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +enum XMPPReconnectFlags +{ + kAutoReconnect = 1 << 0, // If set, automatically attempts to reconnect after a disconnection + kShouldReconnect = 1 << 1, // If set, disconnection was accidental, and autoReconnect may be used + kMultipleChanges = 1 << 2, // If set, there have been reachability changes during a connection attempt + kManuallyStarted = 1 << 3, // If set, we were started manually via manualStart method + kQueryingDelegates = 1 << 4, // If set, we are awaiting response(s) from the delegate(s) +}; + +#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_5 +// SCNetworkConnectionFlags was renamed to SCNetworkReachabilityFlags in 10.6 +typedef SCNetworkConnectionFlags SCNetworkReachabilityFlags; +#endif + +@interface XMPPReconnect (PrivateAPI) + +- (void)setupReconnectTimer; +- (void)teardownReconnectTimer; + +- (void)setupNetworkMonitoring; +- (void)teardownNetworkMonitoring; + +- (void)maybeAttemptReconnect; +- (void)maybeAttemptReconnectWithTicket:(int)ticket; +- (void)maybeAttemptReconnectWithReachabilityFlags:(SCNetworkReachabilityFlags)reachabilityFlags; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPReconnect + +@dynamic autoReconnect; +@synthesize reconnectDelay; +@synthesize reconnectTimerInterval; + +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super initWithDispatchQueue:queue])) + { + flags = kAutoReconnect; + + reconnectDelay = DEFAULT_XMPP_RECONNECT_DELAY; + reconnectTimerInterval = DEFAULT_XMPP_RECONNECT_TIMER_INTERVAL; + + reconnectTicket = 0; + + previousReachabilityFlags = IMPOSSIBLE_REACHABILITY_FLAGS; + } + return self; +} + +- (void)dealloc +{ + [self teardownReconnectTimer]; + [self teardownNetworkMonitoring]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration and Flags +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)autoReconnect +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (flags & kAutoReconnect) ? YES : NO; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +- (void)setAutoReconnect:(BOOL)flag +{ + dispatch_block_t block = ^{ + if (flag) + flags |= kAutoReconnect; + else + flags &= ~kAutoReconnect; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (BOOL)shouldReconnect +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + return (flags & kShouldReconnect) ? YES : NO; +} + +- (void)setShouldReconnect:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + if (flag) + flags |= kShouldReconnect; + else + flags &= ~kShouldReconnect; +} + +- (BOOL)multipleReachabilityChanges +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + return (flags & kMultipleChanges) ? YES : NO; +} + +- (void)setMultipleReachabilityChanges:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + if (flag) + flags |= kMultipleChanges; + else + flags &= ~kMultipleChanges; +} + +- (BOOL)manuallyStarted +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + return (flags & kManuallyStarted) ? YES : NO; +} + +- (void)setManuallyStarted:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + if (flag) + flags |= kManuallyStarted; + else + flags &= ~kManuallyStarted; +} + +- (BOOL)queryingDelegates +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + return (flags & kQueryingDelegates) ? YES : NO; +} + +- (void)setQueryingDelegates:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked private method outside moduleQueue"); + + if (flag) + flags |= kQueryingDelegates; + else + flags &= ~kQueryingDelegates; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Manual Manipulation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)manualStart +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ([xmppStream isDisconnected] && [self manuallyStarted] == NO) + { + [self setManuallyStarted:YES]; + + [self setupReconnectTimer]; + [self setupNetworkMonitoring]; + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)stop +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Clear all flags (except the kAutoReconnect flag, which should remain as is) + // This is to disable any further reconnect attemts regardless of the state we're in. + + flags = kAutoReconnect; + + // Stop any planned reconnect attempts and stop monitoring the network. + + reconnectTicket++; + + [self teardownReconnectTimer]; + [self teardownNetworkMonitoring]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppStreamDidConnect:(XMPPStream *)sender +{ + // This method is executed on our moduleQueue. + + // The stream is up so we can stop our reconnect attempts now. + // + // We essentially want to do the same thing as the stop method with one exception: + // We do not want to clear the shouldReconnect flag. + // + // Remember the shouldReconnect flag gets set upon authentication. + // A combination of this flag and the autoReconnect flag controls the auto reconnect mechanism. + // + // It is possible for us to get accidentally disconnected after + // the stream opens but prior to authentication completing. + // If this happens we still want to abide by the previous shouldReconnect setting. + + [self setMultipleReachabilityChanges:NO]; + [self setManuallyStarted:NO]; + + reconnectTicket++; + + [self teardownReconnectTimer]; + [self teardownNetworkMonitoring]; +} + +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender +{ + // This method is executed on our moduleQueue. + + // We're now connected and properly authenticated. + // Should we get accidentally disconnected we should automatically reconnect (if autoReconnect is set). + [self setShouldReconnect:YES]; +} + +- (void)xmppStream:(XMPPStream *)sender didReceiveError:(NSXMLElement *)element +{ + // This method is executed on our moduleQueue. + + // + // + // Replaced by new connection + // + // + // If our connection ever gets replaced, we shouldn't attempt a reconnect, + // because the user has logged in on another device. + // If we still applied the reconnect logic, + // the two devices may get into an infinite loop of kicking each other off the system. + + NSString *elementName = [element name]; + + if ([elementName isEqualToString:@"stream:error"] || [elementName isEqualToString:@"error"]) + { + NSXMLElement *conflict = [element elementForName:@"conflict" xmlns:@"urn:ietf:params:xml:ns:xmpp-streams"]; + if (conflict) + { + [self setShouldReconnect:NO]; + } + } +} + +- (void)xmppStreamWasToldToDisconnect:(XMPPStream *)sender +{ + // This method is executed on our moduleQueue. + + // We should not automatically attempt to reconnect when the connection closes. + [self stop]; +} + +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error +{ + // This method is executed on our moduleQueue. + + if ([self autoReconnect] && [self shouldReconnect]) + { + [self setupReconnectTimer]; + [self setupNetworkMonitoring]; + + SCNetworkReachabilityFlags reachabilityFlags = 0; + SCNetworkReachabilityGetFlags(reachability, &reachabilityFlags); + + [multicastDelegate xmppReconnect:self didDetectAccidentalDisconnect:reachabilityFlags]; + } + + if ([self multipleReachabilityChanges]) + { + // While the previous connection attempt was in progress, the reachability of the xmpp host changed. + // This means that while the previous attempt failed, an attempt now might succeed. + + int ticket = ++reconnectTicket; + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (0.1 * NSEC_PER_SEC)); + dispatch_after(tt, moduleQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self maybeAttemptReconnectWithTicket:ticket]; + + [pool drain]; + }); + + // Note: We delay the method call. + // This allows the other delegates to be notified of the closed stream prior to our reconnect attempt. + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Reachability +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +static void ReachabilityChanged(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info) +{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPReconnect *instance = (XMPPReconnect *)info; + [instance maybeAttemptReconnectWithReachabilityFlags:flags]; + + [pool release]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Logic +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setupReconnectTimer +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (reconnectTimer == NULL) + { + if ((reconnectDelay <= 0.0) && (reconnectTimerInterval <= 0.0)) + { + // All timed reconnect attempts are disabled + return; + } + + reconnectTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(reconnectTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self maybeAttemptReconnect]; + [pool drain]; + }); + + dispatch_source_t theReconnectTimer = reconnectTimer; + + dispatch_source_set_cancel_handler(reconnectTimer, ^{ + XMPPLogVerbose(@"dispatch_release(reconnectTimer)"); + dispatch_release(theReconnectTimer); + }); + + dispatch_time_t startTime; + if (reconnectDelay > 0.0) + startTime = dispatch_time(DISPATCH_TIME_NOW, (reconnectDelay * NSEC_PER_SEC)); + else + startTime = dispatch_time(DISPATCH_TIME_NOW, (reconnectTimerInterval * NSEC_PER_SEC)); + + uint64_t intervalTime; + if (reconnectTimerInterval > 0.0) + intervalTime = reconnectTimerInterval * NSEC_PER_SEC; + else + intervalTime = 0.0; + + dispatch_source_set_timer(reconnectTimer, startTime, intervalTime, 0.25); + dispatch_resume(reconnectTimer); + } +} + +- (void)teardownReconnectTimer +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (reconnectTimer) + { + dispatch_source_cancel(reconnectTimer); + reconnectTimer = NULL; + } +} + +- (void)setupNetworkMonitoring +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (reachability == NULL) + { + NSString *domain = xmppStream.hostName; + if (domain == nil) + { + domain = @"apple.com"; + } + + reachability = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [domain UTF8String]); + + if (reachability) + { + SCNetworkReachabilityContext context = {0, self, NULL, NULL, NULL}; + SCNetworkReachabilitySetCallback(reachability, ReachabilityChanged, &context); + + CFRunLoopRef xmppRunLoop = [[xmppStream xmppUtilityRunLoop] getCFRunLoop]; + if (xmppRunLoop) + { + SCNetworkReachabilityScheduleWithRunLoop(reachability, xmppRunLoop, kCFRunLoopDefaultMode); + } + else + { + XMPPLogWarn(@"%@: %@ - No xmpp run loop available!", THIS_FILE, THIS_METHOD); + } + } + } +} + +- (void)teardownNetworkMonitoring +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (reachability) + { + CFRunLoopRef xmppRunLoop = [[xmppStream xmppUtilityRunLoop] getCFRunLoop]; + if (xmppRunLoop) + { + SCNetworkReachabilityUnscheduleFromRunLoop(reachability, xmppRunLoop, kCFRunLoopDefaultMode); + } + else + { + XMPPLogWarn(@"%@: %@ - No xmpp run loop available!", THIS_FILE, THIS_METHOD); + } + + SCNetworkReachabilitySetCallback(reachability, NULL, NULL); + CFRelease(reachability); + reachability = NULL; + } +} + +/** + * This method may be invoked by the reconnectTimer. + * + * During auto reconnection it is invoked reconnectDelay seconds after an accidental disconnection. + * After that, it is then invoked every reconnectTimerInterval seconds. + * + * This handles disconnections that were not the result of an internet connectivity issue. +**/ +- (void)maybeAttemptReconnect +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (reachability) + { + SCNetworkReachabilityFlags reachabilityFlags; + if (SCNetworkReachabilityGetFlags(reachability, &reachabilityFlags)) + { + [self maybeAttemptReconnectWithReachabilityFlags:reachabilityFlags]; + } + } +} + +/** + * This method is invoked (after a short delay) if the reachability changed while + * a reconnection attempt was in progress. +**/ +- (void)maybeAttemptReconnectWithTicket:(int)ticket +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (ticket != reconnectTicket) + { + // The dispatched task was cancelled. + return; + } + + if (reachability) + { + SCNetworkReachabilityFlags reachabilityFlags; + if (SCNetworkReachabilityGetFlags(reachability, &reachabilityFlags)) + { + [self maybeAttemptReconnectWithReachabilityFlags:reachabilityFlags]; + } + } +} + +- (void)maybeAttemptReconnectWithReachabilityFlags:(SCNetworkReachabilityFlags)reachabilityFlags +{ + if (dispatch_get_current_queue() != moduleQueue) + { + dispatch_async(moduleQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self maybeAttemptReconnectWithReachabilityFlags:reachabilityFlags]; + [pool drain]; + }); + + return; + } + + if (([self manuallyStarted]) || ([self autoReconnect] && [self shouldReconnect])) + { + if ([xmppStream isDisconnected] && ([self queryingDelegates] == NO)) + { + // The xmpp stream is disconnected, and is not attempting reconnection + + // Delegate rules: + // + // If ALL of the delegates return YES, then the result is YES. + // If ANY of the delegates return NO, then the result is NO. + // If there are no delegates, the default answer is YES. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + id del; + dispatch_queue_t dq; + + SEL selector = @selector(xmppReconnect:shouldAttemptAutoReconnect:); + + NSUInteger delegateCount = [delegateEnumerator countForSelector:selector]; + + dispatch_semaphore_t delSemaphore = dispatch_semaphore_create(0); + dispatch_group_t delGroup = dispatch_group_create(); + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_group_async(delGroup, dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + if (![del xmppReconnect:self shouldAttemptAutoReconnect:reachabilityFlags]) + { + dispatch_semaphore_signal(delSemaphore); + } + + [innerPool release]; + }); + } + + [self setQueryingDelegates:YES]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + dispatch_group_wait(delGroup, DISPATCH_TIME_FOREVER); + + // What was the delegate response? + + BOOL shouldAttemptReconnect; + if (delegateCount == 0) + { + shouldAttemptReconnect = YES; + } + else + { + shouldAttemptReconnect = (dispatch_semaphore_wait(delSemaphore, DISPATCH_TIME_NOW) != 0); + } + + dispatch_async(moduleQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self setQueryingDelegates:NO]; + + if (shouldAttemptReconnect) + { + [self setMultipleReachabilityChanges:NO]; + previousReachabilityFlags = reachabilityFlags; + + [xmppStream connect:nil]; + } + else if ([self multipleReachabilityChanges]) + { + [self setMultipleReachabilityChanges:NO]; + previousReachabilityFlags = IMPOSSIBLE_REACHABILITY_FLAGS; + + [self maybeAttemptReconnect]; + } + else + { + previousReachabilityFlags = IMPOSSIBLE_REACHABILITY_FLAGS; + } + + [innerPool drain]; + }); + + dispatch_release(delSemaphore); + dispatch_release(delGroup); + + [outerPool drain]; + }); + + } + else + { + // The xmpp stream is already attempting a connection. + + if (reachabilityFlags != previousReachabilityFlags) + { + // It seems that the reachability of our xmpp host has changed in the middle of either + // a reconnection attempt or while querying our delegates for permission to attempt reconnect. + // + // This may mean that the current attempt will fail, + // but an another attempt after the failure will succeed. + // + // We make a note of the multiple changes, + // and if the current attempt fails, we'll try again after a short delay. + + [self setMultipleReachabilityChanges:YES]; + } + } + } +} + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.h b/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.h new file mode 100644 index 0000000..000f060 --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.h @@ -0,0 +1,26 @@ +// +// XMPPGroupCoreDataStorageObject.h +// +// Created by Eric Chamberlain on 3/20/11. +// Copyright (c) 2011 RF.com. All rights reserved. +// + +#import +#import + + +@class XMPPUserCoreDataStorageObject; + + +@interface XMPPGroupCoreDataStorageObject : NSManagedObject { +@private +} + +@property (nonatomic, retain) NSString * name; +@property (nonatomic, retain) NSSet* users; + ++ (id)fetchOrInsertGroupName:(NSString *)groupName inManagedObjectContext:(NSManagedObjectContext *)moc; + ++ (id)insertGroupName:(NSString *)groupName inManagedObjectContext:(NSManagedObjectContext *)moc; + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.m b/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.m new file mode 100644 index 0000000..6a383d5 --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPGroupCoreDataStorageObject.m @@ -0,0 +1,94 @@ +// +// XMPPGroupCoreDataStorageObject.m +// +// Created by Eric Chamberlain on 3/20/11. +// Copyright (c) 2011 RF.com. All rights reserved. +// + +#import "XMPPGroupCoreDataStorageObject.h" +#import "XMPPUserCoreDataStorageObject.h" + + +@implementation XMPPGroupCoreDataStorageObject + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Public +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (id)insertGroupName:(NSString *)groupName inManagedObjectContext:(NSManagedObjectContext *)moc +{ + if (groupName == nil) { + return nil; + } + + XMPPGroupCoreDataStorageObject *newGroup = [NSEntityDescription insertNewObjectForEntityForName:NSStringFromClass([self class]) + inManagedObjectContext:moc]; + newGroup.name = groupName; + + return newGroup; +} + + ++ (id)fetchOrInsertGroupName:(NSString *)groupName inManagedObjectContext:(NSManagedObjectContext *)moc { + if (groupName == nil) { + return nil; + } + + NSEntityDescription *entity = [NSEntityDescription entityForName:NSStringFromClass([self class]) + inManagedObjectContext:moc]; + + NSPredicate *predicate = [NSPredicate predicateWithFormat:@"name == %@", groupName]; + + NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setIncludesPendingChanges:YES]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [moc executeFetchRequest:fetchRequest error:nil]; + + [fetchRequest release]; + + if ([results count] > 0) { + return [results objectAtIndex:0]; + } + + return [self insertGroupName:groupName inManagedObjectContext:moc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Accessors +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@dynamic name; +@dynamic users; + +- (void)addUsersObject:(XMPPUserCoreDataStorageObject *)value { + NSSet *changedObjects = [[NSSet alloc] initWithObjects:&value count:1]; + [self willChangeValueForKey:@"users" withSetMutation:NSKeyValueUnionSetMutation usingObjects:changedObjects]; + [[self primitiveValueForKey:@"users"] addObject:value]; + [self didChangeValueForKey:@"users" withSetMutation:NSKeyValueUnionSetMutation usingObjects:changedObjects]; + [changedObjects release]; +} + +- (void)removeUsersObject:(XMPPUserCoreDataStorageObject *)value { + NSSet *changedObjects = [[NSSet alloc] initWithObjects:&value count:1]; + [self willChangeValueForKey:@"users" withSetMutation:NSKeyValueMinusSetMutation usingObjects:changedObjects]; + [[self primitiveValueForKey:@"users"] removeObject:value]; + [self didChangeValueForKey:@"users" withSetMutation:NSKeyValueMinusSetMutation usingObjects:changedObjects]; + [changedObjects release]; +} + +- (void)addUsers:(NSSet *)value { + [self willChangeValueForKey:@"users" withSetMutation:NSKeyValueUnionSetMutation usingObjects:value]; + [[self primitiveValueForKey:@"users"] unionSet:value]; + [self didChangeValueForKey:@"users" withSetMutation:NSKeyValueUnionSetMutation usingObjects:value]; +} + +- (void)removeUsers:(NSSet *)value { + [self willChangeValueForKey:@"users" withSetMutation:NSKeyValueMinusSetMutation usingObjects:value]; + [[self primitiveValueForKey:@"users"] minusSet:value]; + [self didChangeValueForKey:@"users" withSetMutation:NSKeyValueMinusSetMutation usingObjects:value]; +} + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.h b/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.h new file mode 100644 index 0000000..8772091 --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.h @@ -0,0 +1,40 @@ +#import +#import +#import "XMPPResource.h" + +@class XMPPStream; +@class XMPPPresence; +@class XMPPUserCoreDataStorageObject; + + +@interface XMPPResourceCoreDataStorageObject : NSManagedObject + +@property (nonatomic, retain) XMPPJID *jid; +@property (nonatomic, retain) XMPPPresence *presence; + +@property (nonatomic, assign) int priority; +@property (nonatomic, assign) int intShow; + +@property (nonatomic, retain) NSString * jidStr; +@property (nonatomic, retain) NSString * presenceStr; + +@property (nonatomic, retain) NSString * streamBareJidStr; + +@property (nonatomic, retain) NSString * type; +@property (nonatomic, retain) NSString * show; +@property (nonatomic, retain) NSString * status; + +@property (nonatomic, retain) NSDate * presenceDate; + +@property (nonatomic, retain) NSNumber * priorityNum; +@property (nonatomic, retain) NSNumber * showNum; + +@property (nonatomic, retain) XMPPUserCoreDataStorageObject * user; + ++ (id)insertInManagedObjectContext:(NSManagedObjectContext *)moc + withPresence:(XMPPPresence *)presence + streamBareJidStr:(NSString *)streamBareJidStr; + +- (void)updateWithPresence:(XMPPPresence *)presence; + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.m b/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.m new file mode 100644 index 0000000..e0331cf --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPResourceCoreDataStorageObject.m @@ -0,0 +1,214 @@ +#import "XMPP.h" +#import "XMPPLogging.h" +#import "XMPPRosterCoreDataStorage.h" +#import "XMPPUserCoreDataStorageObject.h" +#import "XMPPResourceCoreDataStorageObject.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@interface XMPPResourceCoreDataStorageObject (CoreDataGeneratedPrimitiveAccessors) +- (NSDate *)primitivePresenceDate; +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPResourceCoreDataStorageObject + +@dynamic jid; // Implementation below +@dynamic presence; // Implementation below +@dynamic priority; // Implementation below +@dynamic intShow; // Implementation below + +@dynamic jidStr; +@dynamic presenceStr; + +@dynamic streamBareJidStr; + +@dynamic type; +@dynamic show; +@dynamic status; + +@dynamic presenceDate; + +@dynamic priorityNum; +@dynamic showNum; + +@dynamic user; + +- (XMPPJID *)jid +{ + return [XMPPJID jidWithString:[self jidStr]]; +} + +- (void)setJid:(XMPPJID *)jid +{ + self.jidStr = [jid full]; +} + +- (XMPPPresence *)presence +{ + [self willAccessValueForKey:@"presence"]; + XMPPPresence *presence = [self primitiveValueForKey:@"presence"]; + [self didAccessValueForKey:@"presence"]; + + if (presence == nil) + { + NSString *presenceStr = self.presenceStr; + if (presenceStr != nil) + { + NSXMLElement *element = [[NSXMLElement alloc] initWithXMLString:presenceStr error:nil]; + + presence = [XMPPPresence presenceFromElement:element]; + [self setPrimitiveValue:presence forKey:@"presence"]; + + [element release]; + } + } + + return presence; +} + +- (void)setPresence:(XMPPPresence *)newPresence +{ + [self willChangeValueForKey:@"presence"]; + [self setPrimitiveValue:newPresence forKey:@"presence"]; + [self didChangeValueForKey:@"presence"]; + + self.presenceStr = [newPresence compactXMLString]; +} + +- (int)priority +{ + return [[self priorityNum] intValue]; +} + +- (void)setPriority:(int)priority +{ + self.priorityNum = [NSNumber numberWithInt:priority]; +} + +- (int)intShow +{ + return [[self showNum] intValue]; +} + +- (void)setIntShow:(int)intShow +{ + self.showNum = [NSNumber numberWithInt:intShow]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Compiler Workarounds +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR + +/** + * This method is here to quiet the compiler. + * Without it the compiler complains that this method is not implemented as required by the protocol. + * This only seems to be a problem when compiling for the device. +**/ +- (NSDate *)presenceDate +{ + NSDate * tmpValue; + + [self willAccessValueForKey:@"presenceDate"]; + tmpValue = [self primitivePresenceDate]; + [self didAccessValueForKey:@"presenceDate"]; + + return tmpValue; +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Creation & Updates +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (id)insertInManagedObjectContext:(NSManagedObjectContext *)moc + withPresence:(XMPPPresence *)presence + streamBareJidStr:(NSString *)streamBareJidStr +{ + XMPPJID *jid = [presence from]; + + if (jid == nil) + { + XMPPLogWarn(@"%@: %@ - Invalid presence (missing or invalid jid): %@", [self class], THIS_METHOD, presence); + return nil; + } + + XMPPResourceCoreDataStorageObject *newResource; + newResource = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPResourceCoreDataStorageObject" + inManagedObjectContext:moc]; + + newResource.streamBareJidStr = streamBareJidStr; + + [newResource updateWithPresence:presence]; + + return newResource; +} + +- (void)updateWithPresence:(XMPPPresence *)presence +{ + XMPPJID *jid = [presence from]; + + if (jid == nil) + { + XMPPLogWarn(@"%@: %@ - Invalid presence (missing or invalid jid): %@", [self class], THIS_METHOD, presence); + return; + } + + self.jid = jid; + self.presence = presence; + + self.priority = [presence priority]; + self.intShow = [presence intShow]; + + self.type = [presence type]; + self.show = [presence show]; + self.status = [presence status]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPResource Protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSComparisonResult)compare:(id )another +{ + XMPPPresence *mp = [self presence]; + XMPPPresence *ap = [another presence]; + + int mpp = [mp priority]; + int app = [ap priority]; + + if(mpp < app) + return NSOrderedDescending; + if(mpp > app) + return NSOrderedAscending; + + // Priority is the same. + // Determine who is more available based on their show. + int mps = [mp intShow]; + int aps = [ap intShow]; + + if(mps < aps) + return NSOrderedDescending; + if(mps > aps) + return NSOrderedAscending; + + // Priority and Show are the same. + // Determine based on who was the last to receive a presence element. + NSDate *mpd = [self presenceDate]; + NSDate *apd = [another presenceDate]; + + return [mpd compare:apd]; +} + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/elements b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/elements new file mode 100644 index 0000000000000000000000000000000000000000..35ee27369348bcf3ff5242dfb38baef541c2347d GIT binary patch literal 107911 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 Iui*Iq2dVjWsQ>@~ literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/layout b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRoster.xcdatamodel/layout new file mode 100644 index 0000000000000000000000000000000000000000..dba2ac61a98283b1d55064205c32044a68399e4e GIT binary patch literal 12498 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 XknID$_KFZ8(Qodu=y&YD?Zf{E7>o5N literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.h b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.h new file mode 100644 index 0000000..f20144a --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.h @@ -0,0 +1,38 @@ +#import +#import + +#import "XMPPRoster.h" +#import "XMPPCoreDataStorage.h" + +/** + * This class is an example implementation of XMPPRosterStorage using core data. + * You are free to substitute your own roster storage class. +**/ + +@interface XMPPRosterCoreDataStorage : XMPPCoreDataStorage +{ + // Inherits protected variables from XMPPCoreDataStorage + + NSMutableSet *rosterPopulationSet; +} + +/** + * Convenience method to get an instance with the default database name. + * + * IMPORTANT: + * You are NOT required to use the sharedInstance. + * + * If your application uses multiple xmppStreams, and you use a sharedInstance of this class, + * then all of your streams share the same database store. You might get better performance if you create + * multiple instances of this class instead (using different database filenames), as this way you can have + * concurrent writes to multiple databases. +**/ ++ (XMPPRosterCoreDataStorage *)sharedInstance; + +// +// This class inherits from XMPPCoreDataStorage. +// +// Please see the XMPPCoreDataStorage header file for more information. +// + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.m b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.m new file mode 100644 index 0000000..95f71f7 --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPRosterCoreDataStorage.m @@ -0,0 +1,463 @@ +#import "XMPPRosterCoreDataStorage.h" +#import "XMPPUserCoreDataStorageObject.h" +#import "XMPPResourceCoreDataStorageObject.h" +#import "XMPPRosterPrivate.h" +#import "XMPPCoreDataStorageProtected.h" +#import "XMPP.h" +#import "XMPPLogging.h" +#import "NSNumber+XMPP.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@implementation XMPPRosterCoreDataStorage + +static XMPPRosterCoreDataStorage *sharedInstance; + ++ (XMPPRosterCoreDataStorage *)sharedInstance +{ + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + + sharedInstance = [[XMPPRosterCoreDataStorage alloc] initWithDatabaseFilename:nil]; + }); + + return sharedInstance; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Setup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)init +{ + return [self initWithDatabaseFilename:nil]; +} + +- (id)initWithDatabaseFilename:(NSString *)aDatabaseFileName +{ + if ((self = [super initWithDatabaseFilename:aDatabaseFileName])) + { + rosterPopulationSet = [[NSMutableSet alloc] init]; + } + return self; +} + +- (BOOL)configureWithParent:(XMPPRoster *)aParent queue:(dispatch_queue_t)queue +{ + return [super configureWithParent:aParent queue:queue]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * For some bizarre reason (in my opinion), when you request your roster, + * the server will return JID's NOT in your roster. + * These are the JID's of users who have requested to be alerted to our presence. + * After we sign in, we'll again be notified, via the normal presence request objects. + * It's redundant, and annoying, and just plain incorrect to include these JID's when we request our personal roster. + * So now, we have to go to the extra effort to filter out these JID's, which is exactly what this method does. +**/ +- (BOOL)isRosterItem:(NSXMLElement *)item +{ + NSString *subscription = [item attributeStringValueForName:@"subscription"]; + if ([subscription isEqualToString:@"none"]) + { + NSString *ask = [item attributeStringValueForName:@"ask"]; + if ([ask isEqualToString:@"subscribe"]) + { + return YES; + } + else + { + return NO; + } + } + + return YES; +} + +- (id )_userForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + + if (jid == nil) return nil; + + NSString *bareJIDStr = [jid bare]; + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPUserCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSPredicate *predicate; + if (stream == nil) + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@", bareJIDStr]; + else + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@ AND streamBareJidStr == %@", + bareJIDStr, [[self myJIDForXMPPStream:stream] bare]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setIncludesPendingChanges:YES]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + return (XMPPUserCoreDataStorageObject *)[results lastObject]; +} + +- (id )_resourceForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + + if (jid == nil) return nil; + + NSString *fullJIDStr = [jid full]; + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSPredicate *predicate; + if (stream == nil) + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@", fullJIDStr]; + else + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@ AND streamBareJidStr == %@", + fullJIDStr, [[self myJIDForXMPPStream:stream] bare]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setIncludesPendingChanges:YES]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + return (XMPPResourceCoreDataStorageObject *)[results lastObject]; +} + +- (void)_clearAllResourcesForXMPPStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setFetchBatchSize:saveThreshold]; + + if (stream) + { + NSPredicate *predicate; + predicate = [NSPredicate predicateWithFormat:@"streamBareJidStr == %@", + [[self myJIDForXMPPStream:stream] bare]]; + + [fetchRequest setPredicate:predicate]; + } + + NSArray *allResources = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + + for (XMPPResourceCoreDataStorageObject *resource in allResources) + { + [[self managedObjectContext] deleteObject:resource]; + + if (++unsavedCount >= saveThreshold) + { + [self save]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Overrides +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)willCreatePersistentStore:(NSString *)filePath +{ + // This method is overriden from the XMPPCoreDataStore superclass. + // From the documentation: + // + // Override me, if needed, to provide customized behavior. + // + // For example, if you are using the database for non-persistent data you may want to delete the database + // file if it already exists on disk. + // + // The default implementation does nothing. + + if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) + { + [[NSFileManager defaultManager] removeItemAtPath:filePath error:nil]; + } +} + +- (void)didCreateManagedObjectContext +{ + // This method is overriden from the XMPPCoreDataStore superclass. + // From the documentation: + // + // Override me, if needed, to provide customized behavior. + // + // For example, if you are using the database for non-persistent data you may want to delete the database + // file if it already exists on disk. + // + // The default implementation does nothing. + + + // Reserved for future use (directory versioning). + // Perhaps invoke [self _clearAllResourcesForXMPPStream:nil] ? +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Protocol Public API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )myUserForXMPPStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + XMPPJID *myJID = stream.myJID; + if (myJID == nil) + { + return nil; + } + + __block XMPPUserCoreDataStorageObject *result; + + [self executeBlock:^{ + + result = [[self _userForJID:myJID xmppStream:stream] retain]; + }]; + + return [result autorelease]; +} + +- (id )myResourceForXMPPStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + XMPPJID *myJID = stream.myJID; + if (myJID == nil) + { + return nil; + } + + __block XMPPResourceCoreDataStorageObject *result; + + [self executeBlock:^{ + + result = [[self resourceForJID:myJID xmppStream:stream] retain]; + }]; + + return [result autorelease]; +} + +- (id )userForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block XMPPUserCoreDataStorageObject *result; + + [self executeBlock:^{ + + result = [[self _userForJID:jid xmppStream:stream] retain]; + }]; + + return [result autorelease]; +} + +- (id )resourceForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block XMPPResourceCoreDataStorageObject *result; + + [self executeBlock:^{ + + result = [[self _resourceForJID:jid xmppStream:stream] retain]; + }]; + + return [result autorelease]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Protocol Private API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)beginRosterPopulationForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + [rosterPopulationSet addObject:[NSNumber numberWithPtr:stream]]; + }]; +} + +- (void)endRosterPopulationForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + [rosterPopulationSet removeObject:[NSNumber numberWithPtr:stream]]; + }]; +} + +- (void)handleRosterItem:(NSXMLElement *)itemSubElement xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + // Remember XML heirarchy memory management rules. + // The passed parameter is a subnode of the IQ, and we need to pass it to an asynchronous operation. + NSXMLElement *item = [[itemSubElement copy] autorelease]; + + [self scheduleBlock:^{ + + if ([self isRosterItem:item]) + { + if ([rosterPopulationSet containsObject:[NSNumber numberWithPtr:stream]]) + { + NSString *streamBareJidStr = [[self myJIDForXMPPStream:stream] bare]; + + [XMPPUserCoreDataStorageObject insertInManagedObjectContext:[self managedObjectContext] + withItem:item + streamBareJidStr:streamBareJidStr]; + } + else + { + NSString *jidStr = [item attributeStringValueForName:@"jid"]; + XMPPJID *jid = [[XMPPJID jidWithString:jidStr] bareJID]; + + XMPPUserCoreDataStorageObject *user = (XMPPUserCoreDataStorageObject *)[self _userForJID:jid xmppStream:stream]; + + NSString *subscription = [item attributeStringValueForName:@"subscription"]; + if ([subscription isEqualToString:@"remove"]) + { + if (user) + { + [[self managedObjectContext] deleteObject:user]; + } + } + else + { + if (user) + { + [user updateWithItem:item]; + } + else + { + NSString *streamBareJidStr = [[self myJIDForXMPPStream:stream] bare]; + + [XMPPUserCoreDataStorageObject insertInManagedObjectContext:[self managedObjectContext] + withItem:item + streamBareJidStr:streamBareJidStr]; + } + } + } + } + }]; +} + +- (void)handlePresence:(XMPPPresence *)presence xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPJID *jid = [presence from]; + XMPPUserCoreDataStorageObject *user = (XMPPUserCoreDataStorageObject *)[self _userForJID:jid xmppStream:stream]; + + if (user) + { + NSString *streamBareJidStr = [[self myJIDForXMPPStream:stream] bare]; + + [user updateWithPresence:presence streamBareJidStr:streamBareJidStr]; + } + }]; +} + +- (void)clearAllResourcesForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + [self _clearAllResourcesForXMPPStream:stream]; + }]; +} + +- (void)clearAllUsersAndResourcesForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + // Note: Deleting a user will delete all associated resources + // because of the cascade rule in our core data model. + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPUserCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setFetchBatchSize:saveThreshold]; + + if (stream) + { + NSPredicate *predicate; + predicate = [NSPredicate predicateWithFormat:@"streamBareJidStr == %@", + [[self myJIDForXMPPStream:stream] bare]]; + + [fetchRequest setPredicate:predicate]; + } + + NSArray *allUsers = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + + for (XMPPUserCoreDataStorageObject *user in allUsers) + { + [[self managedObjectContext] deleteObject:user]; + + if (++unsavedCount >= saveThreshold) + { + [self save]; + } + } + }]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Memory Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)dealloc +{ + [rosterPopulationSet release]; + [super dealloc]; +} + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.h b/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.h new file mode 100644 index 0000000..688e8d7 --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.h @@ -0,0 +1,64 @@ +#import +#import +#import "XMPPUser.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPStream; +@class XMPPGroupCoreDataStorageObject; +@class XMPPResourceCoreDataStorageObject; + + +@interface XMPPUserCoreDataStorageObject : NSManagedObject +{ + NSInteger section; +} + +@property (nonatomic, retain) XMPPJID *jid; +@property (nonatomic, retain) NSString * jidStr; +@property (nonatomic, retain) NSString * streamBareJidStr; + +@property (nonatomic, retain) NSString * nickname; +@property (nonatomic, retain) NSString * displayName; +@property (nonatomic, retain) NSString * subscription; +@property (nonatomic, retain) NSString * ask; +@property (nonatomic, retain) NSNumber * unreadMessages; + +#if TARGET_OS_IPHONE +@property (nonatomic, retain) UIImage *photo; +#else +@property (nonatomic, retain) NSImage *photo; +#endif + +@property (nonatomic, assign) NSInteger section; +@property (nonatomic, retain) NSString * sectionName; +@property (nonatomic, retain) NSNumber * sectionNum; + +@property (nonatomic, retain) NSSet * groups; +@property (nonatomic, retain) XMPPResourceCoreDataStorageObject * primaryResource; +@property (nonatomic, retain) NSSet * resources; + ++ (id)insertInManagedObjectContext:(NSManagedObjectContext *)moc + withItem:(NSXMLElement *)item + streamBareJidStr:(NSString *)streamBareJidStr; + +- (void)updateWithItem:(NSXMLElement *)item; +- (void)updateWithPresence:(XMPPPresence *)presence streamBareJidStr:(NSString *)streamBareJidStr; + +@end + +@interface XMPPUserCoreDataStorageObject (CoreDataGeneratedAccessors) + +- (void)addResourcesObject:(XMPPResourceCoreDataStorageObject *)value; +- (void)removeResourcesObject:(XMPPResourceCoreDataStorageObject *)value; +- (void)addResources:(NSSet *)value; +- (void)removeResources:(NSSet *)value; + +- (void)addGroupsObject:(XMPPGroupCoreDataStorageObject *)value; +- (void)removeGroupsObject:(XMPPGroupCoreDataStorageObject *)value; +- (void)addGroups:(NSSet *)value; +- (void)removeGroups:(NSSet *)value; + +@end diff --git a/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.m b/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.m new file mode 100644 index 0000000..e31b7ea --- /dev/null +++ b/xmpp/Extensions/Roster/CoreDataStorage/XMPPUserCoreDataStorageObject.m @@ -0,0 +1,451 @@ +#import "XMPP.h" +#import "XMPPRosterCoreDataStorage.h" +#import "XMPPUserCoreDataStorageObject.h" +#import "XMPPResourceCoreDataStorageObject.h" +#import "XMPPGroupCoreDataStorageObject.h" +#import "NSNumber+XMPP.h" + +@interface XMPPUserCoreDataStorageObject () + +@property(nonatomic,retain) XMPPJID *primitiveJid; +@property(nonatomic,retain) NSString *primitiveJidStr; + +@property(nonatomic,retain) NSString *primitiveDisplayName; +@property(nonatomic,assign) NSInteger primitiveSection; +@property(nonatomic,retain) NSString *primitiveSectionName; +@property(nonatomic,retain) NSNumber *primitiveSectionNum; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPUserCoreDataStorageObject + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Accessors +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +@dynamic jid, primitiveJid; +@dynamic jidStr, primitiveJidStr; +@dynamic streamBareJidStr; + +@dynamic nickname; +@dynamic displayName, primitiveDisplayName; +@dynamic subscription; +@dynamic ask; +@dynamic unreadMessages; +@dynamic photo; + +@dynamic section, primitiveSection; +@dynamic sectionName, primitiveSectionName; +@dynamic sectionNum, primitiveSectionNum; + +@dynamic groups; +@dynamic primaryResource; +@dynamic resources; + +- (XMPPJID *)jid +{ + // Create and cache the jid on demand + + [self willAccessValueForKey:@"jid"]; + XMPPJID *tmp = [self primitiveJid]; + [self didAccessValueForKey:@"jid"]; + + if (tmp == nil) { + tmp = [XMPPJID jidWithString:[self jidStr]]; + + [self setPrimitiveJid:tmp]; + } + return tmp; +} + +- (void)setJid:(XMPPJID *)jid +{ + self.jidStr = [jid bare]; +} + +- (void)setJidStr:(NSString *)jidStr +{ + [self willChangeValueForKey:@"jidStr"]; + [self setPrimitiveJidStr:jidStr]; + [self didChangeValueForKey:@"jidStr"]; + + // If the jidStr changes, the jid becomes invalid. + [self setPrimitiveJid:nil]; +} + +- (NSInteger)section +{ + // Create and cache the section on demand + [self willAccessValueForKey:@"section"]; + NSInteger tmp = [self primitiveSection]; + [self didAccessValueForKey:@"section"]; + + // section uses zero, so to distinguish unset values, use NSNotFound + if (tmp == NSNotFound) { + tmp = [[self sectionNum] integerValue]; + + [self setPrimitiveSection:tmp]; + } + return tmp; +} + +- (void)setSection:(NSInteger)value +{ + self.sectionNum = [NSNumber numberWithInteger:value]; +} + +- (NSInteger)primitiveSection +{ + return section; +} + +- (void)setPrimitiveSection:(NSInteger)primitiveSection +{ + section = primitiveSection; +} + + + +- (void)setSectionNum:(NSNumber *)sectionNum +{ + [self willChangeValueForKey:@"sectionNum"]; + [self setPrimitiveSectionNum:sectionNum]; + [self didChangeValueForKey:@"sectionNum"]; + + // If the sectionNum changes, the section becomes invalid. + // section uses zero, so to distinguish unset values, use NSNotFound + [self setPrimitiveSection:NSNotFound]; +} + +- (NSString *)sectionName +{ + // Create and cache the sectionName on demand + + [self willAccessValueForKey:@"sectionName"]; + NSString *tmp = [self primitiveSectionName]; + [self didAccessValueForKey:@"sectionName"]; + + if (tmp == nil) { + // Section names are organized by capitalizing the first letter of the displayName + + NSString *upperCase = [self.displayName uppercaseString]; + + // return the first character with support UTF-16: + tmp = [upperCase substringWithRange:[upperCase rangeOfComposedCharacterSequenceAtIndex:0]]; + + [self setPrimitiveSectionName:tmp]; + } + return tmp; +} + +- (void)setDisplayName:(NSString *)displayName +{ + [self willChangeValueForKey:@"displayName"]; + [self setPrimitiveDisplayName:displayName]; + [self didChangeValueForKey:@"displayName"]; + + // If the displayName changes, the sectionName becomes invalid. + [self setPrimitiveSectionName:nil]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark NSManagedObject +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)awakeFromInsert +{ + // Section uses zero, so to distinguish unset values, use NSNotFound. + + self.primitiveSection = NSNotFound; +} + +- (void)awakeFromFetch +{ + // Section uses zero, so to distinguish unset values, use NSNotFound. + // + // Note: Do NOT use "self.section = NSNotFound" as this will in turn set the sectionNum. + + self.primitiveSection = NSNotFound; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Creation & Updates +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (id)insertInManagedObjectContext:(NSManagedObjectContext *)moc + withItem:(NSXMLElement *)item + streamBareJidStr:(NSString *)streamBareJidStr +{ + NSString *jidStr = [item attributeStringValueForName:@"jid"]; + XMPPJID *jid = [XMPPJID jidWithString:jidStr]; + + if (jid == nil) + { + NSLog(@"XMPPUserCoreDataStorageObject: invalid item (missing or invalid jid): %@", item); + return nil; + } + + XMPPUserCoreDataStorageObject *newUser; + newUser = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPUserCoreDataStorageObject" + inManagedObjectContext:moc]; + + newUser.streamBareJidStr = streamBareJidStr; + + [newUser updateWithItem:item]; + + return newUser; +} + +- (void)updateGroupsWithItem:(NSXMLElement *)item +{ + XMPPGroupCoreDataStorageObject *group = nil; + + // clear existing group memberships first + if ([self.groups count] > 0) { + [self removeGroups:self.groups]; + } + + NSArray *groupItems = [item elementsForName:@"group"]; + NSString *groupName = nil; + + for (NSXMLElement *groupElement in groupItems) { + groupName = [groupElement stringValue]; + + group = [XMPPGroupCoreDataStorageObject fetchOrInsertGroupName:groupName + inManagedObjectContext:[self managedObjectContext]]; + + if (group != nil) { + [self addGroupsObject:group]; + } + } +} + +- (void)updateWithItem:(NSXMLElement *)item +{ + NSString *jidStr = [item attributeStringValueForName:@"jid"]; + XMPPJID *jid = [XMPPJID jidWithString:jidStr]; + + if (jid == nil) + { + NSLog(@"XMPPUserCoreDataStorageObject: invalid item (missing or invalid jid): %@", item); + return; + } + + self.jid = jid; + self.nickname = [item attributeStringValueForName:@"name"]; + + self.displayName = (self.nickname != nil) ? self.nickname : jidStr; + + self.subscription = [item attributeStringValueForName:@"subscription"]; + self.ask = [item attributeStringValueForName:@"ask"]; + + [self updateGroupsWithItem:item]; +} + +- (void)recalculatePrimaryResource +{ + self.primaryResource = nil; + + NSArray *sortedResources = [self sortedResources]; + if ([sortedResources count] > 0) + { + XMPPResourceCoreDataStorageObject *resource = [sortedResources objectAtIndex:0]; + + // Primary resource must have a non-negative priority + if([resource priority] >= 0) + { + self.primaryResource = resource; + + if (resource.intShow >= 3) + self.section = 0; + else + self.section = 1; + } + } + + if (self.primaryResource == nil) + { + self.section = 2; + } +} + +- (void)updateWithPresence:(XMPPPresence *)presence streamBareJidStr:(NSString *)streamBareJidStr +{ + XMPPResourceCoreDataStorageObject *resource; + resource = (XMPPResourceCoreDataStorageObject *)[self resourceForJID:[presence from]]; + + if ([[presence type] isEqualToString:@"unavailable"]) + { + if (resource) + { + [self removeResourcesObject:resource]; + [[self managedObjectContext] deleteObject:resource]; + } + } + else + { + if(resource) + { + [resource updateWithPresence:presence]; + } + else + { + XMPPResourceCoreDataStorageObject *newResource; + newResource = [XMPPResourceCoreDataStorageObject insertInManagedObjectContext:[self managedObjectContext] + withPresence:presence + streamBareJidStr:streamBareJidStr]; + + [self addResourcesObject:newResource]; + } + } + + [self recalculatePrimaryResource]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPUser Protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)isOnline +{ + return (self.primaryResource != nil); +} + +- (BOOL)isPendingApproval +{ + // Either of the following mean we're waiting to have our presence subscription approved: + // + // + + NSString *subscription = self.subscription; + NSString *ask = self.ask; + + if ([subscription isEqualToString:@"none"] || [subscription isEqualToString:@"from"]) + { + if ([ask isEqualToString:@"subscribe"]) + { + return YES; + } + } + + return NO; +} + +- (id )resourceForJID:(XMPPJID *)jid +{ + NSString *jidStr = [jid full]; + + for (XMPPResourceCoreDataStorageObject *resource in [self resources]) + { + if ([jidStr isEqualToString:[resource jidStr]]) + { + return resource; + } + } + + return nil; +} + +- (NSArray *)sortedResources +{ + return [[self unsortedResources] sortedArrayUsingSelector:@selector(compare:)]; +} + +- (NSArray *)unsortedResources +{ + return [[self resources] allObjects]; +} + +/** + * Returns the result of invoking compareByName:options: with no options. +**/ +- (NSComparisonResult)compareByName:(id )another +{ + return [self compareByName:another options:0]; +} + +/** + * This method compares the two users according to their display name. + * + * Options for the search — you can combine any of the following using a C bitwise OR operator: + * NSCaseInsensitiveSearch, NSLiteralSearch, NSNumericSearch. + * See "String Programming Guide for Cocoa" for details on these options. +**/ +- (NSComparisonResult)compareByName:(id )another options:(NSStringCompareOptions)mask +{ + NSString *myName = [self displayName]; + NSString *theirName = [another displayName]; + + return [myName compare:theirName options:mask]; +} + +/** + * Returns the result of invoking compareByAvailabilityName:options: with no options. +**/ +- (NSComparisonResult)compareByAvailabilityName:(id )another +{ + return [self compareByAvailabilityName:another options:0]; +} + +/** + * This method compares the two users according to availability first, and then display name. + * Thus available users come before unavailable users. + * If both users are available, or both users are not available, + * this method follows the same functionality as the compareByName:options: as documented above. +**/ +- (NSComparisonResult)compareByAvailabilityName:(id )another options:(NSStringCompareOptions)mask +{ + if ([self isOnline]) + { + if ([another isOnline]) + return [self compareByName:another options:mask]; + else + return NSOrderedAscending; + } + else + { + if ([another isOnline]) + return NSOrderedDescending; + else + return [self compareByName:another options:mask]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark KVO compliance methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSSet *)keyPathsForValuesAffectingJid { + // If the jidStr changes, the jid may change as well. + return [NSSet setWithObject:@"jidStr"]; +} + ++ (NSSet *)keyPathsForValuesAffectingIsOnline { + return [NSSet setWithObject:@"primaryResource"]; +} + ++ (NSSet *)keyPathsForValuesAffectingSection { + // If the value of sectionNum changes, the section may change as well. + return [NSSet setWithObject:@"sectionNum"]; +} + ++ (NSSet *)keyPathsForValuesAffectingSectionName { + // If the value of displayName changes, the sectionName may change as well. + return [NSSet setWithObject:@"displayName"]; +} + ++ (NSSet *)keyPathsForValuesAffectingSortedResources { + return [NSSet setWithObject:@"unsortedResources"]; +} + ++ (NSSet *)keyPathsForValuesAffectingUnsortedResources { + return [NSSet setWithObject:@"resources"]; +} + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.h b/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.h new file mode 100644 index 0000000..2dfab7f --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.h @@ -0,0 +1,19 @@ +#import +#import "XMPPResource.h" + +@class XMPPJID; +@class XMPPIQ; +@class XMPPPresence; + + +@interface XMPPResourceMemoryStorage : NSObject +{ + XMPPJID *jid; + XMPPPresence *presence; + + NSDate *presenceDate; +} + +// See the XMPPResource protocol for available methods. + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.m b/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.m new file mode 100644 index 0000000..61a728d --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPResourceMemoryStorage.m @@ -0,0 +1,193 @@ +#import "XMPP.h" +#import "XMPPElement+Delay.h" +#import "XMPPRosterMemoryStoragePrivate.h" + +@implementation XMPPResourceMemoryStorage + +- (id)initWithPresence:(XMPPPresence *)aPresence +{ + if((self = [super init])) + { + jid = [[aPresence from] retain]; + presence = [aPresence retain]; + + presenceDate = [[presence delayedDeliveryDate] retain]; + if (presenceDate == nil) + { + presenceDate = [[NSDate alloc] init]; + } + } + return self; +} + +- (void)dealloc +{ + [jid release]; + [presence release]; + [presenceDate release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Copying +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)copyWithZone:(NSZone *)zone +{ + XMPPResourceMemoryStorage *deepCopy = [[XMPPResourceMemoryStorage alloc] init]; + + deepCopy->jid = [jid copy]; + deepCopy->presence = [presence retain]; // No need to bother with a copy we don't alter presence + deepCopy->presenceDate = [presenceDate copy]; + + return deepCopy; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Encoding, Decoding +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if ! TARGET_OS_IPHONE +- (id)replacementObjectForPortCoder:(NSPortCoder *)encoder +{ + if([encoder isBycopy]) + return self; + else + return [NSDistantObject proxyWithLocal:self connection:[encoder connection]]; +} +#endif + +- (id)initWithCoder:(NSCoder *)coder +{ + if((self = [super init])) + { + if([coder allowsKeyedCoding]) + { + jid = [[coder decodeObjectForKey:@"jid"] retain]; + presence = [[coder decodeObjectForKey:@"presence"] retain]; + presenceDate = [[coder decodeObjectForKey:@"presenceDate"] retain]; + } + else + { + jid = [[coder decodeObject] retain]; + presence = [[coder decodeObject] retain]; + presenceDate = [[coder decodeObject] retain]; + } + } + return self; +} + +- (void)encodeWithCoder:(NSCoder *)coder +{ + if([coder allowsKeyedCoding]) + { + [coder encodeObject:jid forKey:@"jid"]; + [coder encodeObject:presence forKey:@"presence"]; + [coder encodeObject:presenceDate forKey:@"presenceDate"]; + } + else + { + [coder encodeObject:jid]; + [coder encodeObject:presence]; + [coder encodeObject:presenceDate]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Standard Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (XMPPJID *)jid +{ + return jid; +} + +- (XMPPPresence *)presence +{ + return presence; +} + +- (NSDate *)presenceDate +{ + return presenceDate; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Update Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)updateWithPresence:(XMPPPresence *)aPresence +{ + [presence release]; + presence = [aPresence retain]; + + [presenceDate release]; + presenceDate = [[presence delayedDeliveryDate] retain]; + if (presenceDate == nil) + { + presenceDate = [[NSDate alloc] init]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Comparison Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSComparisonResult)compare:(id )another +{ + XMPPPresence *mp = [self presence]; + XMPPPresence *ap = [another presence]; + + int mpp = [mp priority]; + int app = [ap priority]; + + if(mpp < app) + return NSOrderedDescending; + if(mpp > app) + return NSOrderedAscending; + + // Priority is the same. + // Determine who is more available based on their show. + int mps = [mp intShow]; + int aps = [ap intShow]; + + if(mps < aps) + return NSOrderedDescending; + if(mps > aps) + return NSOrderedAscending; + + // Priority and Show are the same. + // Determine based on who was the last to receive a presence element. + NSDate *mpd = [self presenceDate]; + NSDate *apd = [another presenceDate]; + + return [mpd compare:apd]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark NSObject Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSUInteger)hash +{ + return [jid hash]; +} + +- (BOOL)isEqual:(id)anObject +{ + if([anObject isMemberOfClass:[self class]]) + { + XMPPResourceMemoryStorage *another = (XMPPResourceMemoryStorage *)anObject; + + return [jid isEqual:[another jid]]; + } + + return NO; +} + +- (NSString *)description +{ + return [NSString stringWithFormat:@"XMPPResource: %@", [jid full]]; +} + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.h b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.h new file mode 100644 index 0000000..4c054f5 --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.h @@ -0,0 +1,67 @@ +#import +#import "XMPPRoster.h" + +@class XMPPUserMemoryStorage; + +/** + * This class is an example implementation of XMPPRosterStorage using core data. + * You are free to substitute your own storage class. +**/ + +@interface XMPPRosterMemoryStorage : NSObject +{ + XMPPRoster *parent; + dispatch_queue_t parentQueue; + + NSMutableDictionary *roster; + + BOOL isRosterPopulation; + + XMPPUserMemoryStorage *myUser; +} + +- (id)init; + +@property (nonatomic, readonly) XMPPRoster *parent; + +// The methods below provide access to the roster data. +// If invoked from a dispatch queue other than the roster's queue, +// the methods return snapshots (copies) of the roster data. +// These snapshots provide a thread-safe version of the roster data. +// The thread-safety comes from the fact that the copied data will not be altered, +// so it can therefore be used from multiple threads/queues if needed. + +- (id )myUser; +- (id )myResource; + +- (id )userForJID:(XMPPJID *)jid; +- (id )resourceForJID:(XMPPJID *)jid; + +- (NSArray *)sortedUsersByName; +- (NSArray *)sortedUsersByAvailabilityName; + +- (NSArray *)sortedAvailableUsersByName; +- (NSArray *)sortedUnavailableUsersByName; + +- (NSArray *)unsortedUsers; +- (NSArray *)unsortedAvailableUsers; +- (NSArray *)unsortedUnavailableUsers; + +- (NSArray *)sortedResources:(BOOL)includeResourcesForMyUserExcludingMyself; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPRosterMemoryStorageDelegate +@optional + +/** + * The XMPPRosterStorage classes use the same delegate as their parent XMPPRoster. +**/ + +- (void)xmppRosterDidChange:(XMPPRosterMemoryStorage *)sender; + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.m b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.m new file mode 100644 index 0000000..a651ccc --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStorage.m @@ -0,0 +1,731 @@ +#import "XMPP.h" +#import "XMPPRosterPrivate.h" +#import "XMPPRosterMemoryStorage.h" +#import "XMPPRosterMemoryStoragePrivate.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@interface XMPPRosterMemoryStorage (PrivateAPI) + +- (BOOL)isRosterItem:(NSXMLElement *)item; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPRosterMemoryStorage + +@synthesize parent; + +- (GCDMulticastDelegate *)multicastDelegate +{ + return (GCDMulticastDelegate *)[parent multicastDelegate]; +} + +- (id)init +{ + if ((self = [super init])) + { + roster = [[NSMutableDictionary alloc] init]; + } + return self; +} + +- (BOOL)configureWithParent:(XMPPRoster *)aParent queue:(dispatch_queue_t)queue +{ + NSParameterAssert(aParent != nil); + NSParameterAssert(queue != NULL); + + if ((parent == nil) && (parentQueue == NULL)) + { + parent = aParent; // Parents retain their children, children do NOT retain their parent + + parentQueue = queue; + dispatch_retain(parentQueue); + + return YES; + } + + return NO; +} + +- (void)dealloc +{ + if (parentQueue) + dispatch_release(parentQueue); + + [roster release]; + [myUser release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Internal API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )_userForJID:(XMPPJID *)jid +{ + // Private method: Only invoked on the parentQueue. + + XMPPUserMemoryStorage *result = [roster objectForKey:[jid bareJID]]; + + if (result) + { + return result; + } + + XMPPJID *myJID = parent.xmppStream.myJID; + + XMPPJID *myBareJID = [myJID bareJID]; + XMPPJID *bareJID = [jid bareJID]; + + if ([bareJID isEqual:myBareJID]) + { + return myUser; + } + + return nil; +} + +- (id )_resourceForJID:(XMPPJID *)jid +{ + // Private method: Only invoked on the parentQueue. + + XMPPUserMemoryStorage *user = (XMPPUserMemoryStorage *)[self _userForJID:jid]; + return [user resourceForJID:jid]; +} + +- (NSArray *)_unsortedUsers +{ + // Private method: Only invoked on the parentQueue. + + return [roster allValues]; +} + +- (NSArray *)_unsortedAvailableUsers +{ + // Private method: Only invoked on the parentQueue. + + NSArray *allUsers = [roster allValues]; + + NSMutableArray *result = [NSMutableArray arrayWithCapacity:[allUsers count]]; + + for (id user in allUsers) + { + if ([user isOnline]) + { + [result addObject:user]; + } + } + + return result; +} + +- (NSArray *)_unsortedUnavailableUsers +{ + // Private method: Only invoked on the parentQueue. + + NSArray *allUsers = [roster allValues]; + + NSMutableArray *result = [NSMutableArray arrayWithCapacity:[allUsers count]]; + + for (id user in allUsers) + { + if (![user isOnline]) + { + [result addObject:user]; + } + } + + return result; +} + +- (NSArray *)_sortedUsersByName +{ + // Private method: Only invoked on the parentQueue. + + return [[roster allValues] sortedArrayUsingSelector:@selector(compareByName:)]; +} + +- (NSArray *)_sortedUsersByAvailabilityName +{ + // Private method: Only invoked on the parentQueue. + + return [[roster allValues] sortedArrayUsingSelector:@selector(compareByAvailabilityName:)]; +} + +- (NSArray *)_sortedAvailableUsersByName +{ + // Private method: Only invoked on the parentQueue. + + return [[self _unsortedAvailableUsers] sortedArrayUsingSelector:@selector(compareByName:)]; +} + +- (NSArray *)_sortedUnavailableUsersByName +{ + // Private method: Only invoked on the parentQueue. + + return [[self _unsortedUnavailableUsers] sortedArrayUsingSelector:@selector(compareByName:)]; +} + +- (NSArray *)_sortedResources:(BOOL)includeResourcesForMyUserExcludingMyself +{ + // Private method: Only invoked on the parentQueue. + + // Add all the resouces from all the available users in the roster + // + // Remember: There may be multiple resources per user + + NSArray *availableUsers = [self unsortedAvailableUsers]; + + NSMutableArray *result = [NSMutableArray arrayWithCapacity:[availableUsers count]]; + + for (id user in availableUsers) + { + [result addObjectsFromArray:[user unsortedResources]]; + } + + if (includeResourcesForMyUserExcludingMyself) + { + // Now add all the available resources from our own user account (excluding ourselves) + + XMPPJID *myJID = parent.xmppStream.myJID; + NSArray *myResources = [myUser unsortedResources]; + + for (id resource in myResources) + { + if (![myJID isEqual:[resource jid]]) + { + [result addObject:resource]; + } + } + } + + return [result sortedArrayUsingSelector:@selector(compare:)]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Roster Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )myUser +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return myUser; + } + else + { + __block XMPPUserMemoryStorage *result; + + dispatch_sync(parentQueue, ^{ + result = [myUser copy]; + }); + + return [result autorelease]; + } +} + +- (id )myResource +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + XMPPJID *myJID = parent.xmppStream.myJID; + + if (dispatch_get_current_queue() == parentQueue) + { + return [myUser resourceForJID:myJID]; + } + else + { + __block XMPPResourceMemoryStorage *result; + + dispatch_sync(parentQueue, ^{ + XMPPResourceMemoryStorage *resource = (XMPPResourceMemoryStorage *)[myUser resourceForJID:myJID]; + result = [resource copy]; + }); + + return [result autorelease]; + } +} + +- (id )userForJID:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _userForJID:jid]; + } + else + { + __block XMPPUserMemoryStorage *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPUserMemoryStorage *user = (XMPPUserMemoryStorage *)[self _userForJID:jid]; + result = [user copy]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (id )resourceForJID:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _resourceForJID:jid]; + } + else + { + __block XMPPResourceMemoryStorage *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPResourceMemoryStorage *resource = (XMPPResourceMemoryStorage *)[self _resourceForJID:jid]; + result = [resource copy]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)sortedUsersByName +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _sortedUsersByName]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _sortedUsersByName]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)sortedUsersByAvailabilityName +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _sortedUsersByAvailabilityName]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _sortedUsersByAvailabilityName]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)sortedAvailableUsersByName +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _sortedAvailableUsersByName]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _sortedAvailableUsersByName]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)sortedUnavailableUsersByName +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _sortedUnavailableUsersByName]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _sortedUnavailableUsersByName]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)unsortedUsers +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _unsortedUsers]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _unsortedUsers]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)unsortedAvailableUsers +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _unsortedAvailableUsers]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _unsortedAvailableUsers]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)unsortedUnavailableUsers +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _unsortedUnavailableUsers]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _unsortedUnavailableUsers]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +- (NSArray *)sortedResources:(BOOL)includeResourcesForMyUserExcludingMyself +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (parentQueue == NULL) return nil; + + if (dispatch_get_current_queue() == parentQueue) + { + return [self _sortedResources:includeResourcesForMyUserExcludingMyself]; + } + else + { + __block NSArray *result; + + dispatch_sync(parentQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + NSArray *temp = [self _sortedResources:includeResourcesForMyUserExcludingMyself]; + + result = [[NSArray alloc] initWithArray:temp copyItems:YES]; + + [pool release]; + }); + + return [result autorelease]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPRosterStorage Protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )myUserForXMPPStream:(XMPPStream *)stream +{ + return [self myUser]; +} + +- (id )myResourceForXMPPStream:(XMPPStream *)stream +{ + return [self myResource]; +} + +- (id )userForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + return [self userForJID:jid]; +} + +- (id )resourceForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + return [self resourceForJID:jid]; +} + +- (void)beginRosterPopulationForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + isRosterPopulation = YES; + + XMPPJID *myJID = parent.xmppStream.myJID; + + [myUser release]; + myUser = [[XMPPUserMemoryStorage alloc] initWithJID:myJID]; +} + +- (void)endRosterPopulationForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + isRosterPopulation = NO; + + [[self multicastDelegate] xmppRosterDidChange:self]; +} + +- (void)handleRosterItem:(NSXMLElement *)item xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + if ([self isRosterItem:item]) + { + NSString *jidStr = [item attributeStringValueForName:@"jid"]; + XMPPJID *jid = [[XMPPJID jidWithString:jidStr] bareJID]; + + NSString *subscription = [item attributeStringValueForName:@"subscription"]; + + if ([subscription isEqualToString:@"remove"]) + { + [roster removeObjectForKey:jid]; + } + else + { + XMPPUserMemoryStorage *user = [roster objectForKey:jid]; + if (user) + { + [user updateWithItem:item]; + } + else + { + XMPPUserMemoryStorage *newUser = [[XMPPUserMemoryStorage alloc] initWithItem:item]; + + [roster setObject:newUser forKey:jid]; + [newUser release]; + } + } + + if (!isRosterPopulation) + { + [[self multicastDelegate] xmppRosterDidChange:self]; + } + } +} + +- (void)handlePresence:(XMPPPresence *)presence xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + XMPPJID *jidKey = [[presence from] bareJID]; + XMPPUserMemoryStorage *rosterUser = [roster objectForKey:jidKey]; + + if (rosterUser) + { + [rosterUser updateWithPresence:presence]; + + if (!isRosterPopulation) + { + [[self multicastDelegate] xmppRosterDidChange:self]; + } + } + else + { + // Not a presence element for anyone in our roster. + // Is it a presence element for our user (either our resource or another resource)? + + XMPPJID *myJID = parent.xmppStream.myJID; + XMPPJID *myBareJID = [myJID bareJID]; + + if([myBareJID isEqual:jidKey]) + { + [myUser updateWithPresence:presence]; + + if (!isRosterPopulation) + { + [[self multicastDelegate] xmppRosterDidChange:self]; + } + } + } +} + +- (void)clearAllResourcesForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + NSEnumerator *enumerator = [roster objectEnumerator]; + XMPPUserMemoryStorage *user; + + while ((user = [enumerator nextObject])) + { + [user clearAllResources]; + } + + [[self multicastDelegate] xmppRosterDidChange:self]; +} + +- (void)clearAllUsersAndResourcesForXMPPStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [roster removeAllObjects]; + + [myUser release]; + myUser = nil; + + [[self multicastDelegate] xmppRosterDidChange:self]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * For some bizarre reason (in my opinion), when you request your roster, + * the server will return JID's NOT in your roster. + * These are the JID's of users who have requested to be alerted to our presence. + * After we sign in, we'll again be notified, via the normal presence request objects. + * It's redundant, and annoying, and just plain incorrect to include these JID's when we request our personal roster. + * So now, we have to go to the extra effort to filter out these JID's, which is exactly what this method does. +**/ +- (BOOL)isRosterItem:(NSXMLElement *)item +{ + NSString *subscription = [item attributeStringValueForName:@"subscription"]; + if ([subscription isEqualToString:@"none"]) + { + NSString *ask = [item attributeStringValueForName:@"ask"]; + if ([ask isEqualToString:@"subscribe"]) + { + return YES; + } + else + { + return NO; + } + } + + return YES; +} + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStoragePrivate.h b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStoragePrivate.h new file mode 100644 index 0000000..cef8cba --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPRosterMemoryStoragePrivate.h @@ -0,0 +1,36 @@ +#import "XMPPUserMemoryStorage.h" +#import "XMPPResourceMemoryStorage.h" + +/** + * The following methods are designed to be invoked ONLY from + * within the XMPPRosterMemoryStorage implementation. + * + * Warning: XMPPUserMemoryStorage and XMPPResourceMemoryStorage are not explicitly thread-safe. + * Only copies that are no longer being actively + * altered by the XMPPRosterMemoryStorage class should be considered read-only and therefore thread-safe. +**/ + +@interface XMPPUserMemoryStorage (Internal) + +- (id)initWithJID:(XMPPJID *)aJid; +- (id)initWithItem:(NSXMLElement *)item; + +- (void)clearAllResources; + +- (void)updateWithItem:(NSXMLElement *)item; +- (void)updateWithPresence:(XMPPPresence *)presence; + +- (NSInteger)tag; +- (void)setTag:(NSInteger)anInt; + +@end + +@interface XMPPResourceMemoryStorage (Internal) + +- (id)initWithPresence:(XMPPPresence *)aPresence; + +- (void)updateWithPresence:(XMPPPresence *)presence; + +- (XMPPPresence *)presence; + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.h b/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.h new file mode 100644 index 0000000..297084d --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.h @@ -0,0 +1,32 @@ +#import +#import "XMPPUser.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPJID; +@class XMPPPresence; +@class XMPPResourceMemoryStorage; + + +@interface XMPPUserMemoryStorage : NSObject +{ + XMPPJID *jid; + NSMutableDictionary *itemAttributes; + +#if TARGET_OS_IPHONE + UIImage *photo; +#else + NSImage *photo; +#endif + + NSMutableDictionary *resources; + XMPPResourceMemoryStorage *primaryResource; + + NSInteger tag; +} + +// See the XMPPUser protocol for available methods. + +@end diff --git a/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.m b/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.m new file mode 100644 index 0000000..957b8cc --- /dev/null +++ b/xmpp/Extensions/Roster/MemoryStorage/XMPPUserMemoryStorage.m @@ -0,0 +1,428 @@ +#import "XMPP.h" +#import "XMPPRosterMemoryStoragePrivate.h" + + +@interface XMPPUserMemoryStorage (PrivateAPI) +- (void)recalculatePrimaryResource; +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPUserMemoryStorage + +- (id)initWithJID:(XMPPJID *)aJid item:(NSXMLElement *)item +{ + if ((self = [super init])) { + jid = [[aJid bareJID] retain]; + resources = [[NSMutableDictionary alloc] initWithCapacity:1]; + photo = nil; + tag = 0; + + if (item == nil) { + itemAttributes = [[NSMutableDictionary alloc] initWithCapacity:0]; + } + else + { + itemAttributes = [[item attributesAsDictionary] retain]; + } + } + return self; +} + +- (id)initWithJID:(XMPPJID *)aJid +{ + return [self initWithJID:aJid item:nil]; +} + +- (id)initWithItem:(NSXMLElement *)item +{ + NSString *jidStr = [[item attributeForName:@"jid"] stringValue]; + jid = [[XMPPJID jidWithString:jidStr] bareJID]; + + return [self initWithJID:jid item:item]; +} + +- (void)dealloc +{ + [photo release]; + [jid release]; + [itemAttributes release]; + [resources release]; + [primaryResource release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Copying +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)copyWithZone:(NSZone *)zone +{ + XMPPUserMemoryStorage *deepCopy = [[XMPPUserMemoryStorage alloc] init]; + + deepCopy->jid = [jid copy]; + deepCopy->itemAttributes = [itemAttributes mutableCopy]; + + deepCopy->resources = [[NSMutableDictionary alloc] initWithCapacity:[resources count]]; + + for (XMPPJID *key in resources) + { + XMPPResourceMemoryStorage *resourceCopy = [[resources objectForKey:key] copy]; + + [deepCopy->resources setObject:resourceCopy forKey:key]; + [resourceCopy release]; + } + + [deepCopy recalculatePrimaryResource]; + + deepCopy->tag = tag; + + return deepCopy; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Encoding, Decoding +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if ! TARGET_OS_IPHONE +- (id)replacementObjectForPortCoder:(NSPortCoder *)encoder +{ + if([encoder isBycopy]) + return self; + else + return [NSDistantObject proxyWithLocal:self connection:[encoder connection]]; +} +#endif + +- (id)initWithCoder:(NSCoder *)coder +{ + if((self = [super init])) + { + if([coder allowsKeyedCoding]) + { + jid = [[coder decodeObjectForKey:@"jid"] retain]; + itemAttributes = [[coder decodeObjectForKey:@"itemAttributes"] mutableCopy]; + #if TARGET_OS_IPHONE + photo = [[UIImage alloc] initWithData:[coder decodeObjectForKey:@"photo"]]; + #else + photo = [[NSImage alloc] initWithData:[coder decodeObjectForKey:@"photo"]]; + #endif + resources = [[coder decodeObjectForKey:@"resources"] mutableCopy]; + primaryResource = [[coder decodeObjectForKey:@"primaryResource"] retain]; + tag = [coder decodeIntegerForKey:@"tag"]; + } + else + { + jid = [[coder decodeObject] retain]; + itemAttributes = [[coder decodeObject] mutableCopy]; + #if TARGET_OS_IPHONE + photo = [[UIImage alloc] initWithData:[coder decodeObject]]; + #else + photo = [[NSImage alloc] initWithData:[coder decodeObject]]; + #endif + resources = [[coder decodeObject] mutableCopy]; + primaryResource = [[coder decodeObject] retain]; + tag = [[coder decodeObject] integerValue]; + } + } + return self; +} + +- (void)encodeWithCoder:(NSCoder *)coder +{ + if([coder allowsKeyedCoding]) + { + [coder encodeObject:jid forKey:@"jid"]; + [coder encodeObject:itemAttributes forKey:@"itemAttributes"]; + #if TARGET_OS_IPHONE + [coder encodeObject:UIImagePNGRepresentation(photo) forKey:@"photo"]; + #else + [coder encodeObject:[photo TIFFRepresentation] forKey:@"photo"]; + #endif + [coder encodeObject:resources forKey:@"resources"]; + [coder encodeObject:primaryResource forKey:@"primaryResource"]; + [coder encodeInteger:tag forKey:@"tag"]; + } + else + { + [coder encodeObject:jid]; + [coder encodeObject:itemAttributes]; + #if TARGET_OS_IPHONE + [coder encodeObject:UIImagePNGRepresentation(photo)]; + #else + [coder encodeObject:[photo TIFFRepresentation]]; + #endif + [coder encodeObject:resources]; + [coder encodeObject:primaryResource]; + [coder encodeObject:[NSNumber numberWithInteger:tag]]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Standard Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@synthesize photo; + +- (XMPPJID *)jid +{ + return jid; +} + +- (NSString *)nickname +{ + return (NSString *)[itemAttributes objectForKey:@"name"]; +} + +- (NSString *)displayName +{ + NSString *nickname = [self nickname]; + if(nickname) + return nickname; + else + return [jid bare]; +} + +- (BOOL)isOnline +{ + return (primaryResource != nil); +} + +- (BOOL)isPendingApproval +{ + // Either of the following mean we're waiting to have our presence subscription approved: + // + // + + NSString *subscription = [itemAttributes objectForKey:@"subscription"]; + NSString *ask = [itemAttributes objectForKey:@"ask"]; + + if ([subscription isEqualToString:@"none"] || [subscription isEqualToString:@"from"]) + { + if([ask isEqualToString:@"subscribe"]) + { + return YES; + } + } + + return NO; +} + +- (id )primaryResource +{ + return primaryResource; +} + +- (id )resourceForJID:(XMPPJID *)aJid +{ + return [resources objectForKey:aJid]; +} + +- (NSArray *)sortedResources +{ + return [[resources allValues] sortedArrayUsingSelector:@selector(compare:)]; +} + +- (NSArray *)unsortedResources +{ + return [resources allValues]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Helper Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)recalculatePrimaryResource +{ + [primaryResource release]; + primaryResource = nil; + + NSArray *sortedResources = [self sortedResources]; + if([sortedResources count] > 0) + { + XMPPResourceMemoryStorage *possiblePrimary = [sortedResources objectAtIndex:0]; + + // Primary resource must have a non-negative priority + if([[possiblePrimary presence] priority] >= 0) + { + primaryResource = [possiblePrimary retain]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Update Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)clearAllResources +{ + [resources removeAllObjects]; + + [primaryResource release]; + primaryResource = nil; +} + +- (void)updateWithItem:(NSXMLElement *)item +{ + NSArray *attributes = [item attributes]; + + int i; + for(i = 0; i < [attributes count]; i++) + { + NSXMLNode *node = [attributes objectAtIndex:i]; + NSString *key = [node name]; + NSString *value = [node stringValue]; + + if(![value isEqualToString:[itemAttributes objectForKey:key]]) + { + [itemAttributes setObject:value forKey:key]; + } + } +} + +- (void)updateWithPresence:(XMPPPresence *)presence +{ + if([[presence type] isEqualToString:@"unavailable"]) + { + [resources removeObjectForKey:[presence from]]; + } + else + { + XMPPJID *key = [presence from]; + XMPPResourceMemoryStorage *resource = [resources objectForKey:key]; + + if(resource) + { + [resource updateWithPresence:presence]; + } + else + { + XMPPResourceMemoryStorage *newResource = [[XMPPResourceMemoryStorage alloc] initWithPresence:presence]; + + [resources setObject:newResource forKey:key]; + [newResource release]; + } + } + + [self recalculatePrimaryResource]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Comparison Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the result of invoking compareByName:options: with no options. +**/ +- (NSComparisonResult)compareByName:(id )another +{ + return [self compareByName:another options:0]; +} + +/** + * This method compares the two users according to their display name. + * + * Options for the search — you can combine any of the following using a C bitwise OR operator: + * NSCaseInsensitiveSearch, NSLiteralSearch, NSNumericSearch. + * See "String Programming Guide for Cocoa" for details on these options. +**/ +- (NSComparisonResult)compareByName:(id )another options:(NSStringCompareOptions)mask +{ + NSString *myName = [self displayName]; + NSString *theirName = [another displayName]; + + return [myName compare:theirName options:mask]; +} + +/** + * Returns the result of invoking compareByAvailabilityName:options: with no options. +**/ +- (NSComparisonResult)compareByAvailabilityName:(id )another +{ + return [self compareByAvailabilityName:another options:0]; +} + +/** + * This method compares the two users according to availability first, and then display name. + * Thus available users come before unavailable users. + * If both users are available, or both users are not available, + * this method follows the same functionality as the compareByName:options: as documented above. +**/ +- (NSComparisonResult)compareByAvailabilityName:(id )another options:(NSStringCompareOptions)mask +{ + if([self isOnline]) + { + if([another isOnline]) + return [self compareByName:another options:mask]; + else + return NSOrderedAscending; + } + else + { + if([another isOnline]) + return NSOrderedDescending; + else + return [self compareByName:another options:mask]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark NSObject Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSUInteger)hash +{ + return [jid hash]; +} + +- (BOOL)isEqual:(id)anObject +{ + if([anObject isMemberOfClass:[self class]]) + { + XMPPUserMemoryStorage *another = (XMPPUserMemoryStorage *)anObject; + + return [jid isEqual:[another jid]]; + } + + return NO; +} + +- (NSString *)description +{ + return [NSString stringWithFormat:@"XMPPUser: %@", [jid bare]]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark User Defined Content +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSInteger)tag +{ + return tag; +} + +- (void)setTag:(NSInteger)anInt +{ + tag = anInt; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark KVO Compliance methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSSet *)keyPathsForValuesAffectingIsOnline +{ + return [NSSet setWithObject:@"primaryResource"]; +} + ++ (NSSet *)keyPathsForValuesAffectingUnsortedResources { + return [NSSet setWithObject:@"resources"]; +} + ++ (NSSet *)keyPathsForValuesAffectingSortedResources { + return [NSSet setWithObject:@"unsortedResources"]; +} + +@end diff --git a/xmpp/Extensions/Roster/XMPPResource.h b/xmpp/Extensions/Roster/XMPPResource.h new file mode 100644 index 0000000..14f9948 --- /dev/null +++ b/xmpp/Extensions/Roster/XMPPResource.h @@ -0,0 +1,17 @@ +#import + +@class XMPPJID; +@class XMPPIQ; +@class XMPPPresence; + + +@protocol XMPPResource + +- (XMPPJID *)jid; +- (XMPPPresence *)presence; + +- (NSDate *)presenceDate; + +- (NSComparisonResult)compare:(id )another; + +@end diff --git a/xmpp/Extensions/Roster/XMPPRoster.h b/xmpp/Extensions/Roster/XMPPRoster.h new file mode 100644 index 0000000..0f1da04 --- /dev/null +++ b/xmpp/Extensions/Roster/XMPPRoster.h @@ -0,0 +1,148 @@ +#import +#import "XMPPModule.h" +#import "XMPPUser.h" +#import "XMPPResource.h" +#import "XMPPvCardAvatarModule.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPJID; +@class XMPPStream; +@class XMPPPresence; +@protocol XMPPRosterStorage; +@protocol XMPPRosterDelegate; + + +/** + * Add XMPPRoster as a delegate of XMPPvCardAvatarModule to cache roster photos in the roster. + * This frees the view controller from having to save photos on the main thread. + **/ + +@interface XMPPRoster : XMPPModule +{ +/* Inherited from XMPPModule: + + XMPPStream *xmppStream; + + dispatch_queue_t moduleQueue; + id multicastDelegate; + */ + id xmppRosterStorage; + + Byte flags; + NSMutableArray *earlyPresenceElements; +} + +- (id)initWithRosterStorage:(id )storage; +- (id)initWithRosterStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue; + +/* Inherited from XMPPModule: + +- (BOOL)activate:(XMPPStream *)xmppStream; +- (void)deactivate; + +@property (readonly) XMPPStream *xmppStream; + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate; + +- (NSString *)moduleName; + +*/ + +@property (nonatomic, readonly) id xmppRosterStorage; + +@property (nonatomic, assign) BOOL autoRoster; + +- (void)fetchRoster; + +- (void)addBuddy:(XMPPJID *)jid withNickname:(NSString *)optionalName; +- (void)removeBuddy:(XMPPJID *)jid; + +- (void)setNickname:(NSString *)nickname forBuddy:(XMPPJID *)jid; + +- (void)acceptBuddyRequest:(XMPPJID *)jid; +- (void)rejectBuddyRequest:(XMPPJID *)jid; + +- (id )myUser; +- (id )myResource; + +- (id )userForJID:(XMPPJID *)jid; +- (id )resourceForJID:(XMPPJID *)jid; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPRosterStorage +@required + +// +// +// -- PUBLIC METHODS -- +// +// + +- (id )myUserForXMPPStream:(XMPPStream *)stream; +- (id )myResourceForXMPPStream:(XMPPStream *)stream; + +- (id )userForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; +- (id )resourceForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +// +// +// -- PRIVATE METHODS -- +// +// These methods are designed to be used ONLY by the XMPPRoster class. +// +// + +/** + * Configures the storage class, passing its parent and parent's dispatch queue. + * + * This method is called by the init method of the XMPPRoster class. + * This method is designed to inform the storage class of its parent + * and of the dispatch queue the parent will be operating on. + * + * The storage class may choose to operate on the same queue as its parent, + * or it may operate on its own internal dispatch queue. + * + * This method should return YES if it was configured properly. + * If a storage class is designed to be used with a single parent at a time, this method may return NO. + * The XMPPRoster class is configured to ignore the passed + * storage class in its init method if this method returns NO. +**/ +- (BOOL)configureWithParent:(XMPPRoster *)aParent queue:(dispatch_queue_t)queue; + +- (void)beginRosterPopulationForXMPPStream:(XMPPStream *)stream; +- (void)endRosterPopulationForXMPPStream:(XMPPStream *)stream; + +- (void)handleRosterItem:(NSXMLElement *)item xmppStream:(XMPPStream *)stream; +- (void)handlePresence:(XMPPPresence *)presence xmppStream:(XMPPStream *)stream; + +- (void)clearAllResourcesForXMPPStream:(XMPPStream *)stream; +- (void)clearAllUsersAndResourcesForXMPPStream:(XMPPStream *)stream; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPRosterDelegate +@optional + +/** + * Sent when a buddy request is received. + * + * The entire presence packet is provided for proper extensibility. + * You can use [presence from] to get the JID of the buddy who sent the request. +**/ +- (void)xmppRoster:(XMPPRoster *)sender didReceiveBuddyRequest:(XMPPPresence *)presence; + +@end diff --git a/xmpp/Extensions/Roster/XMPPRoster.m b/xmpp/Extensions/Roster/XMPPRoster.m new file mode 100644 index 0000000..e5f3963 --- /dev/null +++ b/xmpp/Extensions/Roster/XMPPRoster.m @@ -0,0 +1,606 @@ +#import "XMPPRoster.h" +#import "XMPP.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +enum XMPPRosterFlags +{ + kAutoRoster = 1 << 0, // If set, we automatically request roster after authentication + kRequestedRoster = 1 << 1, // If set, we have requested the roster + kHasRoster = 1 << 2, // If set, we have received the roster +}; + +@interface XMPPRoster (PrivateAPI) + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPRoster + +@dynamic xmppRosterStorage; +@dynamic autoRoster; + +- (id)init +{ + return [self initWithRosterStorage:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + return [self initWithRosterStorage:nil dispatchQueue:queue]; +} + +- (id)initWithRosterStorage:(id )storage +{ + return [self initWithRosterStorage:storage dispatchQueue:NULL]; +} + +- (id)initWithRosterStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(storage != nil); + + if ((self = [super initWithDispatchQueue:queue])) + { + if ([storage configureWithParent:self queue:moduleQueue]) + { + xmppRosterStorage = [storage retain]; + } + else + { + XMPPLogError(@"%@: %@ - Unable to configure storage!", THIS_FILE, THIS_METHOD); + } + + flags = 0; + earlyPresenceElements = [[NSMutableArray alloc] initWithCapacity:2]; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + XMPPLogTrace(); + + if ([super activate:aXmppStream]) + { + XMPPLogVerbose(@"%@: Activated", THIS_FILE); + + // Custom code goes here (if needed) + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + XMPPLogTrace(); + + // Custom code goes here (if needed) + + [super deactivate]; +} + +- (void)dealloc +{ + [xmppRosterStorage release]; + [earlyPresenceElements release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Internal +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method is used by XMPPRosterStorage classes. +**/ +- (GCDMulticastDelegate *)multicastDelegate +{ + return multicastDelegate; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)moduleName +{ + return @"XMPPRoster"; +} + +- (id )xmppRosterStorage +{ + // Note: The xmppRosterStorage variable is read-only (set in the init method) + + return [[xmppRosterStorage retain] autorelease]; +} + +- (BOOL)autoRoster +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (flags & kAutoRoster) ? YES : NO; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +- (void)setAutoRoster:(BOOL)flag +{ + dispatch_block_t block = ^{ + + if (flag) + flags |= kAutoRoster; + else + flags &= ~kAutoRoster; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Buddy Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)addBuddy:(XMPPJID *)jid withNickname:(NSString *)optionalName +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (jid == nil) return; + + XMPPJID *myJID = xmppStream.myJID; + + if ([[myJID bare] isEqualToString:[jid bare]]) + { + // No, you don't need to add yourself + return; + } + + // Add the buddy to our roster + // + // + // + // + // + // + + NSXMLElement *item = [NSXMLElement elementWithName:@"item"]; + [item addAttributeWithName:@"jid" stringValue:[jid bare]]; + + if (optionalName) + { + [item addAttributeWithName:@"name" stringValue:optionalName]; + } + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:roster"]; + [query addChild:item]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; + + // Subscribe to the buddy's presence + // + // + + NSXMLElement *presence = [NSXMLElement elementWithName:@"presence"]; + [presence addAttributeWithName:@"to" stringValue:[jid bare]]; + [presence addAttributeWithName:@"type" stringValue:@"subscribe"]; + + [xmppStream sendElement:presence]; +} + +- (void)removeBuddy:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (jid == nil) return; + + XMPPJID *myJID = xmppStream.myJID; + + if ([[myJID bare] isEqualToString:[jid bare]]) + { + // No, you shouldn't remove yourself + return; + } + + // Remove the buddy from our roster + // Unsubscribe from presence + // And revoke contact's subscription to our presence + // ...all in one step + + // + // + // + // + // + + NSXMLElement *item = [NSXMLElement elementWithName:@"item"]; + [item addAttributeWithName:@"jid" stringValue:[jid bare]]; + [item addAttributeWithName:@"subscription" stringValue:@"remove"]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:roster"]; + [query addChild:item]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +- (void)setNickname:(NSString *)nickname forBuddy:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + if (jid == nil) return; + + // + // + // + // + // + + NSXMLElement *item = [NSXMLElement elementWithName:@"item"]; + [item addAttributeWithName:@"jid" stringValue:[jid bare]]; + [item addAttributeWithName:@"name" stringValue:nickname]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:roster"]; + [query addChild:item]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +- (void)acceptBuddyRequest:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + // Send presence response + // + // + + NSXMLElement *response = [NSXMLElement elementWithName:@"presence"]; + [response addAttributeWithName:@"to" stringValue:[jid bare]]; + [response addAttributeWithName:@"type" stringValue:@"subscribed"]; + + [xmppStream sendElement:response]; + + // Add user to our roster + + [self addBuddy:jid withNickname:nil]; +} + +- (void)rejectBuddyRequest:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + // Send presence response + // + // + + NSXMLElement *response = [NSXMLElement elementWithName:@"presence"]; + [response addAttributeWithName:@"to" stringValue:[jid bare]]; + [response addAttributeWithName:@"type" stringValue:@"unsubscribed"]; + + [xmppStream sendElement:response]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)requestedRoster +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + return (flags & kRequestedRoster) ? YES : NO; +} + +- (void)setRequestedRoster:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (flag) + flags |= kRequestedRoster; + else + flags &= ~kRequestedRoster; +} + +- (BOOL)hasRoster +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + return (flags & kHasRoster) ? YES : NO; +} + +- (void)setHasRoster:(BOOL)flag +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (flag) + flags |= kHasRoster; + else + flags &= ~kHasRoster; +} + +- (void)fetchRoster +{ + // This is a public method. + // It may be invoked on any thread/queue. + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ([self requestedRoster]) + { + // We've already requested the roster from the server. + [pool drain]; + return; + } + + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:roster"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"get"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; + + [self setRequestedRoster:YES]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Roster methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )myUser { + return [xmppRosterStorage myUserForXMPPStream:xmppStream]; +} +- (id )myResource { + return [xmppRosterStorage myResourceForXMPPStream:xmppStream]; +} + +- (id )userForJID:(XMPPJID *)jid { + return [xmppRosterStorage userForJID:jid xmppStream:xmppStream]; +} + +- (id )resourceForJID:(XMPPJID *)jid { + return [xmppRosterStorage resourceForJID:jid xmppStream:xmppStream]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender +{ + // This method is invoked on the moduleQueue. + + XMPPLogTrace(); + + if ([self autoRoster]) + { + [self fetchRoster]; + } +} + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // This method is invoked on the moduleQueue. + + XMPPLogTrace(); + + // Note: Some jabber servers send an iq element with an xmlns. + // Because of the bug in Apple's NSXML (documented in our elementForName method), + // it is important we specify the xmlns for the query. + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"jabber:iq:roster"]; + if (query) + { + if (![self hasRoster]) + { + [xmppRosterStorage beginRosterPopulationForXMPPStream:xmppStream]; + } + + NSArray *items = [query elementsForName:@"item"]; + for (NSXMLElement *item in items) + { + // Filter out items for users who aren't actually in our roster. + // That is, those users who have requested to be our buddy, but we haven't approved yet. + + [xmppRosterStorage handleRosterItem:item xmppStream:xmppStream]; + } + + if (![self hasRoster]) + { + // We should have our roster now + + [self setHasRoster:YES]; + + // Which means we can process any premature presence elements we received. + // + // Note: We do this before invoking endRosterPopulation to enable optimizations + // concerning the possible presence storm. + + for (XMPPPresence *presence in earlyPresenceElements) + { + [self xmppStream:xmppStream didReceivePresence:presence]; + } + [earlyPresenceElements removeAllObjects]; + + // And finally, notify roster storage that the roster population is complete + [xmppRosterStorage endRosterPopulationForXMPPStream:xmppStream]; + } + + return YES; + } + + return NO; +} + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence +{ + // This method is invoked on the moduleQueue. + + XMPPLogTrace(); + + if (![self hasRoster]) + { + // We received a presence notification, + // but we don't have a roster to apply it to yet. + // + // This is possible if we send our presence before we've received our roster. + // It's even possible if we send our presence after we've requested our roster. + // There is no guarantee the server will process our requests serially, + // and the server may start sending presence elements before it sends our roster. + // + // However, if we've requested the roster, + // then it shouldn't be too long before we receive it. + // So we should be able to simply queue the presence elements for later processing. + + if ([self requestedRoster]) + { + // We store the presence element until we get our roster. + [earlyPresenceElements addObject:presence]; + } + else + { + // The user has not requested the roster. + // This is a rogue presence element, or the user is simply not using our roster management. + } + + return; + } + + if ([[presence type] isEqualToString:@"subscribe"]) + { + id user = [xmppRosterStorage userForJID:[presence from] xmppStream:xmppStream]; + + if (user && [self autoRoster]) + { + // Presence subscription request from someone who's already in our roster. + // Automatically approve. + // + // + + NSXMLElement *response = [NSXMLElement elementWithName:@"presence"]; + [response addAttributeWithName:@"to" stringValue:[[presence from] bare]]; + [response addAttributeWithName:@"type" stringValue:@"subscribed"]; + + [xmppStream sendElement:response]; + } + else + { + // Presence subscription request from someone who's NOT in our roster + + [multicastDelegate xmppRoster:self didReceiveBuddyRequest:presence]; + } + } + else + { + [xmppRosterStorage handlePresence:presence xmppStream:xmppStream]; + } +} + +- (void)xmppStream:(XMPPStream *)sender didSendPresence:(XMPPPresence *)presence +{ + // This method is invoked on the moduleQueue. + + XMPPLogTrace(); + + if ([[presence type] isEqualToString:@"unavailable"]) + { + // We don't receive presence notifications when we're offline. + // So we need to remove all resources from our roster when we're offline. + // When we become available again, we'll automatically receive the + // presence from every available user in our roster. + // + // We will receive general roster updates as long as we're still connected though. + // So there's no need to refetch the roster. + + [xmppRosterStorage clearAllResourcesForXMPPStream:xmppStream]; + + [earlyPresenceElements removeAllObjects]; + } +} + +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error +{ + // This method is invoked on the moduleQueue. + + XMPPLogTrace(); + + [xmppRosterStorage clearAllUsersAndResourcesForXMPPStream:xmppStream]; + + [self setRequestedRoster:NO]; + [self setHasRoster:NO]; + + [earlyPresenceElements removeAllObjects]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPvCardAvatarDelegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if TARGET_OS_IPHONE +- (void)xmppvCardAvatarModule:(XMPPvCardAvatarModule *)vCardTempModule + didReceivePhoto:(UIImage *)photo + forJID:(XMPPJID *)jid +#else +- (void)xmppvCardAvatarModule:(XMPPvCardAvatarModule *)vCardTempModule + didReceivePhoto:(NSImage *)photo + forJID:(XMPPJID *)jid +#endif +{ + id user = [self userForJID:jid]; + + if (user != nil) { + user.photo = photo; + } +} + +@end diff --git a/xmpp/Extensions/Roster/XMPPRosterPrivate.h b/xmpp/Extensions/Roster/XMPPRosterPrivate.h new file mode 100644 index 0000000..402d15e --- /dev/null +++ b/xmpp/Extensions/Roster/XMPPRosterPrivate.h @@ -0,0 +1,16 @@ +#import +#import "XMPPRoster.h" + +@interface XMPPRoster (PrivateInternalAPI) + +/** + * The XMPPRosterStorage classes use the same delegate(s) as their parent XMPPRoster. + * This method allows these classes to access the delegate(s). + * + * Note: If the storage class operates on a different queue than its parent, + * it MUST dispatch all calls to the multicastDelegate onto its parent's queue. + * The parent's dispatch queue is passed in the configureWithParent:queue: method. +**/ +- (GCDMulticastDelegate *)multicastDelegate; + +@end diff --git a/xmpp/Extensions/Roster/XMPPUser.h b/xmpp/Extensions/Roster/XMPPUser.h new file mode 100644 index 0000000..bf82ed8 --- /dev/null +++ b/xmpp/Extensions/Roster/XMPPUser.h @@ -0,0 +1,45 @@ +#import + +#if !TARGET_OS_IPHONE + #import +#endif + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPJID; +@class XMPPIQ; +@class XMPPPresence; +@protocol XMPPResource; + + +@protocol XMPPUser + +#if TARGET_OS_IPHONE +@property (nonatomic, retain) UIImage * photo; +#else +@property (nonatomic, retain) NSImage * photo; +#endif + +- (XMPPJID *)jid; +- (NSString *)nickname; + +- (NSString *)displayName; + +- (BOOL)isOnline; +- (BOOL)isPendingApproval; + +- (id )primaryResource; +- (id )resourceForJID:(XMPPJID *)jid; + +- (NSArray *)sortedResources; +- (NSArray *)unsortedResources; + +- (NSComparisonResult)compareByName:(id )another; +- (NSComparisonResult)compareByName:(id )another options:(NSStringCompareOptions)mask; + +- (NSComparisonResult)compareByAvailabilityName:(id )another; +- (NSComparisonResult)compareByAvailabilityName:(id )another options:(NSStringCompareOptions)mask; + +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.h b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.h new file mode 100644 index 0000000..21b6c89 --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.h @@ -0,0 +1,77 @@ +// +// XMPPIQ+JabberRPC.h +// XEP-0009 +// +// Created by Eric Chamberlain on 5/16/10. +// + +#import + +#import "XMPPIQ.h" + + +@interface XMPPIQ(JabberRPC) + +/** + * Creates and returns a new autoreleased XMPPIQ. + * This is the only method you normally need to call. + **/ ++ (XMPPIQ *)rpcTo:(XMPPJID *)jid methodName:(NSString *)method parameters:(NSArray *)parameters; + +#pragma mark - +#pragma mark Element helper methods + +// returns a Jabber-RPC query elelement +// ++(NSXMLElement *)elementRpcQuery; + +// returns a Jabber-RPC methodCall element +// ++(NSXMLElement *)elementMethodCall; + +// returns a Jabber-RPC methodName element +// method ++(NSXMLElement *)elementMethodName:(NSString *)method; + +// returns a Jabber-RPC params element +// ++(NSXMLElement *)elementParams; + +#pragma mark - +#pragma mark Disco elements + +// returns the Disco query identity element +// ++(NSXMLElement *)elementRpcIdentity; + +// returns the Disco query feature element +// ++(NSXMLElement *)elementRpcFeature; + +#pragma mark - +#pragma mark Conversion methods + +// encode any object into JabberRPC formatted element +// this method calls the others ++(NSXMLElement *)paramElementFromObject:(id)object; + ++(NSXMLElement *)valueElementFromObject:(id)object; + ++(NSXMLElement *)valueElementFromArray:(NSArray *)array; ++(NSXMLElement *)valueElementFromDictionary:(NSDictionary *)dictionary; + ++(NSXMLElement *)valueElementFromBoolean:(CFBooleanRef)boolean; ++(NSXMLElement *)valueElementFromNumber:(NSNumber *)number; ++(NSXMLElement *)valueElementFromString:(NSString *)string; ++(NSXMLElement *)valueElementFromDate:(NSDate *)date; ++(NSXMLElement *)valueElementFromData:(NSData *)data; + ++(NSXMLElement *)valueElementFromElementWithName:(NSString *)elementName value:(NSString *)value; + + +#pragma mark Wrapper methods + ++(NSXMLElement *)wrapElement:(NSString *)elementName aroundElement:(NSXMLElement *)element; ++(NSXMLElement *)wrapValueElementAroundElement:(NSXMLElement *)element; + +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.m b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.m new file mode 100644 index 0000000..23c8d2b --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPC.m @@ -0,0 +1,216 @@ +// +// XMPPIQ+JabberRPC.m +// XEP-0009 +// +// Created by Eric Chamberlain on 5/16/10. +// + +#import "XMPPIQ+JabberRPC.h" + +#import "NSData+XMPP.h" +#import "XMPP.h" + + +@implementation XMPPIQ(JabberRPC) + ++(XMPPIQ *)rpcTo:(XMPPJID *)jid methodName:(NSString *)method parameters:(NSArray *)parameters { + // Send JabberRPC element + // + // + // + // + // method + // + // + // example + // + // ... + // + // + // + // + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:jid elementID:[XMPPStream generateUUID]]; + + NSXMLElement *jabberRPC = [self elementRpcQuery]; + NSXMLElement *methodCall = [self elementMethodCall]; + NSXMLElement *methodName = [self elementMethodName:method]; + NSXMLElement *params = [self elementParams]; + + for (id parameter in parameters) { + [params addChild:[self paramElementFromObject:parameter]]; + } + + [methodCall addChild:methodName]; + [methodCall addChild:params]; + [jabberRPC addChild:methodCall]; + [iq addChild:jabberRPC]; + return iq; +} + +#pragma mark Element helper methods + ++(NSXMLElement *)elementRpcQuery { + return [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:rpc"]; +} + ++(NSXMLElement *)elementMethodCall { + return [NSXMLElement elementWithName:@"methodCall"]; +} + ++(NSXMLElement *)elementMethodName:(NSString *)method { + return [NSXMLElement elementWithName:@"methodName" stringValue:method]; +} + ++(NSXMLElement *)elementParams { + return [NSXMLElement elementWithName:@"params"]; +} + + +#pragma mark - +#pragma mark Disco elements + ++(NSXMLElement *)elementRpcIdentity { + NSXMLElement *identity = [NSXMLElement elementWithName:@"identity"]; + [identity addAttributeWithName:@"category" stringValue:@"automation"]; + [identity addAttributeWithName:@"type" stringValue:@"rpc"]; + return identity; +} + +// returns the Disco query feature element +// ++(NSXMLElement *)elementRpcFeature { + NSXMLElement *feature = [NSXMLElement elementWithName:@"feature"]; + [feature addAttributeWithName:@"var" stringValue:@"jabber:iq:rpc"]; + return feature; +} +#pragma mark Conversion methods + ++(NSXMLElement *)paramElementFromObject:(id)object { + if (!object) { + return nil; + } + return [self wrapElement:@"param" aroundElement:[self valueElementFromObject:object]]; +} + ++(NSXMLElement *)valueElementFromObject:(id)object { + if (!object) { + return nil; + } + + if ([object isKindOfClass: [NSArray class]]) { + return [self valueElementFromArray: object]; + } else if ([object isKindOfClass: [NSDictionary class]]) { + return [self valueElementFromDictionary: object]; + } else if (((CFBooleanRef)object == kCFBooleanTrue) || ((CFBooleanRef)object == kCFBooleanFalse)) { + return [self valueElementFromBoolean: (CFBooleanRef)object]; + } else if ([object isKindOfClass: [NSNumber class]]) { + return [self valueElementFromNumber: object]; + } else if ([object isKindOfClass: [NSString class]]) { + return [self valueElementFromString: object]; + } else if ([object isKindOfClass: [NSDate class]]) { + return [self valueElementFromDate: object]; + } else if ([object isKindOfClass: [NSData class]]) { + return [self valueElementFromData: object]; + } else { + return [self valueElementFromString: object]; + } + +} + + ++(NSXMLElement *)valueElementFromArray:(NSArray *)array { + NSXMLElement *data = [NSXMLElement elementWithName:@"data"]; + + for (id object in array) { + [data addChild:[self valueElementFromObject:object]]; + } + return [self wrapValueElementAroundElement:data]; +} + + ++(NSXMLElement *)valueElementFromDictionary:(NSDictionary *)dictionary { + NSXMLElement *structElement = [NSXMLElement elementWithName:@"struct"]; + + NSXMLElement *member; + NSXMLElement *name; + + for (NSString *key in dictionary) { + member = [NSXMLElement elementWithName:@"member"]; + name = [NSXMLElement elementWithName:@"name" stringValue:key]; + [member addChild:name]; + [member addChild:[self valueElementFromObject:[dictionary objectForKey:key]]]; + } + + return [self wrapValueElementAroundElement:structElement]; +} + + ++(NSXMLElement *)valueElementFromBoolean:(CFBooleanRef)boolean { + if (boolean == kCFBooleanTrue) { + return [self valueElementFromElementWithName:@"boolean" value:@"1"]; + } else { + return [self valueElementFromElementWithName:@"boolean" value:@"0"]; + } +} + + ++(NSXMLElement *)valueElementFromNumber:(NSNumber *)number { + // what type of NSNumber is this? + if ([[NSString stringWithCString: [number objCType] + encoding: NSUTF8StringEncoding] isEqualToString: @"d"]) { + return [self valueElementFromElementWithName:@"double" value:[number stringValue]]; + } else { + return [self valueElementFromElementWithName:@"i4" value:[number stringValue]]; + } +} + + ++(NSXMLElement *)valueElementFromString:(NSString *)string { + return [self valueElementFromElementWithName:@"string" value:string]; +} + + ++(NSXMLElement *)valueElementFromDate:(NSDate *)date { + unsigned calendarComponents = kCFCalendarUnitYear | + kCFCalendarUnitMonth | + kCFCalendarUnitDay | + kCFCalendarUnitHour | + kCFCalendarUnitMinute | + kCFCalendarUnitSecond; + NSDateComponents *dateComponents = [[NSCalendar currentCalendar] components:calendarComponents fromDate:date]; + NSString *dateString = [NSString stringWithFormat: @"%.4d%.2d%.2dT%.2d:%.2d:%.2d", + [dateComponents year], + [dateComponents month], + [dateComponents day], + [dateComponents hour], + [dateComponents minute], + [dateComponents second], + nil]; + + return [self valueElementFromElementWithName:@"dateTime.iso8601" value: dateString]; +} + + ++(NSXMLElement *)valueElementFromData:(NSData *)data { + return [self valueElementFromElementWithName:@"base64" value:[data base64Encoded]]; +} + ++(NSXMLElement *)valueElementFromElementWithName:(NSString *)elementName value:(NSString *)value { + return [self wrapValueElementAroundElement:[NSXMLElement elementWithName:elementName stringValue:value]]; +} + + +#pragma mark Wrapper methods + ++(NSXMLElement *)wrapElement:(NSString *)elementName aroundElement:(NSXMLElement *)element { + NSXMLElement *wrapper = [NSXMLElement elementWithName:elementName]; + [wrapper addChild:element]; + return wrapper; +} + ++(NSXMLElement *)wrapValueElementAroundElement:(NSXMLElement *)element { + return [self wrapElement:@"value" aroundElement:element]; +} + +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.h b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.h new file mode 100644 index 0000000..6347d38 --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.h @@ -0,0 +1,66 @@ +// +// XMPPIQ+JabberRPCResonse.h +// XEP-0009 +// +// Created by Eric Chamberlain on 5/25/10. +// + +#import "XMPPIQ.h" + +typedef enum { + JabberRPCElementTypeArray, + JabberRPCElementTypeDictionary, + JabberRPCElementTypeMember, + JabberRPCElementTypeName, + JabberRPCElementTypeInteger, + JabberRPCElementTypeDouble, + JabberRPCElementTypeBoolean, + JabberRPCElementTypeString, + JabberRPCElementTypeDate, + JabberRPCElementTypeData +} JabberRPCElementType; + + +@interface XMPPIQ(JabberRPCResonse) + +-(NSXMLElement *)methodResponseElement; + +// is this a Jabber RPC method response +-(BOOL)isMethodResponse; + +-(BOOL)isFault; + +-(BOOL)isJabberRPC; + +-(id)methodResponse:(NSError **)error; + +-(id)objectFromElement:(NSXMLElement *)param; + + +#pragma mark - + +-(NSArray *)parseArray:(NSXMLElement *)arrayElement; + +-(NSDictionary *)parseStruct:(NSXMLElement *)structElement; + +-(NSDictionary *)parseMember:(NSXMLElement *)memberElement; + +#pragma mark - + +- (NSDate *)parseDateString: (NSString *)dateString withFormat: (NSString *)format; + +#pragma mark - + +- (NSNumber *)parseInteger: (NSString *)value; + +- (NSNumber *)parseDouble: (NSString *)value; + +- (NSNumber *)parseBoolean: (NSString *)value; + +- (NSString *)parseString: (NSString *)value; + +- (NSDate *)parseDate: (NSString *)value; + +- (NSData *)parseData: (NSString *)value; + +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.m b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.m new file mode 100644 index 0000000..4d20b7d --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPIQ+JabberRPCResonse.m @@ -0,0 +1,291 @@ +// +// XMPPIQ+JabberRPCResonse.m +// XEP-0009 +// +// Created by Eric Chamberlain on 5/25/10. +// + +#import "XMPPIQ+JabberRPCResonse.h" + +#import "NSData+XMPP.h" +#import "NSXMLElement+XMPP.h" +#import "XMPPJabberRPCModule.h" + +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@implementation XMPPIQ(JabberRPCResonse) + +-(NSXMLElement *)methodResponseElement { + NSXMLElement *query = [self elementForName:@"query"]; + return [query elementForName:@"methodResponse"]; +} + +// is this a Jabber RPC method response +-(BOOL)isMethodResponse { + /* + + + + South Dakota + + + + */ + NSXMLElement *methodResponse = [self methodResponseElement]; + return methodResponse != nil; +} + +-(BOOL)isFault { + /* + + + + + + faultCode + 4 + + + faultString + Too many parameters. + + + + + + */ + NSXMLElement *methodResponse = [self methodResponseElement]; + + return [methodResponse elementForName:@"fault"] != nil; +} + +-(BOOL)isJabberRPC { + /* + + ... + + */ + NSXMLElement *rpcQuery = [self elementForName:@"query" xmlns:@"jabber:iq:rpc"]; + return rpcQuery != nil; +} + +-(id)methodResponse:(NSError **)error { + id response = nil; + + /* + + + + South Dakota + + + + */ + + // or + + /* + + + + + + faultCode + 4 + + + faultString + Too many parameters. + + + + + + */ + NSXMLElement *methodResponse = [self methodResponseElement]; + + // parse the methodResponse + + response = [self objectFromElement:(NSXMLElement *)[methodResponse childAtIndex:0]]; + + if ([self isFault]) { + // we should produce an error + // response should be a dict + if (error) { + *error = [NSError errorWithDomain:XMPPJabberRPCErrorDomain + code:[[response objectForKey:@"faultCode"] intValue] + userInfo:(NSDictionary *)response]; + } + response = nil; + } else { + if (error) { + *error = nil; + } + } + + return response; +} + +-(id)objectFromElement:(NSXMLElement *)param { + NSString *element = [param name]; + + if ([element isEqualToString:@"params"] || + [element isEqualToString:@"param"] || + [element isEqualToString:@"fault"] || + [element isEqualToString:@"value"]) { + + NSXMLElement *firstChild = (NSXMLElement *)[param childAtIndex:0]; + if (firstChild) { + return [self objectFromElement:firstChild]; + } else { + // no child element, treat it like a string + return [self parseString:[param stringValue]]; + } + } else if ([element isEqualToString:@"string"] || + [element isEqualToString:@"name"]) { + return [self parseString:[param stringValue]]; + } else if ([element isEqualToString:@"member"]) { + return [self parseMember:param]; + } else if ([element isEqualToString:@"array"]) { + return [self parseArray:param]; + } else if ([element isEqualToString:@"struct"]) { + return [self parseStruct:param]; + } else if ([element isEqualToString:@"int"]) { + return [self parseInteger:[param stringValue]]; + } else if ([element isEqualToString:@"double"]) { + return [self parseDouble:[param stringValue]]; + } else if ([element isEqualToString:@"boolean"]) { + return [self parseBoolean:[param stringValue]]; + } else if ([element isEqualToString:@"dateTime.iso8601"]) { + return [self parseDate:[param stringValue]]; + } else if ([element isEqualToString:@"base64"]) { + return [self parseData:[param stringValue]]; + } else { + // bad element + XMPPLogWarn(@"%@: %@ - bad element: %@", THIS_FILE, THIS_METHOD, [param stringValue]); + } + return nil; +} + + +#pragma mark - + +-(NSArray *)parseArray:(NSXMLElement *)arrayElement { + /* + + + 12 + Egypt + 0 + -31 + + + */ + NSXMLElement *data = (NSXMLElement *)[arrayElement childAtIndex:0]; + NSArray *children = [data children]; + + NSMutableArray *array = [NSMutableArray arrayWithCapacity:[children count]]; + + for (NSXMLElement *child in children) { + [array addObject:[self objectFromElement:child]]; + } + + return array; +} + +-(NSDictionary *)parseStruct:(NSXMLElement *)structElement { + /* + + + lowerBound + 18 + + + upperBound + 139 + + + */ + NSArray *children = [structElement children]; + NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:[children count]]; + + for (NSXMLElement *child in children) { + [dict addEntriesFromDictionary:[self parseMember:child]]; + } + + return dict; +} + +-(NSDictionary *)parseMember:(NSXMLElement *)memberElement { + NSString *key = [self objectFromElement:[memberElement elementForName:@"name"]]; + id value = [self objectFromElement:[memberElement elementForName:@"value"]]; + + return [NSDictionary dictionaryWithObject:value forKey:key]; +} + +#pragma mark - + +- (NSDate *)parseDateString: (NSString *)dateString withFormat: (NSString *)format { + NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init]; + NSDate *result = nil; + + [dateFormatter setDateFormat: format]; + + result = [dateFormatter dateFromString: dateString]; + + [dateFormatter release]; + + return result; +} + +#pragma mark - + +- (NSNumber *)parseInteger: (NSString *)value { + return [NSNumber numberWithInteger: [value integerValue]]; +} + +- (NSNumber *)parseDouble: (NSString *)value { + return [NSNumber numberWithDouble: [value doubleValue]]; +} + +- (NSNumber *)parseBoolean: (NSString *)value { + if ([value isEqualToString: @"1"]) { + return [NSNumber numberWithBool: YES]; + } + + return [NSNumber numberWithBool: NO]; +} + +- (NSString *)parseString: (NSString *)value { + return [value stringByTrimmingCharactersInSet: [NSCharacterSet whitespaceAndNewlineCharacterSet]]; +} + +- (NSDate *)parseDate: (NSString *)value { + NSDate *result = nil; + + result = [self parseDateString: value withFormat: @"yyyyMMdd'T'HH:mm:ss"]; + + if (!result) { + result = [self parseDateString: value withFormat: @"yyyy'-'MM'-'dd'T'HH:mm:ss"]; + } + + return result; +} + +- (NSData *)parseData: (NSString *)value { + // Convert the base 64 encoded data into a string + NSData *base64Data = [value dataUsingEncoding:NSASCIIStringEncoding]; + NSData *decodedData = [base64Data base64Decoded]; + + return decodedData; +} + + +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.h b/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.h new file mode 100644 index 0000000..39471c3 --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.h @@ -0,0 +1,48 @@ +// +// XMPPJabberRPCModule.h +// XEP-0009 +// +// Originally created by Eric Chamberlain on 5/16/10. +// + +#import +#import "XMPPModule.h" + +extern NSString *const XMPPJabberRPCErrorDomain; + +@class XMPPJID; +@class XMPPStream; +@class XMPPIQ; +@protocol XMPPJabberRPCModuleDelegate; + + +@interface XMPPJabberRPCModule : XMPPModule +{ + NSMutableDictionary *rpcIDs; + NSTimeInterval defaultTimeout; +} + +@property (nonatomic, assign) NSTimeInterval defaultTimeout; + +- (NSString *)sendRpcIQ:(XMPPIQ *)iq; +- (NSString *)sendRpcIQ:(XMPPIQ *)iq withTimeout:(NSTimeInterval)timeout; + +// caller knows best when a request has timed out +// it should remove the rpcID, on timeout. +- (void)timeoutRemoveRpcID:(NSString *)rpcID; + +@end + + +@protocol XMPPJabberRPCModuleDelegate +@optional + +// sent when transport error is received +-(void)jabberRPC:(XMPPJabberRPCModule *)sender elementID:(NSString *)elementID didReceiveError:(NSError *)error; + +// sent when a methodResponse comes back +-(void)jabberRPC:(XMPPJabberRPCModule *)sender elementID:(NSString *)elementID didReceiveMethodResponse:(id)response; + +// sent when a Jabber-RPC server request is received +-(void)jabberRPC:(XMPPJabberRPCModule *)sender didReceiveSetIQ:(XMPPIQ *)iq; +@end diff --git a/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.m b/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.m new file mode 100644 index 0000000..99c1e78 --- /dev/null +++ b/xmpp/Extensions/XEP-0009/XMPPJabberRPCModule.m @@ -0,0 +1,349 @@ +// +// XMPPJabberRPCModule.m +// XEP-0009 +// +// Originally created by Eric Chamberlain on 5/16/10. +// + +#import "XMPPJabberRPCModule.h" +#import "XMPP.h" +#import "XMPPIQ+JabberRPC.h" +#import "XMPPIQ+JabberRPCResonse.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +// can turn off if not acting as a Jabber-RPC server +#define INTEGRATE_WITH_CAPABILITIES 1 + +#if INTEGRATE_WITH_CAPABILITIES +#import "XMPPCapabilities.h" +#endif + +NSString *const XMPPJabberRPCErrorDomain = @"XMPPJabberRPCErrorDomain"; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface RPCID : NSObject +{ + NSString *rpcID; + dispatch_source_t timer; +} + +@property (nonatomic, readonly) NSString *rpcID; +@property (nonatomic, readonly) dispatch_source_t timer; + +- (id)initWithRpcID:(NSString *)rpcID timer:(dispatch_source_t)timer; + +- (void)cancelTimer; + +@end + +@implementation RPCID + +@synthesize rpcID; +@synthesize timer; + +- (id)initWithRpcID:(NSString *)aRpcID timer:(dispatch_source_t)aTimer +{ + if ((self = [super init])) + { + rpcID = [aRpcID copy]; + + timer = aTimer; + dispatch_retain(timer); + } + return self; +} + +- (BOOL)isEqual:(id)anObject +{ + return [rpcID isEqual:anObject]; +} + +- (NSUInteger)hash +{ + return [rpcID hash]; +} + +- (void)cancelTimer +{ + if (timer) + { + dispatch_source_cancel(timer); + dispatch_release(timer); + timer = NULL; + } +} + +- (void)dealloc +{ + [self cancelTimer]; + [rpcID release]; + + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPJabberRPCModule + +@dynamic defaultTimeout; + +- (NSTimeInterval)defaultTimeout +{ + __block NSTimeInterval result; + + dispatch_block_t block = ^{ + result = defaultTimeout; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +- (void)setDefaultTimeout:(NSTimeInterval)newDefaultTimeout +{ + dispatch_block_t block = ^{ + XMPPLogTrace(); + defaultTimeout = newDefaultTimeout; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Module Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super initWithDispatchQueue:queue])) + { + XMPPLogTrace(); + + rpcIDs = [[NSMutableDictionary alloc] initWithCapacity:5]; + defaultTimeout = 5.0; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + XMPPLogTrace(); + + if ([super activate:aXmppStream]) + { + #if INTEGRATE_WITH_CAPABILITIES + [xmppStream autoAddDelegate:self delegateQueue:moduleQueue toModulesOfClass:[XMPPCapabilities class]]; + #endif + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + XMPPLogTrace(); + +#if INTEGRATE_WITH_CAPABILITIES + [xmppStream removeAutoDelegate:self delegateQueue:moduleQueue fromModulesOfClass:[XMPPCapabilities class]]; +#endif + + [super deactivate]; +} + +- (void)dealloc +{ + XMPPLogTrace(); + + [rpcIDs release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Send RPC +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)sendRpcIQ:(XMPPIQ *)iq +{ + return [self sendRpcIQ:iq withTimeout:[self defaultTimeout]]; +} + +- (NSString *)sendRpcIQ:(XMPPIQ *)iq withTimeout:(NSTimeInterval)timeout +{ + XMPPLogTrace(); + + NSString *elementID = [iq elementID]; + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(timer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self timeoutRemoveRpcID:elementID]; + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(timer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timer); + + RPCID *rpcID = [[RPCID alloc] initWithRpcID:elementID timer:timer]; + + [rpcIDs setObject:rpcID forKey:elementID]; + [rpcID release]; + + [xmppStream sendElement:iq]; + + return elementID; +} + +- (void)timeoutRemoveRpcID:(NSString *)elementID +{ + XMPPLogTrace(); + + RPCID *rpcID = [rpcIDs objectForKey:elementID]; + if (rpcID) + { + [rpcID cancelTimer]; + [rpcIDs removeObjectForKey:elementID]; + + NSError *error = [NSError errorWithDomain:XMPPJabberRPCErrorDomain + code:1400 + userInfo:[NSDictionary dictionaryWithObjectsAndKeys: + @"Request timed out", @"error",nil]]; + + [multicastDelegate jabberRPC:self elementID:elementID didReceiveError:error]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + if ([iq isJabberRPC]) + { + if ([iq isResultIQ] || [iq isErrorIQ]) + { + // Example: + // + // + + NSString *elementID = [iq elementID]; + + // check if this is a JabberRPC query + // we could check the query element, but we should be able to do a lookup based on the unique elementID + // because we send an ID, we should get one back + + RPCID *rpcID = [rpcIDs objectForKey:elementID]; + if (rpcID == nil) + { + return NO; + } + + XMPPLogVerbose(@"%@: Received RPC response!", THIS_FILE); + + if ([iq isResultIQ]) + { + id response; + NSError *error = nil; + + //TODO: parse iq and generate response. + response = [iq methodResponse:&error]; + + if (error == nil) { + [multicastDelegate jabberRPC:self elementID:elementID didReceiveMethodResponse:response]; + } else { + [multicastDelegate jabberRPC:self elementID:elementID didReceiveError:error]; + } + + } + else + { + // TODO: implement error parsing + // not much specified in XEP, only 403 forbidden error + NSXMLElement *errorElement = [iq childErrorElement]; + NSError *error = [NSError errorWithDomain:XMPPJabberRPCErrorDomain + code:[errorElement attributeIntValueForName:@"code"] + userInfo:[NSDictionary dictionaryWithObjectsAndKeys: + [errorElement attributesAsDictionary],@"error", + [[errorElement childAtIndex:0] name], @"condition", + iq,@"iq", + nil]]; + + [multicastDelegate jabberRPC:self elementID:elementID didReceiveError:error]; + } + + [rpcID cancelTimer]; + [rpcIDs removeObjectForKey:elementID]; + +#if INTEGRATE_WITH_CAPABILITIES + } else if ([iq isSetIQ]) { + // we would receive set when implementing Jabber-RPC server + + [multicastDelegate jabberRPC:self didReceiveSetIQ:iq]; +#endif + } + + // Jabber-RPC doesn't use get iq type + } + return NO; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPCapabilities delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if INTEGRATE_WITH_CAPABILITIES +/** + * If an XMPPCapabilites instance is used we want to advertise our support for JabberRPC. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender collectingMyCapabilities:(NSXMLElement *)query +{ + XMPPLogTrace(); + + // + // ... + // + // + // ... + // + [query addChild:[XMPPIQ elementRpcIdentity]]; + [query addChild:[XMPPIQ elementRpcFeature]]; +} +#endif + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.h b/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.h new file mode 100644 index 0000000..047fdf6 --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.h @@ -0,0 +1,10 @@ +#import +#import "XMPPMessage.h" + + +@interface XMPPMessage(XEP0045) + +- (BOOL)isGroupChatMessage; +- (BOOL)isGroupChatMessageWithBody; + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.m b/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.m new file mode 100644 index 0000000..9350c45 --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPMessage+XEP0045.m @@ -0,0 +1,24 @@ +#import "XMPPMessage+XEP0045.h" +#import "NSXMLElement+XMPP.h" + + +@implementation XMPPMessage(XEP0045) + +- (BOOL)isGroupChatMessage +{ + return [[[self attributeForName:@"type"] stringValue] isEqualToString:@"groupchat"]; +} + +- (BOOL)isGroupChatMessageWithBody +{ + if ([self isGroupChatMessage]) + { + NSString *body = [[self elementForName:@"body"] stringValue]; + + return ((body != nil) && ([body length] > 0)); + } + + return NO; +} + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPRoom.h b/xmpp/Extensions/XEP-0045/XMPPRoom.h new file mode 100644 index 0000000..e83f825 --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPRoom.h @@ -0,0 +1,58 @@ +// +// XMPPRoom +// A chat room. XEP-0045 Implementation. +// + +#import + +#import "XMPP.h" +#import "XMPPRoomOccupant.h" + +@interface XMPPRoom : XMPPModule +{ + NSString *roomName; + NSString *nickName; + NSString *subject; + NSString *invitedUser; + BOOL _isJoined; + NSMutableDictionary *occupants; +} + +- (id)initWithRoomName:(NSString *)roomName nickName:(NSString *)nickName; +- (id)initWithRoomName:(NSString *)roomName nickName:(NSString *)nickName dispatchQueue:(dispatch_queue_t)queue; + +@property (readonly) NSString *roomName; +@property (readonly) NSString *nickName; +@property (readonly) NSString *subject; + +@property (readonly, assign) BOOL isJoined; + +@property (readonly) NSDictionary *occupants; + +@property (readwrite, copy) NSString *invitedUser; + +- (void)createOrJoinRoom; +- (void)joinRoom; +- (void)leaveRoom; + +- (void)chageNickForRoom:(NSString *)name; + +- (void)inviteUser:(XMPPJID *)jid withMessage:(NSString *)invitationMessage; +- (void)acceptInvitation; +- (void)rejectInvitation; +- (void)rejectInvitationWithMessage:(NSString *)reasonForRejection; + +- (void)sendMessage:(NSString *)msg; + +@end + +@protocol XMPPRoomDelegate +@optional + +- (void)xmppRoomDidCreate:(XMPPRoom *)sender; +- (void)xmppRoomDidEnter:(XMPPRoom *)sender; +- (void)xmppRoomDidLeave:(XMPPRoom *)sender; +- (void)xmppRoom:(XMPPRoom *)sender didReceiveMessage:(XMPPMessage *)message fromNick:(NSString *)nick; +- (void)xmppRoom:(XMPPRoom *)sender didChangeOccupants:(NSDictionary *)occupants; + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPRoom.m b/xmpp/Extensions/XEP-0045/XMPPRoom.m new file mode 100644 index 0000000..408c1ee --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPRoom.m @@ -0,0 +1,710 @@ +#import "XMPPRoom.h" +#import "XMPPMessage+XEP0045.h" +#import "XMPPLogging.h" + + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +static NSString *const XMPPMUCNamespaceName = @"http://jabber.org/protocol/muc"; +static NSString *const XMPPMUCUserNamespaceName = @"http://jabber.org/protocol/muc#user"; +static NSString *const XMPPMUCOwnerNamespaceName = @"http://jabber.org/protocol/muc#owner"; + +@interface XMPPRoom () +@property (readwrite, assign) BOOL isJoined; +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPRoom + +@dynamic roomName; +@dynamic nickName; +@dynamic subject; +@dynamic isJoined; +@dynamic occupants; +@dynamic invitedUser; + +- (id)init +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPRoom.h are supported. + + return [self initWithRoomName:nil nickName:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPRoom.h are supported. + + return [self initWithRoomName:nil nickName:nil dispatchQueue:NULL]; +} + +- (id)initWithRoomName:(NSString *)aRoomName nickName:(NSString *)aNickName +{ + return [self initWithRoomName:aRoomName nickName:aNickName dispatchQueue:NULL]; +} + +- (id)initWithRoomName:(NSString *)aRoomName nickName:(NSString *)aNickName dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(aRoomName != nil); + NSParameterAssert(aNickName != nil); + + if ((self = [super initWithDispatchQueue:queue])) + { + roomName = [aRoomName copy]; + nickName = [aNickName copy]; + + occupants = [[NSMutableDictionary alloc] init]; + + XMPPLogTrace2(@"%@: init -> roomName(%@) nickName(%@)", [self class], roomName, nickName); + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + // Custom code goes here (if needed) + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + XMPPLogTrace(); + + if (self.isJoined) + { + [self leaveRoom]; + } + + [super deactivate]; +} + +- (void)dealloc +{ + [roomName release]; + [nickName release]; + [subject release]; + [invitedUser release]; + [occupants release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)roomName +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return roomName; + } + else + { + // This variable is readonly - set in init method and never changed. + + return [[roomName retain] autorelease]; + } +} + +- (NSString *)nickName +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return nickName; + } + else + { + // This variable is readonly - set in init method and never changed. + + return [[nickName retain] autorelease]; + } +} + +- (NSString *)subject +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return subject; + } + else + { + __block NSString *result; + + dispatch_sync(moduleQueue, ^{ + result = [subject retain]; + }); + + return [result autorelease]; + } +} + +- (BOOL)isJoined +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return _isJoined; + } + else + { + __block BOOL result; + + dispatch_sync(moduleQueue, ^{ + result = _isJoined; + }); + + return result; + } +} + +- (void)setIsJoined:(BOOL)newIsJoined +{ + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + if (_isJoined != newIsJoined) + { + _isJoined = newIsJoined; + + if (newIsJoined) + [multicastDelegate xmppRoomDidEnter:self]; + else + [multicastDelegate xmppRoomDidLeave:self]; + } +} + +- (NSDictionary *)occupants +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return occupants; + } + else + { + __block NSDictionary *result; + + dispatch_sync(moduleQueue, ^{ + result = [occupants copy]; + }); + + return [result autorelease]; + } +} + +- (NSString *)invitedUser +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return invitedUser; + } + else + { + __block NSString *result; + + dispatch_sync(moduleQueue, ^{ + result = [invitedUser retain]; + }); + + return [result autorelease]; + } +} + +- (void)setInvitedUser:(NSString *)newInvitedUser +{ + if (dispatch_get_current_queue() == moduleQueue) + { + if (![invitedUser isEqual:newInvitedUser]) + { + [invitedUser release]; + invitedUser = [newInvitedUser retain]; + } + } + else + { + NSString *newInvitedUserCopy = [newInvitedUser copy]; + + dispatch_async(moduleQueue, ^{ + + if (![invitedUser isEqual:newInvitedUserCopy]) + { + [invitedUser release]; + invitedUser = [newInvitedUserCopy retain]; + } + }); + + [newInvitedUserCopy release]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Room Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)createOrJoinRoom +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + // + // + + NSString *to = [NSString stringWithFormat:@"%@/%@", roomName, nickName]; + + NSXMLElement *x = [NSXMLElement elementWithName:@"x" xmlns:XMPPMUCNamespaceName]; + + XMPPPresence *presence = [XMPPPresence presence]; + [presence addAttributeWithName:@"to" stringValue:to]; + [presence addChild:x]; + + [xmppStream sendElement:presence]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)sendInstantRoomConfig +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + // + // + // + // + + NSXMLElement *x = [NSXMLElement elementWithName:@"x" xmlns:@"jabber:x:data"]; + [x addAttributeWithName:@"type" stringValue:@"submit"]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:XMPPMUCOwnerNamespaceName]; + [query addChild:x]; + + XMPPIQ *iq = [XMPPIQ iq]; + [iq addAttributeWithName:@"id" stringValue:[NSString stringWithFormat:@"inroom-cr%@", roomName]]; + [iq addAttributeWithName:@"to" stringValue:roomName]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)joinRoom +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + + NSString *to = [NSString stringWithFormat:@"%@/%@", roomName, nickName]; + + XMPPPresence *presence = [XMPPPresence presence]; + [presence addAttributeWithName:@"to" stringValue:to]; + + [xmppStream sendElement:presence]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)leaveRoom +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + + NSString *to = [NSString stringWithFormat:@"%@/%@", roomName, nickName]; + + XMPPPresence *presence = [XMPPPresence presence]; + [presence addAttributeWithName:@"to" stringValue:to]; + [presence addAttributeWithName:@"type" stringValue:@"unavailable"]; + + [xmppStream sendElement:presence]; + self.isJoined = NO; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +/** + * Changes the nickname for room by joining room again with new nick. +**/ +- (void)chageNickForRoom:(NSString *)newNickName +{ + NSString *newNickNameCopy = [newNickName copy]; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + if (![nickName isEqual:newNickNameCopy]) + { + [nickName release]; + nickName = [newNickNameCopy retain]; + + [self joinRoom]; + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); + + [newNickNameCopy release]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark RoomInvite Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)inviteUser:(XMPPJID *)jid withMessage:(NSString *)inviteMessageStr +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + // + // + // + // Hey Hecate, this is the place for all good witches! + // + // + // + // + + NSXMLElement *reason = [NSXMLElement elementWithName:@"reason" stringValue:inviteMessageStr]; + + NSXMLElement *invite = [NSXMLElement elementWithName:@"invite"]; + [invite addAttributeWithName:@"to" stringValue:[jid full]]; + [invite addChild:reason]; + + NSXMLElement *x = [NSXMLElement elementWithName:@"x" xmlns:XMPPMUCUserNamespaceName]; + [x addChild:invite]; + + XMPPMessage *message = [XMPPMessage message]; + [message addAttributeWithName:@"to" stringValue:roomName]; + [message addChild:x]; + + [xmppStream sendElement:message]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)acceptInvitation +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // Just need to send presence to room to accept it. We are done. + [self joinRoom]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)rejectInvitation +{ + [self rejectInvitationWithMessage:nil]; +} + +- (void)rejectInvitationWithMessage:(NSString *)rejectMessageStr +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + // + // + // + // Sorry, I'm too busy right now. + // + // + // + // + + NSXMLElement *reason = nil; + if (rejectMessageStr) + { + reason = [NSXMLElement elementWithName:@"reason" stringValue:rejectMessageStr]; + } + + NSXMLElement *decline = [NSXMLElement elementWithName:@"decline"]; + [decline addAttributeWithName:@"to" stringValue:invitedUser]; + if (reason) + { + [decline addChild:reason]; + } + + NSXMLElement *x = [NSXMLElement elementWithName:@"x" xmlns:XMPPMUCUserNamespaceName]; + [x addChild:decline]; + + NSXMLElement *message = [XMPPMessage message]; + [message addAttributeWithName:@"to" stringValue:roomName]; + [message addChild:x]; + + [xmppStream sendElement:message]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Message Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)sendMessage:(NSString *)msg +{ + if ([msg length] == 0) return; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + // + // I'll give thee a wind. + // + + NSXMLElement *body = [NSXMLElement elementWithName:@"body" stringValue:msg]; + + XMPPMessage *message = [XMPPMessage message]; + [message addAttributeWithName:@"to" stringValue:roomName]; + [message addAttributeWithName:@"type" stringValue:@"groupchat"]; + [message addChild:body]; + + [xmppStream sendElement:message]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)onDidChangeOccupants +{ + // We cannot directly pass our NSMutableDictionary *occupants + // to the delegates as NSMutableDictionary is not thread-safe. + // + // And even if it was, we don't want this dictionary changing on them. + // That's what this delegate method is for. + // + // So we create an immutable copy of the dictionary to send to the delegates. + // And we don't have to worry about the XMPPRoomOccupant objects changing as they are immutable. + + NSDictionary *occupantsCopy = [occupants copy]; + + [multicastDelegate xmppRoom:self didChangeOccupants:occupantsCopy]; + + [occupants release]; +} + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + NSArray *components = [[presence fromStr] componentsSeparatedByString:@"/"]; + + NSString *aRoomName = [components count] > 0 ? [components objectAtIndex:0] : nil; + NSString *aNickName = [components count] > 1 ? [components objectAtIndex:1] : nil; + + if (![aRoomName isEqualToString:roomName]) return; + + XMPPLogTrace2(@"%@: didReceivePresence: ROOM: %@", [self class], roomName); + + NSXMLElement *priorityElement = [presence elementForName:@"priority"]; + if (priorityElement) + XMPPLogVerbose(@"%@: didReceivePresence: priority:%@", [self class], [priorityElement stringValue]); + + NSXMLElement *x = [presence elementForName:@"x" xmlns:XMPPMUCUserNamespaceName]; + NSXMLElement *xItem = [x elementForName:@"item"]; + + NSString *jidStr = [xItem attributeStringValueForName:@"jid"]; + NSString *role = [xItem attributeStringValueForName:@"role"]; + NSString *newNick = [xItem attributeStringValueForName:@"nick"]; + + XMPPLogVerbose(@"%@: didReceivePresence: nick:%@ role:%@ newnick:%@ jid:%@", + [self class], aNickName, role, newNick, jidStr); + + if (newNick) + { + // We are joined, getting presence for room + self.isJoined = YES; + + // Handle nick Change having "nick" in element. + [occupants removeObjectForKey:aNickName]; + + // Add new room occupant + XMPPJID *jid = [XMPPJID jidWithString:jidStr]; + XMPPRoomOccupant *occupant = [XMPPRoomOccupant occupantWithJID:jid nick:newNick role:role]; + + [occupants setObject:occupant forKey:newNick]; + [self onDidChangeOccupants]; + + return; + } + else if (aNickName) + { + if ([[presence type] isEqualToString:@"unavailable"]) + { + if ([aNickName isEqualToString:nickName]) + { + // We got presence from our nick to us about leaving. + self.isJoined = NO; + + [occupants removeAllObjects]; + [self onDidChangeOccupants]; + } + else + { + // We're getting presence from the room, so that means we are joined + self.isJoined = YES; + + // This is about some one else leaving the Room. + // Remove them and notify delegate. + + [occupants removeObjectForKey:aNickName]; + [self onDidChangeOccupants]; + } + } + else + { + // We're getting presence from the room, so that means we are joined + self.isJoined = YES; + + // This is about some sort of available presence. i don't mind even if they are busy. + // if the user is there. no need to notify. let's check that. + XMPPRoomOccupant *occupant = [occupants objectForKey:aNickName]; + if (!occupant) + { + XMPPJID *jid = [XMPPJID jidWithString:jidStr]; + occupant = [XMPPRoomOccupant occupantWithJID:jid nick:aNickName role:role]; + + [occupants setObject:occupant forKey:aNickName]; + [self onDidChangeOccupants]; + } + } + } +} + +- (void)xmppStream:(XMPPStream *)sender didReceiveMessage:(XMPPMessage *)message +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + // Check if its group chat, and make sure it's for this Room + if ([message isGroupChatMessageWithBody]) + { + NSArray *components = [[message fromStr] componentsSeparatedByString:@"/"]; + + NSString *aRoomName = [components count] > 0 ? [components objectAtIndex:0] : nil; + NSString *aNickName = [components count] > 1 ? [components objectAtIndex:1] : nil; + + if (![aRoomName isEqualToString:roomName]) return; + + if (aNickName == nil) + { + // Todo - A proper implementation... + + // NSString *body = [[message elementForName:@"body"] stringValue]; + // + // if ([body isEqualToString:@"This room is locked from entry until configuration is confirmed."]) + // { + // [self sendInstantRoomConfig]; + // return; + // } + // + // if ([body isEqualToString:@"This room is now unlocked."]) + // { + // [multicastDelegate xmppRoomDidCreate:self]; + // return; + // } + } + + [multicastDelegate xmppRoom:self didReceiveMessage:message fromNick:aNickName]; + } +} + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.h b/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.h new file mode 100644 index 0000000..3656c61 --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.h @@ -0,0 +1,25 @@ +// +// XMPPRoomOccupant +// A chat room. XEP-0045 Implementation. +// + +#import + +@class XMPPJID; + +@interface XMPPRoomOccupant : NSObject +{ + XMPPJID *jid; + NSString *nick; + NSString *role; +} + ++ (XMPPRoomOccupant *)occupantWithJID:(XMPPJID *)aJid nick:(NSString *)aNick role:(NSString *)aRole; + +- (id)initWithJID:(XMPPJID *)aJid nick:(NSString *)aNick role:(NSString *)aRole; + +@property (readonly) XMPPJID *jid; +@property (readonly) NSString *nick; +@property (readonly) NSString *role; + +@end diff --git a/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.m b/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.m new file mode 100644 index 0000000..c3bf83c --- /dev/null +++ b/xmpp/Extensions/XEP-0045/XMPPRoomOccupant.m @@ -0,0 +1,58 @@ +// +// XMPPRoomOccupant +// A chat room. XEP-0045 Implementation. +// + +#import "XMPPRoomOccupant.h" + + +@implementation XMPPRoomOccupant + ++ (XMPPRoomOccupant *)occupantWithJID:(XMPPJID *)aJid nick:(NSString *)aNick role:(NSString *)aRole +{ + return [[[XMPPRoomOccupant alloc] initWithJID:aJid nick:aNick role:aRole] autorelease]; +} + +@dynamic jid; +@dynamic role; +@dynamic nick; + +- (id)initWithJID:(XMPPJID *)aJid nick:(NSString *)aNick role:(NSString *)aRole +{ + if ((self = [super init])) + { + jid = [aJid copy]; + nick = [aNick copy]; + role = [aRole copy]; + } + return self; +} + +- (void)dealloc +{ + [jid release]; + [nick release]; + [role release]; + [super dealloc]; +} + +// Why are these here? +// Why not just let @synthesize do it for us? +// +// Since these variables are readonly, their getters should act like nonatomic getters. +// However, using the label nonatomic on their property definitions is misleading, +// and might cause some to assume this class isn't thread-safe when, in fact, it is. + +- (XMPPJID *)jid { + return jid; +} + +- (NSString *)nick { + return nick; +} + +- (NSString *)role { + return role; +} + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/.xccurrentversion b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/.xccurrentversion new file mode 100644 index 0000000..f9bae00 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/.xccurrentversion @@ -0,0 +1,8 @@ + + + + + _XCCurrentVersionName + XMPPvCard.xcdatamodel + + diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/elements b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/elements new file mode 100644 index 0000000000000000000000000000000000000000..ff516d13606774de5ea9b9e18329bf2ae705fb55 GIT binary patch literal 36011 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 z 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 literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/layout b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCard.xcdatamodeld/XMPPvCard.xcdatamodel/layout new file mode 100644 index 0000000000000000000000000000000000000000..14125f8425e589d8b022ac5dd8a87514e5071365 GIT binary patch literal 10268 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 literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.h b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.h new file mode 100644 index 0000000..21f40c1 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.h @@ -0,0 +1,20 @@ +// +// XMPPvCardAvatarCoreDataStorageObject.h +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// +// This class is so that we don't load the photoData each time we need to touch the XMPPvCardCoreDataStorageObject. + +#import +#import + +@class XMPPvCardCoreDataStorageObject; + + +@interface XMPPvCardAvatarCoreDataStorageObject : NSManagedObject + +@property (nonatomic, retain) NSData * photoData; +@property (nonatomic, retain) XMPPvCardCoreDataStorageObject * vCard; + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.m b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.m new file mode 100644 index 0000000..b2bf002 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardAvatarCoreDataStorageObject.m @@ -0,0 +1,17 @@ +// +// XMPPvCardAvatarCoreDataStorageObject.m +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import "XMPPvCardAvatarCoreDataStorageObject.h" +#import "XMPPvCardCoreDataStorageObject.h" + + +@implementation XMPPvCardAvatarCoreDataStorageObject + +@dynamic photoData; +@dynamic vCard; + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.h b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.h new file mode 100644 index 0000000..3b9303c --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.h @@ -0,0 +1,47 @@ +// +// XMPPvCardCoreDataStorage.h +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import +#import + +#import "XMPPCoreDataStorage.h" +#import "XMPPvCardTempModule.h" +#import "XMPPvCardAvatarModule.h" + +/** + * This class is an example implementation of XMPPCapabilitiesStorage using core data. + * You are free to substitute your own storage class. + **/ + +@interface XMPPvCardCoreDataStorage : XMPPCoreDataStorage < +XMPPvCardAvatarStorage, +XMPPvCardTempModuleStorage +> { + // Inherits protected variables from XMPPCoreDataStorage +} + +/** + * XEP-0054 provides a mechanism for transmitting vCards via XMPP. + * Because the JID doesn't change very often and can be large with image data, + * it is safe to persistently store the JID and wait for a user to explicity ask for an update, + * or use XEP-0153 to monitor for JID changes. + * + * For this reason, it is recommended you use this sharedInstance across all your xmppStreams. + * This way all streams can shared a knowledgebase concerning known JIDs and Avatar photos. + * + * All other aspects of vCard handling (such as lookup failures, etc) are kept separate between streams. +**/ ++ (XMPPvCardCoreDataStorage *)sharedInstance; + +// +// This class inherits from XMPPCoreDataStorage. +// +// Please see the XMPPCoreDataStorage header file for more information. +// + + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.m b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.m new file mode 100644 index 0000000..7f1bfb6 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorage.m @@ -0,0 +1,235 @@ +// +// XMPPvCardCoreDataStorage.m +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import "XMPPvCardCoreDataStorage.h" +#import "XMPPvCardCoreDataStorageObject.h" +#import "XMPPvCardTempCoreDataStorageObject.h" +#import "XMPPvCardAvatarCoreDataStorageObject.h" +#import "XMPP.h" +#import "XMPPCoreDataStorageProtected.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +enum { + kXMPPvCardTempNetworkFetchTimeout = 10, +}; + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPvCardCoreDataStorage + +static XMPPvCardCoreDataStorage *sharedInstance; + ++ (XMPPvCardCoreDataStorage *)sharedInstance +{ + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + + sharedInstance = [[XMPPvCardCoreDataStorage alloc] initWithDatabaseFilename:nil]; + }); + + return sharedInstance; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Setup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)configureWithParent:(XMPPvCardTempModule *)aParent queue:(dispatch_queue_t)queue +{ + return [super configureWithParent:aParent queue:queue]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Overrides +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)addPersistentStorePath:(NSString *)storePath error:(NSError **)error +{ + BOOL result = [super addPersistentStorePath:storePath error:error]; + + if (!result && + [*error code] == NSMigrationMissingSourceModelError && + [[*error domain] isEqualToString:NSCocoaErrorDomain]) { + // If we get this error while trying to add the persistent store, it most likely means the model changed. + // Since we are caching capabilities, it is safe to delete the persistent store and create a new one. + + if ([[NSFileManager defaultManager] fileExistsAtPath:storePath]) + { + [[NSFileManager defaultManager] removeItemAtPath:storePath error:nil]; + + // Try creating the store again, without creating a deletion/creation loop. + result = [super addPersistentStorePath:storePath error:error]; + } + } + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPvCardAvatarStorage protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSData *)photoDataForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block NSData *result; + + [self executeBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + result = [vCard.photoData retain]; + }]; + + return [result autorelease]; +} + +- (NSString *)photoHashForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block NSString *result; + + [self executeBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + result = [vCard.photoHash retain]; + }]; + + return [result autorelease]; +} + +- (void)clearvCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + vCard.vCardTemp = nil; + vCard.lastUpdated = [NSDate date]; + }]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPvCardTempModuleStorage protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (XMPPvCardTemp *)vCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block XMPPvCardTemp *result; + + [self executeBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + result = [vCard.vCardTemp retain]; + }]; + + return [result autorelease]; +} + +- (void)setvCardTemp:(XMPPvCardTemp *)vCardTemp forJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + vCard.waitingForFetch = [NSNumber numberWithBool:NO]; + vCard.vCardTemp = vCardTemp; + + // Update photo and photo hash + vCard.photoData = vCardTemp.photo; + + vCard.lastUpdated = [NSDate date]; + }]; +} + +- (BOOL)shouldFetchvCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // This is a public method. + // It may be invoked on any thread/queue. + + XMPPLogTrace(); + + __block BOOL result; + + [self executeBlock:^{ + + XMPPvCardCoreDataStorageObject *vCard; + vCard = [XMPPvCardCoreDataStorageObject fetchOrInsertvCardForJID:jid + inManagedObjectContext:[self managedObjectContext]]; + + BOOL waitingForFetch = [vCard.waitingForFetch boolValue]; + + if (!waitingForFetch) + { + vCard.waitingForFetch = [NSNumber numberWithBool:YES]; + vCard.lastUpdated = [NSDate date]; + + result = YES; + } + else if ([vCard.lastUpdated timeIntervalSinceNow] < -kXMPPvCardTempNetworkFetchTimeout) + { + // Our last request exceeded the timeout, send a new one + vCard.lastUpdated = [NSDate date]; + + result = YES; + } + else + { + // We already have an outstanding request, no need to send another one. + result = NO; + } + }]; + + return result; +} + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.h b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.h new file mode 100644 index 0000000..7a34915 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.h @@ -0,0 +1,73 @@ +// +// XMPPvCardCoreDataStorageObject.h +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import +#import + + +@class XMPPJID; +@class XMPPvCardTemp; +@class XMPPvCardTempCoreDataStorageObject; +@class XMPPvCardAvatarCoreDataStorageObject; + + +@interface XMPPvCardCoreDataStorageObject : NSManagedObject + + +/* + * User's JID, indexed for lookups + */ +@property (nonatomic, retain) NSString * jidStr; + +/* + * User's photoHash used by XEP-0153 + */ +@property (nonatomic, retain, readonly) NSString * photoHash; + +/* + * The last time the record was modified, also used to determine if we need to fetch again + */ +@property (nonatomic, retain) NSDate * lastUpdated; + + +/* + * Flag indicating whether a get request is already pending, used in conjunction with lastUpdated + */ +@property (nonatomic, retain) NSNumber * waitingForFetch; + + +/* + * Relationship to the vCardTemp record. + * We use a relationship, so the vCardTemp stays faulted until we really need it. + */ +@property (nonatomic, retain) XMPPvCardTempCoreDataStorageObject * vCardTempRel; + + +/* + * Relationship to the vCardAvatar record. + * We use a relationship, so the vCardAvatar stays faulted until we really need it. + */ +@property (nonatomic, retain) XMPPvCardAvatarCoreDataStorageObject * vCardAvatarRel; + + +/* + * Accessor to retrieve photoData, so we can hide the underlying relationship implementation. + */ +@property (nonatomic, retain) NSData *photoData; + + +/* + * Accessor to retrieve vCardTemp, so we can hide the underlying relationship implementation. + */ +@property (nonatomic, retain) XMPPvCardTemp *vCardTemp; + + ++ (XMPPvCardCoreDataStorageObject *)fetchOrInsertvCardForJID:(XMPPJID *)jid + inManagedObjectContext:(NSManagedObjectContext *)moc; + + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.m b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.m new file mode 100644 index 0000000..700359b --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardCoreDataStorageObject.m @@ -0,0 +1,177 @@ +// +// XMPPvCardCoreDataStorageObject.m +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import "XMPPvCardCoreDataStorageObject.h" +#import "XMPPvCardTempCoreDataStorageObject.h" +#import "XMPPvCardAvatarCoreDataStorageObject.h" + +#import "XMPPJID.h" +#import "XMPPStream.h" +#import "NSNumber+XMPP.h" +#import "NSData+XMPP.h" + + +@implementation XMPPvCardCoreDataStorageObject + ++ (XMPPvCardCoreDataStorageObject *)fetchvCardForJID:(XMPPJID *)jid + inManagedObjectContext:(NSManagedObjectContext *)moc +{ + NSString *entityName = NSStringFromClass([XMPPvCardCoreDataStorageObject class]); + + NSEntityDescription *entity = [NSEntityDescription entityForName:entityName + inManagedObjectContext:moc]; + + NSPredicate *predicate = [NSPredicate predicateWithFormat:@"jidStr == %@", [jid bare]]; + + NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setIncludesPendingChanges:YES]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [moc executeFetchRequest:fetchRequest error:nil]; + + [fetchRequest release]; + + return (XMPPvCardCoreDataStorageObject *)[results lastObject]; +} + + ++ (XMPPvCardCoreDataStorageObject *)insertEmptyvCardForJID:(XMPPJID *)jid + inManagedObjectContext:(NSManagedObjectContext *)moc +{ + NSString *entityName = NSStringFromClass([XMPPvCardCoreDataStorageObject class]); + + XMPPvCardCoreDataStorageObject *vCard = [NSEntityDescription insertNewObjectForEntityForName:entityName + inManagedObjectContext:moc]; + + vCard.jidStr = [jid bare]; + return vCard; +} + ++ (XMPPvCardCoreDataStorageObject *)fetchOrInsertvCardForJID:(XMPPJID *)jid + inManagedObjectContext:(NSManagedObjectContext *)moc +{ + XMPPvCardCoreDataStorageObject *vCard = [self fetchvCardForJID:jid inManagedObjectContext:moc]; + if (vCard == nil) + { + vCard = [self insertEmptyvCardForJID:jid inManagedObjectContext:moc]; + } + + return vCard; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark NSManagedObject methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)awakeFromInsert +{ + [super awakeFromInsert]; + [self setPrimitiveValue:[NSDate date] forKey:@"lastUpdated"]; +} + + +- (void)willSave +{ + /* + if (![self isDeleted] && [self isUpdated]) { + [self setPrimitiveValue:[NSDate date] forKey:@"lastUpdated"]; + } + */ + + [super willSave]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Getter/setter methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@dynamic jidStr; +@dynamic photoHash; +@dynamic lastUpdated; +@dynamic waitingForFetch; +@dynamic vCardTempRel; +@dynamic vCardAvatarRel; + + +- (NSData *)photoData { + return self.vCardAvatarRel.photoData; +} + + +- (void)setPhotoData:(NSData *)photoData +{ + if (photoData == nil) + { + if (self.vCardAvatarRel != nil) + { + [[self managedObjectContext] deleteObject:self.vCardAvatarRel]; + [self setPrimitiveValue:nil forKey:@"photoHash"]; + } + + return; + } + + if (self.vCardAvatarRel == nil) + { + NSString *entityName = NSStringFromClass([XMPPvCardAvatarCoreDataStorageObject class]); + + self.vCardAvatarRel = [NSEntityDescription insertNewObjectForEntityForName:entityName + inManagedObjectContext:[self managedObjectContext]]; + } + + [self willChangeValueForKey:@"photoData"]; + self.vCardAvatarRel.photoData = photoData; + [self didChangeValueForKey:@"photoData"]; + + [self setPrimitiveValue:[[photoData sha1Digest] hexStringValue] forKey:@"photoHash"]; +} + + +- (XMPPvCardTemp *)vCardTemp { + return self.vCardTempRel.vCardTemp; +} + + +- (void)setVCardTemp:(XMPPvCardTemp *)vCardTemp +{ + if (vCardTemp == nil && self.vCardTempRel != nil) + { + [[self managedObjectContext] deleteObject:self.vCardTempRel]; + + return; + } + + if (self.vCardTempRel == nil) + { + NSString *entityName = NSStringFromClass([XMPPvCardTempCoreDataStorageObject class]); + + self.vCardTempRel = [NSEntityDescription insertNewObjectForEntityForName:entityName + inManagedObjectContext:[self managedObjectContext]]; + } + + [self willChangeValueForKey:@"vCardTemp"]; + self.vCardTempRel.vCardTemp = vCardTemp; + [self didChangeValueForKey:@"vCardTemp"]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark KVO methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSSet *)keyPathsForValuesAffectingPhotoHash +{ + return [NSSet setWithObjects:@"vCardAvatarRel", @"photoData", nil]; +} + ++ (NSSet *)keyPathsForValuesAffectingVCardTemp +{ + return [NSSet setWithObject:@"vCardTempRel"]; +} + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.h b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.h new file mode 100644 index 0000000..d08bf5f --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.h @@ -0,0 +1,23 @@ +// +// XMPPvCardTempCoreDataStorageObject.h +// XEP-0054 vCard-temp +// +// Oringally created by Eric Chamberlain on 3/18/11. +// +// This class is so that we don't load the vCardTemp each time we need to touch the XMPPvCardCoreDataStorageObject. +// The vCardTemp abstraction also makes it easier to eventually add support for vCard4 over XMPP (XEP-0292). + +#import +#import + +#import "XMPPvcardTemp.h" + +@class XMPPvCardCoreDataStorageObject; + + +@interface XMPPvCardTempCoreDataStorageObject : NSManagedObject + +@property (nonatomic, retain) XMPPvCardTemp * vCardTemp; +@property (nonatomic, retain) XMPPvCardCoreDataStorageObject * vCard; + +@end diff --git a/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.m b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.m new file mode 100644 index 0000000..7d9fe85 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/CoreDataStorage/XMPPvCardTempCoreDataStorageObject.m @@ -0,0 +1,17 @@ +// +// XMPPvCardTempCoreDataStorageObject.m +// XEP-0054 vCard-temp +// +// Originally created by Eric Chamberlain on 3/18/11. +// + +#import "XMPPvCardTempCoreDataStorageObject.h" +#import "XMPPvCardCoreDataStorageObject.h" + + +@implementation XMPPvCardTempCoreDataStorageObject + +@dynamic vCardTemp; +@dynamic vCard; + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTemp.h b/xmpp/Extensions/XEP-0054/XMPPvCardTemp.h new file mode 100644 index 0000000..d657aec --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTemp.h @@ -0,0 +1,120 @@ +// +// XMPPvCardTemp.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import +#import + +#import "XMPPIQ.h" +#import "XMPPJID.h" +#import "XMPPUser.h" +#import "XMPPvCardTempAdr.h" +#import "XMPPvCardTempBase.h" +#import "XMPPvCardTempEmail.h" +#import "XMPPvCardTempLabel.h" +#import "XMPPvCardTempTel.h" + + +typedef enum _XMPPvCardTempClass { + XMPPvCardTempClassNone, + XMPPvCardTempClassPublic, + XMPPvCardTempClassPrivate, + XMPPvCardTempClassConfidential, +} XMPPvCardTempClass; + + +extern NSString *const kXMPPNSvCardTemp; +extern NSString *const kXMPPvCardTempElement; + + +/* + * Note: according to the DTD, every fields bar N and FN can appear multiple times. + * The provided accessors only support this for the field types where multiple + * entries make sense - for the others, if required, the NSXMLElement accessors + * must be used. + */ +@interface XMPPvCardTemp : XMPPvCardTempBase + + +@property (nonatomic, assign) NSDate *bday; +@property (nonatomic, assign) NSData *photo; +@property (nonatomic, assign) NSString *nickname; +@property (nonatomic, assign) NSString *formattedName; +@property (nonatomic, assign) NSString *familyName; +@property (nonatomic, assign) NSString *givenName; +@property (nonatomic, assign) NSString *middleName; +@property (nonatomic, assign) NSString *prefix; +@property (nonatomic, assign) NSString *suffix; + +@property (nonatomic, assign) NSArray *addresses; +@property (nonatomic, assign) NSArray *labels; +@property (nonatomic, assign) NSArray *telecomsAddresses; +@property (nonatomic, assign) NSArray *emailAddresses; + +@property (nonatomic, assign) XMPPJID *jid; +@property (nonatomic, assign) NSString *mailer; + +@property (nonatomic, assign) NSTimeZone *timeZone; +@property (nonatomic, assign) CLLocation *location; + +@property (nonatomic, assign) NSString *title; +@property (nonatomic, assign) NSString *role; +@property (nonatomic, assign) NSData *logo; +@property (nonatomic, assign) XMPPvCardTemp *agent; +@property (nonatomic, assign) NSString *orgName; + +/* + * ORGUNITs can only be set if there is already an ORGNAME. Otherwise, changes are ignored. + */ +@property (nonatomic, assign) NSArray *orgUnits; + +@property (nonatomic, assign) NSArray *categories; +@property (nonatomic, assign) NSString *note; +@property (nonatomic, assign) NSString *prodid; +@property (nonatomic, assign) NSDate *revision; +@property (nonatomic, assign) NSString *sortString; +@property (nonatomic, assign) NSString *phoneticSound; +@property (nonatomic, assign) NSData *sound; +@property (nonatomic, assign) NSString *uid; +@property (nonatomic, assign) NSString *url; +@property (nonatomic, assign) NSString *version; +@property (nonatomic, assign) NSString *description; + +@property (nonatomic, assign) XMPPvCardTempClass privacyClass; +@property (nonatomic, assign) NSData *key; +@property (nonatomic, assign) NSString *keyType; + + ++ (XMPPvCardTemp *)vCardTempFromElement:(NSXMLElement *)element; ++ (XMPPvCardTemp *)vCardTempSubElementFromIQ:(XMPPIQ *)iq; ++ (XMPPvCardTemp *)vCardTempCopyFromIQ:(XMPPIQ *)iq; ++ (XMPPIQ *)iqvCardRequestForJID:(XMPPJID *)jid; + + +- (void)addAddress:(XMPPvCardTempAdr *)adr; +- (void)removeAddress:(XMPPvCardTempAdr *)adr; +- (void)clearAddresses; + + +- (void)addLabel:(XMPPvCardTempLabel *)label; +- (void)removeLabel:(XMPPvCardTempLabel *)label; +- (void)clearLabels; + + +- (void)addTelecomsAddress:(XMPPvCardTempTel *)tel; +- (void)removeTelecomsAddress:(XMPPvCardTempTel *)tel; +- (void)clearTelecomsAddresses; + + +- (void)addEmailAddress:(XMPPvCardTempEmail *)email; +- (void)removeEmailAddress:(XMPPvCardTempEmail *)email; +- (void)clearEmailAddresses; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTemp.m b/xmpp/Extensions/XEP-0054/XMPPvCardTemp.m new file mode 100644 index 0000000..2e385b4 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTemp.m @@ -0,0 +1,932 @@ +// +// XMPPvCardTemp.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTemp.h" + +#import + +#import "XMPPLogging.h" +#import "NSData+XMPP.h" +#import "XMPPDateTimeProfiles.h" + +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#endif + +NSString *const kXMPPNSvCardTemp = @"vcard-temp"; +NSString *const kXMPPvCardTempElement = @"vCard"; + + +@implementation XMPPvCardTemp + + ++ (void)initialize { + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPvCardTemp class]); + + if (superSize != ourSize) + { + XMPPLogError(@"Adding instance variables to XMPPvCardTemp is not currently supported!"); + + [DDLog flushLog]; + exit(15); + } +} + + ++ (XMPPvCardTemp *)vCardTempFromElement:(NSXMLElement *)elem { + object_setClass(elem, [XMPPvCardTemp class]); + + return (XMPPvCardTemp *)elem; +} + + ++ (XMPPvCardTemp *)vCardTempSubElementFromIQ:(XMPPIQ *)iq +{ + if ([iq isResultIQ]) + { + NSXMLElement *query = [iq elementForName:kXMPPvCardTempElement xmlns:kXMPPNSvCardTemp]; + if (query) + { + return [self vCardTempFromElement:query]; + } + } + + return nil; +} + ++ (XMPPvCardTemp *)vCardTempCopyFromIQ:(XMPPIQ *)iq +{ + // This doesn't work. + // It looks like the copy that comes back is of class DDXMLElement. + // So maybe the vCardTemp class has to implement its own copy method... + // + //return [[[self vCardTempSubElementFromIQ:iq] copy] autorelease]; + + if ([iq isResultIQ]) + { + NSXMLElement *query = [iq elementForName:kXMPPvCardTempElement xmlns:kXMPPNSvCardTemp]; + if (query) + { + NSXMLElement *queryCopy = [[query copy] autorelease]; + + return [self vCardTempFromElement:queryCopy]; + } + } + + return nil; +} + + ++ (XMPPIQ *)iqvCardRequestForJID:(XMPPJID *)jid { + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:[jid bareJID]]; + NSXMLElement *vCardElem = [NSXMLElement elementWithName:kXMPPvCardTempElement xmlns:kXMPPNSvCardTemp]; + + [iq addChild:vCardElem]; + return iq; +} + + +#pragma mark - +#pragma mark Identification Types + + +- (NSDate *)bday { + NSDate *bday = nil; + NSXMLElement *elem = [self elementForName:@"BDAY"]; + + if (elem != nil) { + bday = [NSDate dateWithXmppDateString:[elem stringValue]]; + } + + return bday; +} + + +- (void)setBday:(NSDate *)bday { + NSXMLElement *elem = [self elementForName:@"BDAY"]; + + if (elem == nil) { + elem = [NSXMLElement elementWithName:@"BDAY"]; + [self addChild:elem]; + } + + [elem setStringValue:[bday xmppDateString]]; +} + + +- (NSData *)photo { + NSData *decodedData = nil; + NSXMLElement *photo = [self elementForName:@"PHOTO"]; + + if (photo != nil) { + // There is a PHOTO element. It should have a TYPE and a BINVAL + //NSXMLElement *fileType = [photo elementForName:@"TYPE"]; + NSXMLElement *binval = [photo elementForName:@"BINVAL"]; + + if (binval) { + NSData *base64Data = [[binval stringValue] dataUsingEncoding:NSASCIIStringEncoding]; + decodedData = [base64Data base64Decoded]; + } + } + + return decodedData; +} + + +- (void)setPhoto:(NSData *)data { + NSXMLElement *photo = [self elementForName:@"PHOTO"]; + + if (photo == nil) { + photo = [NSXMLElement elementWithName:@"PHOTO"]; + [self addChild:photo]; + } + + NSXMLElement *binval = [photo elementForName:@"BINVAL"]; + + if (binval == nil) { + binval = [NSXMLElement elementWithName:@"BINVAL"]; + [photo addChild:binval]; + } + + [binval setStringValue:[data base64Encoded]]; +} + + +- (NSString *)nickname { + return [[self elementForName:@"NICKNAME"] stringValue]; +} + + +- (void)setNickname:(NSString *)nick { + XMPP_VCARD_SET_STRING_CHILD(nick, @"NICKNAME"); +} + + +- (NSString *)formattedName { + return [[self elementForName:@"FN"] stringValue]; +} + + +- (void)setFormattedName:(NSString *)fn { + XMPP_VCARD_SET_STRING_CHILD(fn, @"FN"); +} + + +- (NSString *)familyName { + NSString *result = nil; + NSXMLElement *name = [self elementForName:@"N"]; + + if (name != nil) { + NSXMLElement *part = [name elementForName:@"FAMILY"]; + + if (part != nil) { + result = [part stringValue]; + } + } + + return result; +} + + +- (void)setFamilyName:(NSString *)family { + XMPP_VCARD_SET_N_CHILD(family, @"FAMILY"); +} + + +- (NSString *)givenName { + NSString *result = nil; + NSXMLElement *name = [self elementForName:@"N"]; + + if (name != nil) { + NSXMLElement *part = [name elementForName:@"GIVEN"]; + + if (part != nil) { + result = [part stringValue]; + } + } + + return result; +} + + +- (void)setGivenName:(NSString *)given { + XMPP_VCARD_SET_N_CHILD(given, @"GIVEN"); +} + + +- (NSString *)middleName { + NSString *result = nil; + NSXMLElement *name = [self elementForName:@"N"]; + + if (name != nil) { + NSXMLElement *part = [name elementForName:@"MIDDLE"]; + + if (part != nil) { + result = [part stringValue]; + } + } + + return result; +} + + +- (void)setMiddleName:(NSString *)middle { + XMPP_VCARD_SET_N_CHILD(middle, @"MIDDLE"); +} + + +- (NSString *)prefix { + NSString *result = nil; + NSXMLElement *name = [self elementForName:@"N"]; + + if (name != nil) { + NSXMLElement *part = [name elementForName:@"PREFIX"]; + + if (part != nil) { + result = [part stringValue]; + } + } + + return result; +} + + +- (void)setPrefix:(NSString *)prefix { + XMPP_VCARD_SET_N_CHILD(prefix, @"PREFIX"); +} + + +- (NSString *)suffix { + NSString *result = nil; + NSXMLElement *name = [self elementForName:@"N"]; + + if (name != nil) { + NSXMLElement *part = [name elementForName:@"SUFFIC"]; + + if (part != nil) { + result = [part stringValue]; + } + } + + return result; +} + + +- (void)setSuffix:(NSString *)suffix { + XMPP_VCARD_SET_N_CHILD(suffix, @"SUFFIX"); +} + + +#pragma mark Delivery Addressing Types + + +- (NSArray *)addresses { return nil; } +- (void)addAddress:(XMPPvCardTempAdr *)adr { } +- (void)removeAddress:(XMPPvCardTempAdr *)adr { } +- (void)setAddresses:(NSArray *)adrs { } +- (void)clearAddresses { } + + +- (NSArray *)labels { return nil; } +- (void)addLabel:(XMPPvCardTempLabel *)label { } +- (void)removeLabel:(XMPPvCardTempLabel *)label { } +- (void)setLabels:(NSArray *)labels { } +- (void)clearLabels { } + + +- (NSArray *)telecomsAddresses { return nil; } +- (void)addTelecomsAddress:(XMPPvCardTempTel *)tel { } +- (void)removeTelecomsAddress:(XMPPvCardTempTel *)tel { } +- (void)setTelecomsAddresses:(NSArray *)tels { } +- (void)clearTelecomsAddresses { } + + +- (NSArray *)emailAddresses { return nil; } +- (void)addEmailAddress:(XMPPvCardTempEmail *)email { } +- (void)removeEmailAddress:(XMPPvCardTempEmail *)email { } +- (void)setEmailAddresses:(NSArray *)emails { } +- (void)clearEmailAddresses { } + + +- (XMPPJID *)jid { + XMPPJID *jid = nil; + NSXMLElement *elem = [self elementForName:@"JABBERID"]; + + if (elem != nil) { + jid = [XMPPJID jidWithString:[elem stringValue]]; + } + + return jid; +} + + +- (void)setJid:(XMPPJID *)jid { + NSXMLElement *elem = [self elementForName:@"JABBERID"]; + + if (elem == nil && jid != nil) { + elem = [NSXMLElement elementWithName:@"JABBERID"]; + [self addChild:elem]; + } + + if (jid != nil) { + [elem setStringValue:[jid full]]; + } else if (elem != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + } +} + + +- (NSString *)mailer { + return [[self elementForName:@"MAILER"] stringValue]; +} + + +- (void)setMailer:(NSString *)mailer { + XMPP_VCARD_SET_STRING_CHILD(mailer, @"MAILER"); +} + + +#pragma mark Geographical Types + + +- (NSTimeZone *)timeZone { + // Turns out this is hard. Being lazy for now (not like anyone actually uses this, right?) + NSXMLElement *tz = [self elementForName:@"TZ"]; + if (tz != nil) { + // This is unlikely to work. :-( + return [NSTimeZone timeZoneWithName:[tz stringValue]]; + } else { + return nil; + } +} + + +- (void)setTimeZone:(NSTimeZone *)tz { + NSXMLElement *elem = [self elementForName:@"TZ"]; + + if (elem == nil && tz != nil) { + elem = [NSXMLElement elementWithName:@"TZ"]; + [self addChild:elem]; + } + + if (tz != nil) { + NSInteger offset = [tz secondsFromGMT]; + [elem setStringValue:[NSString stringWithFormat:@"%02d:%02d", offset / 3600, (offset % 3600) / 60]]; + } else if (elem != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + } +} + + +- (CLLocation *)location { + CLLocation *loc = nil; + NSXMLElement *geo = [self elementForName:@"GEO"]; + + if (geo != nil) { + NSXMLElement *lat = [geo elementForName:@"LAT"]; + NSXMLElement *lon = [geo elementForName:@"LON"]; + + loc = [[[CLLocation alloc] initWithLatitude:[[lat stringValue] doubleValue] longitude:[[lon stringValue] doubleValue]] autorelease]; + } + + return loc; +} + + +- (void)setLocation:(CLLocation *)geo { + NSXMLElement *elem = [self elementForName:@"GEO"]; + NSXMLElement *lat; + NSXMLElement *lon; + + if (geo != nil) { + CLLocationCoordinate2D coord = [geo coordinate]; + if (elem == nil) { + elem = [NSXMLElement elementWithName:@"GEO"]; + [self addChild:elem]; + + lat = [NSXMLElement elementWithName:@"LAT"]; + [elem addChild:lat]; + lon = [NSXMLElement elementWithName:@"LON"]; + [elem addChild:lon]; + } else { + lat = [elem elementForName:@"LAT"]; + lon = [elem elementForName:@"LON"]; + } + + [lat setStringValue:[NSString stringWithFormat:@"%.6f", coord.latitude]]; + [lon setStringValue:[NSString stringWithFormat:@"%.6f", coord.longitude]]; + } else if (elem != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + } +} + + +#pragma mark Organizational Types + + +- (NSString *)title { + return [[self elementForName:@"TITLE"] stringValue]; +} + + +- (void)setTitle:(NSString *)title { + XMPP_VCARD_SET_STRING_CHILD(title, @"TITLE"); +} + + +- (NSString *)role { + return [[self elementForName:@"ROLE"] stringValue]; +} + + +- (void)setRole:(NSString *)role { + XMPP_VCARD_SET_STRING_CHILD(role, @"ROLE"); +} + + +- (NSData *)logo { + NSData *decodedData = nil; + NSXMLElement *logo = [self elementForName:@"LOGO"]; + + if (logo != nil) { + // There is a LOGO element. It should have a TYPE and a BINVAL + //NSXMLElement *fileType = [photo elementForName:@"TYPE"]; + NSXMLElement *binval = [logo elementForName:@"BINVAL"]; + + if (binval) { + NSData *base64Data = [[binval stringValue] dataUsingEncoding:NSASCIIStringEncoding]; + decodedData = [base64Data base64Decoded]; + } + } + + return decodedData; +} + + +- (void)setLogo:(NSData *)data { + NSXMLElement *logo = [self elementForName:@"LOGO"]; + + if (logo == nil) { + logo = [NSXMLElement elementWithName:@"LOGO"]; + [self addChild:logo]; + } + + NSXMLElement *binval = [logo elementForName:@"BINVAL"]; + + if (binval == nil) { + binval = [NSXMLElement elementWithName:@"BINVAL"]; + [logo addChild:binval]; + } + + [binval setStringValue:[data base64Encoded]]; +} + + +- (XMPPvCardTemp *)agent { + XMPPvCardTemp *agent = nil; + NSXMLElement *elem = [self elementForName:@"AGENT"]; + + if (elem != nil) { + agent = [XMPPvCardTemp vCardTempFromElement:elem]; + } + + return agent; +} + + +- (void)setAgent:(XMPPvCardTemp *)agent { + NSXMLElement *elem = [self elementForName:@"AGENT"]; + + if (elem != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + } + + if (agent != nil) { + [self addChild:agent]; + } +} + + +- (NSString *)orgName { + NSString *result = nil; + NSXMLElement *org = [self elementForName:@"ORG"]; + + if (org != nil) { + NSXMLElement *orgname = [org elementForName:@"ORGNAME"]; + + if (orgname != nil) { + result = [orgname stringValue]; + } + } + + return result; +} + + +- (void)setOrgName:(NSString *)orgname { + NSXMLElement *org = [self elementForName:@"ORG"]; + NSXMLElement *elem = nil; + + if (orgname != nil) { + if (org == nil) { + org = [NSXMLElement elementWithName:@"ORG"]; + [self addChild:org]; + } else { + elem = [org elementForName:@"ORGNAME"]; + } + + if (elem == nil) { + elem = [NSXMLElement elementWithName:@"ORGNAME"]; + [org addChild:elem]; + } + + [elem setStringValue:orgname]; + } else if (org != nil) { + // This implicitly removes all orgunits too, as per the spec + [self removeChildAtIndex:[[self children] indexOfObject:org]]; + } +} + + +- (NSArray *)orgUnits { + NSArray *result = nil; + NSXMLElement *org = [self elementForName:@"ORG"]; + + if (org != nil) { + NSArray *elems = [org elementsForName:@"ORGUNIT"]; + NSMutableArray *arr = [[NSMutableArray alloc] initWithCapacity:[elems count]]; + + for (NSXMLElement *elem in elems) { + [arr addObject:[elem stringValue]]; + } + + result = [NSArray arrayWithArray:arr]; + [arr release]; + } + + return result; +} + + +- (void)setOrgUnits:(NSArray *)orgunits { + NSXMLElement *org = [self elementForName:@"ORG"]; + + // If there is no org, then there is nothing to do (need ORGNAME first) + if (org != nil) { + NSArray *elems = [org elementsForName:@"ORGUNIT"]; + for (NSXMLElement *elem in elems) { + [org removeChildAtIndex:[[org children] indexOfObject:elem]]; + } + + for (NSString *unit in orgunits) { + NSXMLElement *elem = [NSXMLElement elementWithName:@"ORGUNIT"]; + [elem setStringValue:unit]; + + [org addChild:elem]; + } + } +} + + +#pragma mark Explanatory Types + + +- (NSArray *)categories { + NSArray *result = nil; + NSXMLElement *categories = [self elementForName:@"CATEGORIES"]; + + if (categories != nil) { + NSArray *elems = [categories elementsForName:@"KEYWORD"]; + NSMutableArray *arr = [[NSMutableArray alloc] initWithCapacity:[elems count]]; + + for (NSXMLElement *elem in elems) { + [arr addObject:[elem stringValue]]; + } + + result = [NSArray arrayWithArray:arr]; + [arr release]; + } + + return result; +} + + +- (void)setCategories:(NSArray *)categories { + NSXMLElement *cat = [self elementForName:@"CATEGORIES"]; + + if (categories != nil) { + if (cat == nil) { + cat = [NSXMLElement elementWithName:@"CATEGORIES"]; + [self addChild:cat]; + } + + NSArray *elems = [cat elementsForName:@"KEYWORD"]; + for (NSXMLElement *elem in elems) { + [cat removeChildAtIndex:[[cat children] indexOfObject:elem]]; + } + + for (NSString *kw in categories) { + NSXMLElement *elem = [NSXMLElement elementWithName:@"KEYWORD"]; + [elem setStringValue:kw]; + + [cat addChild:elem]; + } + } else if (cat != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:cat]]; + } +} + + +- (NSString *)note { + return [[self elementForName:@"NOTE"] stringValue]; +} + + +- (void)setNote:(NSString *)note { + XMPP_VCARD_SET_STRING_CHILD(note, @"NOTE"); +} + + +- (NSString *)prodid { + return [[self elementForName:@"PRODID"] stringValue]; +} + + +- (void)setProdid:(NSString *)prodid { + XMPP_VCARD_SET_STRING_CHILD(prodid, @"PRODID"); +} + + +- (NSDate *)revision { + NSDate *rev = nil; + NSXMLElement *elem = [self elementForName:@"REV"]; + + if (elem != nil) { + rev = [NSDate dateWithXmppDateTimeString:[elem stringValue]]; + } + + return rev; +} + + +- (void)setRevision:(NSDate *)rev { + NSXMLElement *elem = [self elementForName:@"REV"]; + + if (elem == nil) { + elem = [NSXMLElement elementWithName:@"REV"]; + [self addChild:elem]; + } + + [elem setStringValue:[rev xmppDateTimeString]]; +} + + +- (NSString *)sortString { + return [[self elementForName:@"SORT-STRING"] stringValue]; +} +- (void)setSortString:(NSString *)sortString { + XMPP_VCARD_SET_STRING_CHILD(sortString, @"SORT-STRING"); +} + + +- (NSString *)phoneticSound { + NSString *phon = nil; + NSXMLElement *sound = [self elementForName:@"SOUND"]; + + if (sound != nil) { + NSXMLElement *elem = [sound elementForName:@"PHONETIC"]; + + if (elem != nil) { + phon = [elem stringValue]; + } + } + + return phon; +} + + +- (void)setPhoneticSound:(NSString *)phonetic { + NSXMLElement *sound = [self elementForName:@"SOUND"]; + NSXMLElement *elem; + + if (sound == nil && phonetic != nil) { + sound = [NSXMLElement elementWithName:@"SOUND"]; + [self addChild:sound]; + } + + if (sound != nil) { + elem = [sound elementForName:@"PHONETIC"]; + + if (elem != nil && phonetic != nil) { + elem = [NSXMLElement elementWithName:@"PHONETIC"]; + [sound addChild:elem]; + } + } + + if (phonetic != nil) { + [elem setStringValue:phonetic]; + } else if (sound != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:phonetic]]; + } +} + + +- (NSData *)sound { + NSData *decodedData = nil; + NSXMLElement *sound = [self elementForName:@"SOUND"]; + + if (sound != nil) { + NSXMLElement *binval = [sound elementForName:@"BINVAL"]; + + if (binval) { + NSData *base64Data = [[binval stringValue] dataUsingEncoding:NSASCIIStringEncoding]; + decodedData = [base64Data base64Decoded]; + } + } + + return decodedData; +} + + +- (void)setSound:(NSData *)data { + NSXMLElement *sound = [self elementForName:@"SOUND"]; + + if (sound == nil) { + sound = [NSXMLElement elementWithName:@"SOUND"]; + [self addChild:sound]; + } + + NSXMLElement *binval = [sound elementForName:@"BINVAL"]; + + if (binval == nil) { + binval = [NSXMLElement elementWithName:@"BINVAL"]; + [sound addChild:binval]; + } + + [binval setStringValue:[data base64Encoded]]; +} + + +- (NSString *)uid { + return [[self elementForName:@"UID"] stringValue]; +} + + +- (void)setUid:(NSString *)uid { + XMPP_VCARD_SET_STRING_CHILD(uid, @"UID"); +} + + +- (NSString *)url { + return [[self elementForName:@"URL"] stringValue]; +} + + +- (void)setUrl:(NSString *)url { + XMPP_VCARD_SET_STRING_CHILD(url, @"URL"); +} + + +- (NSString *)version { + return [self attributeStringValueForName:@"version"]; +} + + +- (void)setVersion:(NSString *)version { + [self addAttributeWithName:@"version" stringValue:version]; +} + + +- (NSString *)description { + return [[self elementForName:@"DESC"] stringValue]; +} + + +- (void)setDescription:(NSString *)desc { + XMPP_VCARD_SET_STRING_CHILD(desc, @"DESC"); +} + + +#pragma mark Security Types + + +- (XMPPvCardTempClass)privacyClass { + XMPPvCardTempClass priv = XMPPvCardTempClassNone; + NSXMLElement *elem = [self elementForName:@"CLASS"]; + + if (elem != nil) { + if ([elem elementForName:@"PUBLIC"] != nil) { + priv = XMPPvCardTempClassPublic; + } else if ([elem elementForName:@"PRIVATE"] != nil) { + priv = XMPPvCardTempClassPrivate; + } else if ([elem elementForName:@"CONFIDENTIAL"] != nil) { + priv = XMPPvCardTempClassConfidential; + } + } + + return priv; +} + + +- (void)setPrivacyClass:(XMPPvCardTempClass)privacyClass { + NSXMLElement *elem = [self elementForName:@"CLASS"]; + + if (elem == nil && privacyClass != XMPPvCardTempClassNone) { + elem = [NSXMLElement elementWithName:@"CLASS"]; + } + + if (elem != nil) { + for (NSString *cls in [NSArray arrayWithObjects:@"PUBLIC", @"PRIVATE", @"CONFIDENTIAL", nil]) { + NSXMLElement *priv = [elem elementForName:cls]; + if (priv != nil) { + [elem removeChildAtIndex:[[elem children] indexOfObject:priv]]; + } + } + + switch (privacyClass) { + case XMPPvCardTempClassPublic: + [elem addChild:[NSXMLElement elementWithName:@"PUBLIC"]]; + break; + case XMPPvCardTempClassPrivate: + [elem addChild:[NSXMLElement elementWithName:@"PRIVATE"]]; + break; + case XMPPvCardTempClassConfidential: + [elem addChild:[NSXMLElement elementWithName:@"CONFIDENTIAL"]]; + break; + default: + case XMPPvCardTempClassNone: + // Remove the whole element + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + break; + } + } +} + + +- (NSData *)key { return nil; } +- (void)setKey:(NSData *)key { } + + +- (NSString *)keyType { + NSString *typ = nil; + NSXMLElement *key = [self elementForName:@"KEY"]; + + if (key != nil) { + NSXMLElement *elem = [key elementForName:@"TYPE"]; + + if (elem != nil) { + typ = [elem stringValue]; + } + } + + return typ; +} + + +- (void)setKeyType:(NSString *)type { + NSXMLElement *key = [self elementForName:@"KEY"]; + NSXMLElement *elem; + + if (key == nil && type != nil) { + key = [NSXMLElement elementWithName:@"KEY"]; + [self addChild:key]; + } + + if (key != nil) { + elem = [key elementForName:@"TYPE"]; + + if (elem != nil && type != nil) { + elem = [NSXMLElement elementWithName:@"TYPE"]; + [key addChild:elem]; + } + } + + if (type != nil) { + [elem setStringValue:type]; + } else if (key != nil) { + [self removeChildAtIndex:[[self children] indexOfObject:key]]; + } +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.h new file mode 100644 index 0000000..5a643e5 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.h @@ -0,0 +1,31 @@ +// +// XMPPvCardTempAdr.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import + +#import "XMPPvCardTempAdrTypes.h" + + +@interface XMPPvCardTempAdr : XMPPvCardTempAdrTypes + + +@property (nonatomic, assign) NSString *pobox; +@property (nonatomic, assign) NSString *extendedAddress; +@property (nonatomic, assign) NSString *street; +@property (nonatomic, assign) NSString *locality; +@property (nonatomic, assign) NSString *region; +@property (nonatomic, assign) NSString *postalCode; +@property (nonatomic, assign) NSString *country; + + ++ (XMPPvCardTempAdr *)vCardAdrFromElement:(NSXMLElement *)elem; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.m new file mode 100644 index 0000000..fcf166a --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdr.m @@ -0,0 +1,132 @@ +// +// XMPPvCardTempAdr.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempAdr.h" +#import "XMPPLogging.h" + +#import + +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#endif + + +@implementation XMPPvCardTempAdr + + ++ (void)initialize +{ + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPvCardTempAdr class]); + + if (superSize != ourSize) + { + XMPPLogError(@"Adding instance variables to XMPPvCardTempAdr is not currently supported!"); + + [DDLog flushLog]; + exit(15); + } +} + + ++ (XMPPvCardTempAdr *)vCardAdrFromElement:(NSXMLElement *)elem { + object_setClass(elem, [XMPPvCardTempAdr class]); + + return (XMPPvCardTempAdr *)elem; +} + + +#pragma mark - +#pragma mark Getter/setter methods + + +- (NSString *)pobox { + return [[self elementForName:@"POBOX"] stringValue]; +} + + +- (void)setPobox:(NSString *)pobox { + XMPP_VCARD_SET_STRING_CHILD(pobox, @"POBOX"); +} + + +- (NSString *)extendedAddress { + return [[self elementForName:@"EXTADD"] stringValue]; +} + + +- (void)setExtendedAddress:(NSString *)extadd { + XMPP_VCARD_SET_STRING_CHILD(extadd, @"EXTADD"); +} + + +- (NSString *)street { + return [[self elementForName:@"STREET"] stringValue]; +} + + +- (void)setStreet:(NSString *)street { + XMPP_VCARD_SET_STRING_CHILD(street, @"STREET"); +} + + +- (NSString *)locality { + return [[self elementForName:@"LOCALITY"] stringValue]; +} + + +- (void)setLocality:(NSString *)locality { + XMPP_VCARD_SET_STRING_CHILD(locality, @"LOCALITY"); +} + + +- (NSString *)region { + return [[self elementForName:@"REGION"] stringValue]; +} + + +- (void)setRegion:(NSString *)region { + XMPP_VCARD_SET_STRING_CHILD(region, @"REGION"); +} + + +- (NSString *)postalCode { + return [[self elementForName:@"PCODE"] stringValue]; +} + + +- (void)setPostalCode:(NSString *)pcode { + XMPP_VCARD_SET_STRING_CHILD(pcode, @"PCODE"); +} + + +- (NSString *)country { + return [[self elementForName:@"CTRY"] stringValue]; +} + + +- (void)setCountry:(NSString *)ctry { + XMPP_VCARD_SET_STRING_CHILD(ctry, @"CTRY"); +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.h new file mode 100644 index 0000000..db2b481 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.h @@ -0,0 +1,28 @@ +// +// XMPPvCardTempAdrTypes.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import + +#import "XMPPvCardTempBase.h" + + +@interface XMPPvCardTempAdrTypes : XMPPvCardTempBase + + +@property (nonatomic, assign, setter=setHome:) BOOL isHome; +@property (nonatomic, assign, setter=setWork:) BOOL isWork; +@property (nonatomic, assign, setter=setParcel:) BOOL isParcel; +@property (nonatomic, assign, setter=setPostal:) BOOL isPostal; +@property (nonatomic, assign, setter=setDomestic:) BOOL isDomestic; +@property (nonatomic, assign, setter=setInternational:) BOOL isInternational; +@property (nonatomic, assign, setter=setPreferred:) BOOL isPreferred; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.m new file mode 100644 index 0000000..cfd35b6 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempAdrTypes.m @@ -0,0 +1,99 @@ +// +// XMPPvCardTempAdrTypes.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempAdrTypes.h" + + +@implementation XMPPvCardTempAdrTypes + + +#pragma mark - +#pragma mark Getter/setter methods + + +- (BOOL)isHome { + return [self elementForName:@"HOME"] != nil; +} + + +- (void)setHome:(BOOL)home { + XMPP_VCARD_SET_EMPTY_CHILD(home && ![self isHome], @"HOME"); +} + + +- (BOOL)isWork { + return [self elementForName:@"WORK"] != nil; +} + + +- (void)setWork:(BOOL)work { + XMPP_VCARD_SET_EMPTY_CHILD(work && ![self isWork], @"WORK"); +} + + +- (BOOL)isParcel { + return [self elementForName:@"PARCEL"] != nil; +} + + +- (void)setParcel:(BOOL)parcel { + XMPP_VCARD_SET_EMPTY_CHILD(parcel && ![self isParcel], @"PARCEL"); +} + + +- (BOOL)isPostal { + return [self elementForName:@"POSTAL"] != nil; +} + + +- (void)setPostal:(BOOL)postal { + XMPP_VCARD_SET_EMPTY_CHILD(postal && ![self isPostal], @"POSTAL"); +} + + +- (BOOL)isDomestic { + return [self elementForName:@"DOM"] != nil; +} + + +- (void)setDomestic:(BOOL)dom { + XMPP_VCARD_SET_EMPTY_CHILD(dom && ![self isDomestic], @"DOM"); + // INTL and DOM are mutually exclusive + if (dom) { + [self setInternational:NO]; + } +} + + +- (BOOL)isInternational { + return [self elementForName:@"INTL"] != nil; +} + + +- (void)setInternational:(BOOL)intl { + XMPP_VCARD_SET_EMPTY_CHILD(intl && ![self isInternational], @"INTL"); + // INTL and DOM are mutually exclusive + if (intl) { + [self setDomestic:NO]; + } +} + + +- (BOOL)isPreferred { + return [self elementForName:@"PREF"] != nil; +} + + +- (void)setPreferred:(BOOL)pref { + XMPP_VCARD_SET_EMPTY_CHILD(pref && ![self isPreferred], @"PREF"); +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.h new file mode 100644 index 0000000..33a4705 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.h @@ -0,0 +1,68 @@ +// +// XMPPvCardTempBase.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import +#import "NSXMLElement+XMPP.h" + + +#define XMPP_VCARD_SET_EMPTY_CHILD(Set, Name) \ + if (Set) { \ + [self addChild:[NSXMLElement elementWithName:(Name)]]; \ + } \ + else if (!(Set)) { \ + [self removeChildAtIndex:[[self children] indexOfObject:[self elementForName:(Name)]]]; \ + } + + +#define XMPP_VCARD_SET_STRING_CHILD(Value, Name) \ + NSXMLElement *elem = [self elementForName:(Name)]; \ + if ((Value) != nil) \ + { \ + if (elem == nil) { \ + elem = [NSXMLElement elementWithName:(Name)]; \ + } \ + [elem setStringValue:(Value)]; \ + } \ + else if (elem != nil) { \ + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; \ + } + + +#define XMPP_VCARD_SET_N_CHILD(Value, Name) \ + NSXMLElement *name = [self elementForName:@"N"]; \ + if ((Value) != nil && name == nil) \ + { \ + name = [NSXMLElement elementWithName:@"N"]; \ + [self addChild:name]; \ + } \ + \ + NSXMLElement *part = [name elementForName:(Name)]; \ + if ((Value) != nil && part == nil) \ + { \ + part = [NSXMLElement elementWithName:(Name)]; \ + [name addChild:part]; \ + } \ + \ + if (Value) \ + { \ + [part setStringValue:(Value)]; \ + } \ + else if (part != nil) \ + { \ + /* N is mandatory, so we leave it in. */ \ + [name removeChildAtIndex:[[self children] indexOfObject:part]]; \ + } + + +@interface XMPPvCardTempBase : NSXMLElement { + +} + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.m new file mode 100644 index 0000000..f4f3ec4 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempBase.m @@ -0,0 +1,65 @@ +// +// XMPPvCardTempBase.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempBase.h" + + +@implementation XMPPvCardTempBase + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +#pragma mark NSCoding protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + +#if ! TARGET_OS_IPHONE +- (id)replacementObjectForPortCoder:(NSPortCoder *)encoder +{ + if([encoder isBycopy]) + return self; + else + return [NSDistantObject proxyWithLocal:self connection:[encoder connection]]; +} +#endif + + +- (id)initWithCoder:(NSCoder *)coder +{ + NSString *xmlString; + if([coder allowsKeyedCoding]) + { + xmlString = [coder decodeObjectForKey:@"xmlString"]; + } + else + { + xmlString = [coder decodeObject]; + } + + return [super initWithXMLString:xmlString error:nil]; +} + + +- (void)encodeWithCoder:(NSCoder *)coder +{ + NSString *xmlString = [self XMLString]; + + if([coder allowsKeyedCoding]) + { + [coder encodeObject:xmlString forKey:@"xmlString"]; + } + else + { + [coder encodeObject:xmlString]; + } +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.h new file mode 100644 index 0000000..9f02d5e --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.h @@ -0,0 +1,30 @@ +// +// XMPPvCardTempEmail.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import + +#import "XMPPvCardTempBase.h" + + +@interface XMPPvCardTempEmail : XMPPvCardTempBase + + +@property (nonatomic, assign, setter=setHome:) BOOL isHome; +@property (nonatomic, assign, setter=setWork:) BOOL isWork; +@property (nonatomic, assign, setter=setInternet:) BOOL isInternet; +@property (nonatomic, assign, setter=setX400:) BOOL isX400; +@property (nonatomic, assign, setter=setPreferred:) BOOL isPreferred; +@property (nonatomic, assign) NSString *userid; + + ++ (XMPPvCardTempEmail *)vCardEmailFromElement:(NSXMLElement *)elem; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.m new file mode 100644 index 0000000..655dc38 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempEmail.m @@ -0,0 +1,121 @@ +// +// XMPPvCardTempEmail.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempEmail.h" +#import "XMPPLogging.h" + +#import + +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#endif + + +@implementation XMPPvCardTempEmail + + ++ (void)initialize { + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPvCardTempEmail class]); + + if (superSize != ourSize) + { + XMPPLogError(@"Adding instance variables to XMPPvCardTempEmail is not currently supported!"); + + [DDLog flushLog]; + exit(15); + } +} + + ++ (XMPPvCardTempEmail *)vCardEmailFromElement:(NSXMLElement *)elem { + object_setClass(elem, [XMPPvCardTempEmail class]); + + return (XMPPvCardTempEmail *)elem; +} + + +#pragma mark - +#pragma mark Getter/setter methods + + +- (BOOL)isHome { + return [self elementForName:@"HOME"] != nil; +} + + +- (void)setHome:(BOOL)home { + XMPP_VCARD_SET_EMPTY_CHILD(home && ![self isHome], @"HOME"); +} + + +- (BOOL)isWork { + return [self elementForName:@"WORK"] != nil; +} + + +- (void)setWork:(BOOL)work { + XMPP_VCARD_SET_EMPTY_CHILD(work && ![self isWork], @"WORK"); +} + + +- (BOOL)isInternet { + return [self elementForName:@"INTERNET"] != nil; +} + + +- (void)setInternet:(BOOL)internet { + XMPP_VCARD_SET_EMPTY_CHILD(internet && ![self isInternet], @"INTERNET"); +} + + +- (BOOL)isX400 { + return [self elementForName:@"X400"] != nil; +} + + +- (void)setX400:(BOOL)x400 { + XMPP_VCARD_SET_EMPTY_CHILD(x400 && ![self isX400], @"X400"); +} + + +- (BOOL)isPreferred { + return [self elementForName:@"PREF"] != nil; +} + + +- (void)setPreferred:(BOOL)pref { + XMPP_VCARD_SET_EMPTY_CHILD(pref && ![self isPreferred], @"PREF"); +} + + +- (NSString *)userid { + return [[self elementForName:@"USERID"] stringValue]; +} + + +- (void)setUserid:(NSString *)userid { + XMPP_VCARD_SET_STRING_CHILD(userid, @"USERID"); +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.h new file mode 100644 index 0000000..b957199 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.h @@ -0,0 +1,25 @@ +// +// XMPPvCardTempLabel.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import + +#import "XMPPvCardTempAdrTypes.h" + + +@interface XMPPvCardTempLabel : XMPPvCardTempAdrTypes + + +@property (nonatomic, assign) NSArray *lines; + + ++ (XMPPvCardTempLabel *)vCardLabelFromElement:(NSXMLElement *)elem; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.m new file mode 100644 index 0000000..8556f8c --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempLabel.m @@ -0,0 +1,90 @@ +// +// XMPPvCardTempLabel.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempLabel.h" +#import "XMPPLogging.h" + +#import + +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#endif + + +@implementation XMPPvCardTempLabel + + ++ (void)initialize { + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPvCardTempLabel class]); + + if (superSize != ourSize) + { + XMPPLogError(@"Adding instance variables to XMPPvCardTempLabel is not currently supported!"); + + [DDLog flushLog]; + exit(15); + } +} + + ++ (XMPPvCardTempLabel *)vCardLabelFromElement:(NSXMLElement *)elem { + object_setClass(elem, [XMPPvCardTempLabel class]); + + return (XMPPvCardTempLabel *)elem; +} + + +#pragma mark - +#pragma mark Getter/setter methods + + +- (NSArray *)lines { + NSArray *elems = [self elementsForName:@"LINE"]; + NSMutableArray *lines = [[NSMutableArray alloc] initWithCapacity:[elems count]]; + + for (NSXMLElement *elem in elems) { + [lines addObject:[elem stringValue]]; + } + + NSArray *result = [NSArray arrayWithArray:lines]; + [lines release]; + return result; +} + + +- (void)setLines:(NSArray *)lines { + NSArray *elems = [self elementsForName:@"LINE"]; + + for (NSXMLElement *elem in elems) { + [self removeChildAtIndex:[[self children] indexOfObject:elem]]; + } + + for (NSString *line in lines) { + NSXMLElement *elem = [NSXMLElement elementWithName:@"LINE"]; + [elem setStringValue:line]; + [self addChild:elem]; + } +} + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.h new file mode 100644 index 0000000..f923d93 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.h @@ -0,0 +1,91 @@ +// +// XMPPvCardTempModule.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/17/11. +// Copyright 2011 RF.com. All rights reserved. +// + + +#import +#import "XMPPModule.h" +#import "XMPPvCardTemp.h" + +@class XMPPJID; +@class XMPPStream; +@protocol XMPPvCardTempModuleStorage; + + +@interface XMPPvCardTempModule : XMPPModule +{ + id _moduleStorage; +} + + +@property(nonatomic, readonly) id moduleStorage; +@property(nonatomic, readonly) XMPPvCardTemp *myvCardTemp; + +- (id)initWithvCardStorage:(id )storage; +- (id)initWithvCardStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue; + +/* + * Return the cached vCard for the user or fetch it, if we don't have it. + */ +- (XMPPvCardTemp *)fetchvCardTempForJID:(XMPPJID *)jid; +- (XMPPvCardTemp *)fetchvCardTempForJID:(XMPPJID *)jid useCache:(BOOL)useCache; +- (void)updateMyvCardTemp:(XMPPvCardTemp *)vCardTemp; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPvCardTempModuleDelegate +@optional + +- (void)xmppvCardTempModule:(XMPPvCardTempModule *)vCardTempModule + didReceivevCardTemp:(XMPPvCardTemp *)vCardTemp + forJID:(XMPPJID *)jid; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPvCardTempModuleStorage + +/** + * Configures the storage class, passing its parent and parent's dispatch queue. + * + * This method is called by the init methods of the XMPPvCardTempModule class. + * This method is designed to inform the storage class of its parent + * and of the dispatch queue the parent will be operating on. + * + * The storage class may choose to operate on the same queue as its parent, + * or it may operate on its own internal dispatch queue. + * + * This method should return YES if it was configured properly. + * The parent class is configured to ignore the passed + * storage class in its init method if this method returns NO. +**/ +- (BOOL)configureWithParent:(XMPPvCardTempModule *)aParent queue:(dispatch_queue_t)queue; + +/** + * Returns a vCardTemp object or nil +**/ +- (XMPPvCardTemp *)vCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Used to set the vCardTemp object when we get it from the XMPP server. +**/ +- (void)setvCardTemp:(XMPPvCardTemp *)vCardTemp forJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Asks the backend if we should fetch the vCardTemp from the network. + * This is used so that we don't request the vCardTemp multiple times. +**/ +- (BOOL)shouldFetchvCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.m new file mode 100644 index 0000000..b196b78 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempModule.m @@ -0,0 +1,207 @@ +// +// XMPPvCardTempModule.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/17/11. +// Copyright 2011 RF.com. All rights reserved. +// + +#import "XMPP.h" +#import "XMPPLogging.h" +#import "XMPPvCardTempModule.h" + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@interface XMPPvCardTempModule() + +- (void)_updatevCardTemp:(XMPPvCardTemp *)vCardTemp forJID:(XMPPJID *)jid; + +@end + +@implementation XMPPvCardTempModule + +@synthesize moduleStorage = _moduleStorage; + +- (id)init +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPvCardTempModule.h are supported. + + return [self initWithvCardStorage:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPvCardTempModule.h are supported. + + return [self initWithvCardStorage:nil dispatchQueue:NULL]; +} + +- (id)initWithvCardStorage:(id )storage +{ + return [self initWithvCardStorage:storage dispatchQueue:NULL]; +} + +- (id)initWithvCardStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(storage != nil); + + if ((self = [super initWithDispatchQueue:queue])) + { + if ([storage configureWithParent:self queue:moduleQueue]) + { + _moduleStorage = [storage retain]; + } + else + { + XMPPLogError(@"%@: %@ - Unable to configure storage!", THIS_FILE, THIS_METHOD); + } + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + // Custom code goes here (if needed) + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + // Custom code goes here (if needed) + + [super deactivate]; +} + +- (void)dealloc +{ + [_moduleStorage release]; + _moduleStorage = nil; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Fetch vCardTemp methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (XMPPvCardTemp *)fetchvCardTempForJID:(XMPPJID *)jid +{ + return [self fetchvCardTempForJID:jid useCache:YES]; +} + +- (XMPPvCardTemp *)fetchvCardTempForJID:(XMPPJID *)jid useCache:(BOOL)useCache +{ + __block XMPPvCardTemp *result; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPvCardTemp *vCardTemp = nil; + + if (useCache) + { + // Try loading from the cache + vCardTemp = [_moduleStorage vCardTempForJID:jid xmppStream:xmppStream]; + } + + if (vCardTemp == nil && [_moduleStorage shouldFetchvCardTempForJID:jid xmppStream:xmppStream]) + { + [xmppStream sendElement:[XMPPvCardTemp iqvCardRequestForJID:jid]]; + } + + result = [vCardTemp retain]; + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return [result autorelease]; +} + +- (XMPPvCardTemp *)myvCardTemp +{ + return [self fetchvCardTempForJID:[xmppStream myJID]]; +} + +- (void)updateMyvCardTemp:(XMPPvCardTemp *)vCardTemp +{ + XMPPvCardTemp *newvCardTemp = [vCardTemp copy]; + + NSString *elemId = [xmppStream generateUUID]; + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:nil elementID:elemId child:newvCardTemp]; + [xmppStream sendElement:iq]; + + [self _updatevCardTemp:newvCardTemp forJID:[xmppStream myJID]]; + + [newvCardTemp release]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Private +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)_updatevCardTemp:(XMPPvCardTemp *)vCardTemp forJID:(XMPPJID *)jid +{ + // this method could be called from anywhere + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogVerbose(@"%@: %s %@", THIS_FILE, __PRETTY_FUNCTION__, [jid bare]); + + [_moduleStorage setvCardTemp:vCardTemp forJID:jid xmppStream:xmppStream]; + + [(id )multicastDelegate xmppvCardTempModule:self + didReceivevCardTemp:vCardTemp + forJID:jid]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStreamDelegate methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // This method is invoked on the moduleQueue. + + // Remember XML heirarchy memory management rules. + // The passed parameter is a subnode of the IQ, and we need to pass it to an asynchronous operation. + // + // Therefore we use vCardTempCopyFromIQ instead of vCardTempSubElementFromIQ. + + XMPPvCardTemp *vCardTemp = [XMPPvCardTemp vCardTempCopyFromIQ:iq]; + if (vCardTemp != nil) + { + [self _updatevCardTemp:vCardTemp forJID:[iq from]]; + + return YES; + } + + return NO; +} + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.h b/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.h new file mode 100644 index 0000000..fcb0370 --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.h @@ -0,0 +1,38 @@ +// +// XMPPvCardTempTel.h +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import + +#import "XMPPvCardTempBase.h" + + +@interface XMPPvCardTempTel : XMPPvCardTempBase + + +@property (nonatomic, assign, setter=setHome:) BOOL isHome; +@property (nonatomic, assign, setter=setWork:) BOOL isWork; +@property (nonatomic, assign, setter=setVoice:) BOOL isVoice; +@property (nonatomic, assign, setter=setFax:) BOOL isFax; +@property (nonatomic, assign, setter=setPager:) BOOL isPager; +@property (nonatomic, assign, setter=setMessaging:) BOOL hasMessaging; +@property (nonatomic, assign, setter=setCell:) BOOL isCell; +@property (nonatomic, assign, setter=setVideo:) BOOL isVideo; +@property (nonatomic, assign, setter=setBBS:) BOOL isBBS; +@property (nonatomic, assign, setter=setModem:) BOOL isModem; +@property (nonatomic, assign, setter=setISDN:) BOOL isISDN; +@property (nonatomic, assign, setter=setPCS:) BOOL isPCS; +@property (nonatomic, assign, setter=setPreferred:) BOOL isPreferred; +@property (nonatomic, assign) NSString *number; + + ++ (XMPPvCardTempTel *)vCardTelFromElement:(NSXMLElement *)elem; + + +@end diff --git a/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.m b/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.m new file mode 100644 index 0000000..79e14bc --- /dev/null +++ b/xmpp/Extensions/XEP-0054/XMPPvCardTempTel.m @@ -0,0 +1,200 @@ +// +// XMPPvCardTempTel.m +// XEP-0054 vCard-temp +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + + +#import "XMPPvCardTempTel.h" +#import "XMPPLogging.h" + +#import + +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_ERROR; +#endif + + +@implementation XMPPvCardTempTel + + ++ (void)initialize { + // We use the object_setClass method below to dynamically change the class from a standard NSXMLElement. + // The size of the two classes is expected to be the same. + // + // If a developer adds instance methods to this class, bad things happen at runtime that are very hard to debug. + // This check is here to aid future developers who may make this mistake. + // + // For Fearless And Experienced Objective-C Developers: + // It may be possible to support adding instance variables to this class if you seriously need it. + // To do so, try realloc'ing self after altering the class, and then initialize your variables. + + size_t superSize = class_getInstanceSize([NSXMLElement class]); + size_t ourSize = class_getInstanceSize([XMPPvCardTempTel class]); + + if (superSize != ourSize) + { + XMPPLogError(@"Adding instance variables to XMPPvCardTempTel is not currently supported!"); + + [DDLog flushLog]; + exit(15); + } +} + + ++ (XMPPvCardTempTel *)vCardTelFromElement:(NSXMLElement *)elem { + object_setClass(elem, [XMPPvCardTempTel class]); + + return (XMPPvCardTempTel *)elem; +} + + +#pragma mark - +#pragma mark Getter/setter methods + +- (BOOL)isHome { + return [self elementForName:@"HOME"] != nil; +} + + +- (void)setHome:(BOOL)home { + XMPP_VCARD_SET_EMPTY_CHILD(home && ![self isHome], @"HOME"); +} + + +- (BOOL)isWork { + return [self elementForName:@"WORK"] != nil; +} + + +- (void)setWork:(BOOL)work { + XMPP_VCARD_SET_EMPTY_CHILD(work && ![self isWork], @"WORK"); +} + + +- (BOOL)isVoice { + return [self elementForName:@"VOICE"] != nil; +} + + +- (void)setVoice:(BOOL)voice { + XMPP_VCARD_SET_EMPTY_CHILD(voice && ![self isVoice], @"VOICE"); +} + + +- (BOOL)isFax { + return [self elementForName:@"FAX"] != nil; +} + + +- (void)setFax:(BOOL)fax { + XMPP_VCARD_SET_EMPTY_CHILD(fax && ![self isFax], @"FAX"); +} + + +- (BOOL)isPager { + return [self elementForName:@"PAGER"] != nil; +} + + +- (void)setPager:(BOOL)pager { + XMPP_VCARD_SET_EMPTY_CHILD(pager && ![self isPager], @"PAGER"); +} + + +- (BOOL)hasMessaging { + return [self elementForName:@"MSG"] != nil; +} + + +- (void)setMessaging:(BOOL)msg { + XMPP_VCARD_SET_EMPTY_CHILD(msg && ![self hasMessaging], @"MSG"); +} + + +- (BOOL)isCell { + return [self elementForName:@"CELL"] != nil; +} + + +- (void)setCell:(BOOL)cell { + XMPP_VCARD_SET_EMPTY_CHILD(cell && ![self isCell], @"CELL"); +} + + +- (BOOL)isVideo { + return [self elementForName:@"VIDEO"] != nil; +} + + +- (void)setVideo:(BOOL)video { + XMPP_VCARD_SET_EMPTY_CHILD(video && ![self isVideo], @"VIDEO"); +} + + +- (BOOL)isBBS { + return [self elementForName:@"BBS"] != nil; +} + + +- (void)setBBS:(BOOL)bbs { + XMPP_VCARD_SET_EMPTY_CHILD(bbs && ![self isBBS], @"BBS"); +} + + +- (BOOL)isModem { + return [self elementForName:@"MODEM"] != nil; +} + + +- (void)setModem:(BOOL)modem { + XMPP_VCARD_SET_EMPTY_CHILD(modem && ![self isModem], @"MODEM"); +} + + +- (BOOL)isISDN { + return [self elementForName:@"ISDN"] != nil; +} + + +- (void)setISDN:(BOOL)isdn { + XMPP_VCARD_SET_EMPTY_CHILD(isdn && ![self isISDN], @"ISDN"); +} + + +- (BOOL)isPCS { + return [self elementForName:@"PCS"] != nil; +} + + +- (void)setPCS:(BOOL)pcs { + XMPP_VCARD_SET_EMPTY_CHILD(pcs && ![self isPCS], @"PCS"); +} + + +- (BOOL)isPreferred { + return [self elementForName:@"PREF"] != nil; +} + + +- (void)setPreferred:(BOOL)pref { + XMPP_VCARD_SET_EMPTY_CHILD(pref && ![self isPreferred], @"PREF"); +} + + +- (NSString *)number { + return [[self elementForName:@"NUMBER"] stringValue]; +} + + +- (void)setNumber:(NSString *)number { + XMPP_VCARD_SET_STRING_CHILD(number, @"NUMBER"); +} + + +@end diff --git a/xmpp/Extensions/XEP-0060/XMPPPubSub.h b/xmpp/Extensions/XEP-0060/XMPPPubSub.h new file mode 100644 index 0000000..b836c7f --- /dev/null +++ b/xmpp/Extensions/XEP-0060/XMPPPubSub.h @@ -0,0 +1,43 @@ +// +// XMPPPubSub.h +// +// Created by Duncan Robertson [duncan@whomwah.com] +// + +#import +#import "XMPPModule.h" + +@class XMPPStream; +@class XMPPJID; +@class XMPPIQ; +@class XMPPMessage; + +@interface XMPPPubSub : XMPPModule +{ + XMPPJID *serviceJID; +} + +- (id)initWithServiceJID:(XMPPJID *)aServiceJID; +- (id)initWithServiceJID:(XMPPJID *)aServiceJID dispatchQueue:(dispatch_queue_t)queue; + +@property (nonatomic, readonly) XMPPJID *serviceJID; + +- (NSString *)subscribeToNode:(NSString *)node withOptions:(NSDictionary *)options; +- (NSString *)unsubscribeFromNode:(NSString *)node; +- (NSString *)createNode:(NSString *)node withOptions:(NSDictionary *)options; +- (NSString *)deleteNode:(NSString *)node; +- (NSString *)configureNode:(NSString *)node; +- (NSString *)allItemsForNode:(NSString *)node; + +@end + +@protocol XMPPPubSubDelegate +@optional + +- (void)xmppPubSub:(XMPPPubSub *)sender didSubscribe:(XMPPIQ *)iq; +- (void)xmppPubSub:(XMPPPubSub *)sender didCreateNode:(NSString *)node withIQ:(XMPPIQ *)iq; +- (void)xmppPubSub:(XMPPPubSub *)sender didReceiveMessage:(XMPPMessage *)message; +- (void)xmppPubSub:(XMPPPubSub *)sender didReceiveError:(XMPPIQ *)iq; +- (void)xmppPubSub:(XMPPPubSub *)sender didReceiveResult:(XMPPIQ *)iq; + +@end diff --git a/xmpp/Extensions/XEP-0060/XMPPPubSub.m b/xmpp/Extensions/XEP-0060/XMPPPubSub.m new file mode 100644 index 0000000..7a98acc --- /dev/null +++ b/xmpp/Extensions/XEP-0060/XMPPPubSub.m @@ -0,0 +1,374 @@ +// +// XMPPPubSub.m +// +// Created by Duncan Robertson [duncan@whomwah.com] +// + +#import "XMPPPubSub.h" +#import "XMPP.h" + +#define NS_PUBSUB @"http://jabber.org/protocol/pubsub" +#define NS_PUBSUB_EVENT @"http://jabber.org/protocol/pubsub#event" +#define NS_PUBSUB_CONFIG @"http://jabber.org/protocol/pubsub#node_config" +#define NS_PUBSUB_OWNER @"http://jabber.org/protocol/pubsub#owner" +#define NS_DISCO_ITEMS @"http://jabber.org/protocol/disco#items" + +#define INTEGRATE_WITH_CAPABILITIES 1 + +#if INTEGRATE_WITH_CAPABILITIES +#import "XMPPCapabilities.h" +#endif + +@implementation XMPPPubSub; + +@synthesize serviceJID; + +- (id)init +{ + return [self initWithServiceJID:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + return [self initWithServiceJID:nil dispatchQueue:NULL]; +} + +- (id)initWithServiceJID:(XMPPJID *)aServiceJID +{ + return [self initWithServiceJID:aServiceJID dispatchQueue:NULL]; +} + +- (id)initWithServiceJID:(XMPPJID *)aServiceJID dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(aServiceJID != nil); + + if ((self = [super initWithDispatchQueue:queue])) + { + serviceJID = [aServiceJID copy]; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([self activate:aXmppStream]) + { + #if INTEGRATE_WITH_CAPABILITIES + [xmppStream autoAddDelegate:self delegateQueue:moduleQueue toModulesOfClass:[XMPPCapabilities class]]; + #endif + + return YES; + } + + return NO; +} + +- (void)deactivate +{ +#if INTEGRATE_WITH_CAPABILITIES + [xmppStream removeAutoDelegate:self delegateQueue:moduleQueue fromModulesOfClass:[XMPPCapabilities class]]; +#endif + + [super deactivate]; +} + +- (void)dealloc +{ + [serviceJID release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Delegate method to receive incoming IQ stanzas. +**/ +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + if ([iq isResultIQ]) + { + NSXMLElement *pubsub = [iq elementForName:@"pubsub" xmlns:NS_PUBSUB]; + if (pubsub) + { + // + // + // + // + // + + NSXMLElement *subscription = [pubsub elementForName:@"subscription"]; + if (subscription) + { + NSString *value = [subscription attributeStringValueForName:@"subscription"]; + if (value && ([value caseInsensitiveCompare:@"subscribed"] == NSOrderedSame)) + { + [multicastDelegate xmppPubSub:self didSubscribe:iq]; + return YES; + } + } + } + + [multicastDelegate xmppPubSub:self didReceiveResult:iq]; + return YES; + } + else if ([iq isErrorIQ]) + { + [multicastDelegate xmppPubSub:self didReceiveError:iq]; + return YES; + } + + return NO; +} + +/** + * Delegate method to receive incoming message stanzas. +**/ +- (void)xmppStream:(XMPPStream *)sender didReceiveMessage:(XMPPMessage *)message +{ + // + // + // + // + // + // Huw Stephens sits in for Greg James and David Garrido takes a look at the sporting week + // + // + // + // + // + + NSXMLElement *event = [message elementForName:@"event" xmlns:NS_PUBSUB_EVENT]; + if (event) + { + [multicastDelegate xmppPubSub:self didReceiveMessage:message]; + } +} + +#if INTEGRATE_WITH_CAPABILITIES +/** + * If an XMPPCapabilites instance is used we want to advertise our support for pubsub support. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender collectingMyCapabilities:(NSXMLElement *)query +{ + // + // ... + // + // + // ... + // + + NSXMLElement *identity = [NSXMLElement elementWithName:@"identity"]; + [identity addAttributeWithName:@"category" stringValue:@"pubsub"]; + [identity addAttributeWithName:@"type" stringValue:@"service"]; + [query addChild:identity]; + + NSXMLElement *feature = [NSXMLElement elementWithName:@"feature"]; + [feature addAttributeWithName:@"var" stringValue:NS_PUBSUB]; + [query addChild:feature]; +} +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Subscription Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)subscribeToNode:(NSString *)node withOptions:(NSDictionary *)options +{ + // + // + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:subscribe_node", xmppStream.generateUUID]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:serviceJID elementID:sid]; + NSXMLElement *ps = [NSXMLElement elementWithName:@"pubsub" xmlns:NS_PUBSUB]; + NSXMLElement *subscribe = [NSXMLElement elementWithName:@"subscribe"]; + [subscribe addAttributeWithName:@"node" stringValue:node]; + [subscribe addAttributeWithName:@"jid" stringValue:[xmppStream.myJID full]]; + + [ps addChild:subscribe]; + [iq addChild:ps]; + + [xmppStream sendElement:iq]; + + return sid; +} + + +- (NSString *)unsubscribeFromNode:(NSString*)node +{ + // + // + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:unsubscribe_node", xmppStream.generateUUID]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:serviceJID elementID:sid]; + NSXMLElement *ps = [NSXMLElement elementWithName:@"pubsub" xmlns:NS_PUBSUB]; + NSXMLElement *subscribe = [NSXMLElement elementWithName:@"unsubscribe"]; + [subscribe addAttributeWithName:@"node" stringValue:node]; + [subscribe addAttributeWithName:@"jid" stringValue:[xmppStream.myJID full]]; + + // join them all together + [ps addChild:subscribe]; + [iq addChild:ps]; + + [xmppStream sendElement:iq]; + + return sid; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Node Admin +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)createNode:(NSString *)node withOptions:(NSDictionary *)options +{ + // + // + // + // + // + // + // http://jabber.org/protocol/pubsub#node_config + // + // Princely Musings (Atom) + // 1 + // 1 + // 1 + // 10 + // ... + // + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:create_node", xmppStream.generateUUID]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:serviceJID elementID:sid]; + NSXMLElement *ps = [NSXMLElement elementWithName:@"pubsub" xmlns:NS_PUBSUB]; + NSXMLElement *create = [NSXMLElement elementWithName:@"create"]; + [create addAttributeWithName:@"node" stringValue:node]; + + if (options != nil && [options count] > 0) + { + + NSXMLElement *config = [NSXMLElement elementWithName:@"configure"]; + NSXMLElement *x = [NSXMLElement elementWithName:@"x" xmlns:@"jabber:x:data"]; + [x addAttributeWithName:@"type" stringValue:@"submit"]; + + NSXMLElement *field = [NSXMLElement elementWithName:@"field"]; + [field addAttributeWithName:@"var" stringValue:@"FORM_TYPE"]; + [field addAttributeWithName:@"type" stringValue:@"hidden"]; + NSXMLElement *value = [NSXMLElement elementWithName:@"value"]; + [value setStringValue:NS_PUBSUB_CONFIG]; + [field addChild:value]; + [x addChild:field]; + + NSXMLElement *f; + NSXMLElement *v; + for (NSString *item in options) + { + f = [NSXMLElement elementWithName:@"field"]; + [f addAttributeWithName:@"var" + stringValue:[NSString stringWithFormat:@"pubsub#%@", [options valueForKey:item]]]; + v = [NSXMLElement elementWithName:@"value"]; + [v setStringValue:item]; + [f addChild:v]; + [x addChild:f]; + } + + [config addChild:x]; + [ps addChild:config]; + + } + + [ps addChild:create]; + [iq addChild:ps]; + + [xmppStream sendElement:iq]; + + return sid; +} + +/** + * This method currently does not support redirection +**/ +- (NSString*)deleteNode:(NSString*)node +{ + // + // + // + // + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:delete_node", xmppStream.generateUUID]; + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:serviceJID elementID:sid]; + NSXMLElement *ps = [NSXMLElement elementWithName:@"pubsub" xmlns:NS_PUBSUB_OWNER]; + + NSXMLElement *delete = [NSXMLElement elementWithName:@"delete"]; + [delete addAttributeWithName:@"node" stringValue:node]; + + [ps addChild:delete]; + [iq addChild:ps]; + + [xmppStream sendElement:iq]; + + return sid; +} + + +- (NSString*)allItemsForNode:(NSString*)node +{ + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:items_for_node", xmppStream.generateUUID]; + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:serviceJID elementID:sid]; + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:NS_DISCO_ITEMS]; + + if (node != nil) { + [query addAttributeWithName:@"node" stringValue:node]; + } + + [iq addChild:query]; + + [xmppStream sendElement:iq]; + + return sid; +} + +- (NSString*)configureNode:(NSString*)node +{ + // + // + // + // + // + + NSString *sid = [NSString stringWithFormat:@"%@:configure_node", xmppStream.generateUUID]; + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:serviceJID elementID:sid]; + NSXMLElement *ps = [NSXMLElement elementWithName:@"pubsub" xmlns:NS_PUBSUB_OWNER]; + + NSXMLElement *conf = [NSXMLElement elementWithName:@"configure"]; + [conf addAttributeWithName:@"node" stringValue:node]; + + [ps addChild:conf]; + [iq addChild:ps]; + + [xmppStream sendElement:iq]; + + return sid; +} + +@end diff --git a/xmpp/Extensions/XEP-0065/TURNSocket.h b/xmpp/Extensions/XEP-0065/TURNSocket.h new file mode 100644 index 0000000..1f1ef6a --- /dev/null +++ b/xmpp/Extensions/XEP-0065/TURNSocket.h @@ -0,0 +1,78 @@ +#import + +@class XMPPIQ; +@class XMPPJID; +@class XMPPStream; +@class GCDAsyncSocket; + +/** + * TURNSocket is an implementation of XEP-0065: SOCKS5 Bytestreams. + * + * It is used for establishing an out-of-band bytestream between any two XMPP users, + * mainly for the purpose of file transfer. +**/ +@interface TURNSocket : NSObject +{ + int state; + BOOL isClient; + + dispatch_queue_t turnQueue; + + XMPPStream *xmppStream; + XMPPJID *jid; + NSString *uuid; + + id delegate; + dispatch_queue_t delegateQueue; + + dispatch_source_t turnTimer; + + NSString *discoUUID; + dispatch_source_t discoTimer; + + NSArray *proxyCandidates; + NSUInteger proxyCandidateIndex; + + NSMutableArray *candidateJIDs; + NSUInteger candidateJIDIndex; + + NSMutableArray *streamhosts; + NSUInteger streamhostIndex; + + XMPPJID *proxyJID; + NSString *proxyHost; + UInt16 proxyPort; + + GCDAsyncSocket *asyncSocket; + + NSDate *startTime, *finishTime; +} + ++ (BOOL)isNewStartTURNRequest:(XMPPIQ *)iq; + ++ (NSArray *)proxyCandidates; ++ (void)setProxyCandidates:(NSArray *)candidates; + +- (id)initWithStream:(XMPPStream *)xmppStream toJID:(XMPPJID *)jid; +- (id)initWithStream:(XMPPStream *)xmppStream incomingTURNRequest:(XMPPIQ *)iq; + +- (void)startWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)aDelegateQueue; + +- (BOOL)isClient; + +- (void)abort; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol TURNSocketDelegate +@optional + +- (void)turnSocket:(TURNSocket *)sender didSucceed:(GCDAsyncSocket *)socket; + +- (void)turnSocketDidFail:(TURNSocket *)sender; + +@end \ No newline at end of file diff --git a/xmpp/Extensions/XEP-0065/TURNSocket.m b/xmpp/Extensions/XEP-0065/TURNSocket.m new file mode 100644 index 0000000..6da80db --- /dev/null +++ b/xmpp/Extensions/XEP-0065/TURNSocket.m @@ -0,0 +1,1550 @@ +#import "TURNSocket.h" +#import "XMPP.h" +#import "XMPPLogging.h" +#import "GCDAsyncSocket.h" +#import "NSData+XMPP.h" +#import "NSNumber+XMPP.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +// Define various states +#define STATE_INIT 0 + +#define STATE_PROXY_DISCO_ITEMS 10 +#define STATE_PROXY_DISCO_INFO 11 +#define STATE_PROXY_DISCO_ADDR 12 +#define STATE_REQUEST_SENT 13 +#define STATE_INITIATOR_CONNECT 14 +#define STATE_ACTIVATE_SENT 15 +#define STATE_TARGET_CONNECT 20 +#define STATE_DONE 30 +#define STATE_FAILURE 31 + +// Define various socket tags +#define SOCKS_OPEN 101 +#define SOCKS_CONNECT 102 +#define SOCKS_CONNECT_REPLY_1 103 +#define SOCKS_CONNECT_REPLY_2 104 + +// Define various timeouts (in seconds) +#define TIMEOUT_DISCO_ITEMS 8.00 +#define TIMEOUT_DISCO_INFO 8.00 +#define TIMEOUT_DISCO_ADDR 5.00 +#define TIMEOUT_CONNECT 8.00 +#define TIMEOUT_READ 5.00 +#define TIMEOUT_TOTAL 80.00 + +// Declare private methods +@interface TURNSocket (PrivateAPI) +- (void)processDiscoItemsResponse:(XMPPIQ *)iq; +- (void)processDiscoInfoResponse:(XMPPIQ *)iq; +- (void)processDiscoAddressResponse:(XMPPIQ *)iq; +- (void)processRequestResponse:(XMPPIQ *)iq; +- (void)processActivateResponse:(XMPPIQ *)iq; +- (void)performPostInitSetup; +- (void)queryProxyCandidates; +- (void)queryNextProxyCandidate; +- (void)queryCandidateJIDs; +- (void)queryNextCandidateJID; +- (void)queryProxyAddress; +- (void)targetConnect; +- (void)targetNextConnect; +- (void)initiatorConnect; +- (void)setupDiscoTimerForDiscoItems; +- (void)setupDiscoTimerForDiscoInfo; +- (void)setupDiscoTimerForDiscoAddress; +- (void)doDiscoItemsTimeout:(NSString *)uuid; +- (void)doDiscoInfoTimeout:(NSString *)uuid; +- (void)doDiscoAddressTimeout:(NSString *)uuid; +- (void)doTotalTimeout; +- (void)succeed; +- (void)fail; +- (void)cleanup; +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation TURNSocket + +static NSMutableDictionary *existingTurnSockets; +static NSMutableArray *proxyCandidates; + +/** + * Called automatically (courtesy of Cocoa) before the first method of this class is called. + * It may also be called directly, hence the safety mechanism. +**/ ++ (void)initialize +{ + static BOOL initialized = NO; + if (!initialized) + { + initialized = YES; + + existingTurnSockets = [[NSMutableDictionary alloc] init]; + proxyCandidates = [[NSMutableArray alloc] initWithObjects:@"jabber.org", nil]; + } +} + +/** + * Returns whether or not the given IQ is a new start TURN request. + * That is, the IQ must have a query with the proper namespace, + * and it must not correspond to an existing TURNSocket. +**/ ++ (BOOL)isNewStartTURNRequest:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + // An incoming turn request looks like this: + // + // + // + // + // + // + // + // + // + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + NSString *queryMode = [[query attributeForName:@"mode"] stringValue]; + + BOOL isTcpBytestreamQuery = NO; + if (queryMode) + { + isTcpBytestreamQuery = [queryMode caseInsensitiveCompare:@"tcp"] == NSOrderedSame; + } + + if (isTcpBytestreamQuery) + { + NSString *uuid = [iq elementID]; + + @synchronized(existingTurnSockets) + { + if ([existingTurnSockets objectForKey:uuid]) + return NO; + else + return YES; + } + } + return NO; +} + +/** + * Returns a list of proxy candidates. + * + * You may want to configure this to include NSUserDefaults stuff, or implement your own static/dynamic list. +**/ ++ (NSArray *)proxyCandidates +{ + NSArray *result = nil; + + @synchronized(proxyCandidates) + { + XMPPLogTrace(); + + result = [[proxyCandidates copy] autorelease]; + } + + return result; +} + ++ (void)setProxyCandidates:(NSArray *)candidates +{ + @synchronized(proxyCandidates) + { + XMPPLogTrace(); + + [proxyCandidates removeAllObjects]; + [proxyCandidates addObjectsFromArray:candidates]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Init, Dealloc +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Initializes a new TURN socket to create a TCP connection by routing through a proxy. + * This constructor configures the object to be the client connecting to a server. +**/ +- (id)initWithStream:(XMPPStream *)stream toJID:(XMPPJID *)aJid +{ + if ((self = [super init])) + { + XMPPLogTrace(); + + // Store references + xmppStream = [stream retain]; + jid = [aJid retain]; + + // Create a uuid to be used as the id for all messages in the stun communication. + // This helps differentiate various turn messages between various turn sockets. + // Relying only on JID's is troublesome, because client A could be initiating a connection to server B, + // while at the same time client B could be initiating a connection to server A. + // So an incoming connection from JID clientB@deusty.com/home would be for which turn socket? + uuid = [[xmppStream generateUUID] retain]; + + // Setup initial state for a client connection + state = STATE_INIT; + isClient = YES; + + // Get list of proxy candidates + // Each host in this list will be queried to see if it can be used as a proxy + proxyCandidates = [[[self class] proxyCandidates] retain]; + + // Configure everything else + [self performPostInitSetup]; + } + return self; +} + +/** + * Initializes a new TURN socket to create a TCP connection by routing through a proxy. + * This constructor configures the object to be the server accepting a connection from a client. +**/ +- (id)initWithStream:(XMPPStream *)stream incomingTURNRequest:(XMPPIQ *)iq +{ + if ((self = [super init])) + { + XMPPLogTrace(); + + // Store references + xmppStream = [stream retain]; + jid = [[iq from] retain]; + + // Store a copy of the ID (which will be our uuid) + uuid = [[iq elementID] copy]; + + // Setup initial state for a server connection + state = STATE_INIT; + isClient = NO; + + // Extract streamhost information from turn request + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + streamhosts = [[query elementsForName:@"streamhost"] retain]; + + // Configure everything else + [self performPostInitSetup]; + } + return self; +} + +/** + * Common initialization tasks shared by all init methods. +**/ +- (void)performPostInitSetup +{ + // Create dispatch queue. + + turnQueue = dispatch_queue_create("TURNSocket", NULL); + + // We want to add this new turn socket to the list of existing sockets. + // This gives us a central repository of turn socket objects that we can easily query. + + @synchronized(existingTurnSockets) + { + [existingTurnSockets setObject:self forKey:uuid]; + } +} + +/** + * Standard deconstructor. + * Release any objects we may have retained. + * These objects should all be defined in the header. +**/ +- (void)dealloc +{ + XMPPLogTrace(); + + if ((state > STATE_INIT) && (state < STATE_DONE)) + { + XMPPLogWarn(@"%@: Deallocating prior to completion or cancellation. " + @"You should explicitly cancel before releasing.", THIS_FILE); + } + + if (turnQueue) + dispatch_release(turnQueue); + + [xmppStream release]; + [jid release]; + [uuid release]; + + if (delegateQueue) + dispatch_release(delegateQueue); + + if (turnTimer) + { + dispatch_source_cancel(turnTimer); + dispatch_release(turnTimer); + } + + [discoUUID release]; + if (discoTimer) + { + dispatch_source_cancel(discoTimer); + dispatch_release(discoTimer); + } + + [proxyCandidates release]; + [candidateJIDs release]; + [streamhosts release]; + [proxyJID release]; + [proxyHost release]; + + if ([asyncSocket delegate] == self) + { + [asyncSocket setDelegate:nil delegateQueue:NULL]; + [asyncSocket disconnect]; + } + [asyncSocket release]; + + [startTime release]; + [finishTime release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Correspondence Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Starts the TURNSocket with the given delegate. + * If the TURNSocket has already been started, this method does nothing, and the existing delegate is not changed. +**/ +- (void)startWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)aDelegateQueue +{ + NSParameterAssert(aDelegate != nil); + NSParameterAssert(aDelegateQueue != NULL); + + dispatch_async(turnQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (state != STATE_INIT) + { + XMPPLogWarn(@"%@: Ignoring start request. Turn procedure already started.", THIS_FILE); + return; + } + + // Set reference to delegate and delegate's queue. + // Note that we do NOT retain the delegate. + + delegate = aDelegate; + + delegateQueue = aDelegateQueue; + dispatch_retain(delegateQueue); + + // Add self as xmpp delegate so we'll get message responses + [xmppStream addDelegate:self delegateQueue:turnQueue]; + + // Start the timer to calculate how long the procedure takes + startTime = [[NSDate alloc] init]; + + // Schedule timer to cancel the turn procedure. + // This ensures that, in the event of network error or crash, + // the TURNSocket object won't remain in memory forever, and will eventually fail. + + turnTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, turnQueue); + + dispatch_source_set_event_handler(turnTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self doTotalTimeout]; + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (TIMEOUT_TOTAL * NSEC_PER_SEC)); + + dispatch_source_set_timer(turnTimer, tt, DISPATCH_TIME_FOREVER, 0.1); + dispatch_resume(turnTimer); + + // Start the TURN procedure + + if (isClient) + [self queryProxyCandidates]; + else + [self targetConnect]; + + [pool drain]; + }); +} + +/** + * Returns the type of connection + * YES for a client connection to a server, NO for a server connection from a client. +**/ +- (BOOL)isClient +{ + // Note: The isClient variable is readonly (set in the init method). + + return isClient; +} + +/** + * Aborts the TURN connection attempt. + * The status will be changed to failure, and no delegate messages will be posted. +**/ +- (void)abort +{ + dispatch_block_t block = ^{ + + if ((state > STATE_INIT) && (state < STATE_DONE)) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // The only thing we really have to do here is move the state to failure. + // This simple act should prevent any further action from being taken in this TUNRSocket object, + // since every action is dictated based on the current state. + state = STATE_FAILURE; + + // And don't forget to cleanup after ourselves + [self cleanup]; + + [pool drain]; + } + }; + + if (dispatch_get_current_queue() == turnQueue) + block(); + else + dispatch_async(turnQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Communication +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Sends the request, from initiator to target, to start a connection to one of the streamhosts. + * This method automatically updates the state. +**/ +- (void)sendRequest +{ + NSAssert(isClient, @"Only the Initiator sends the request"); + + XMPPLogTrace(); + + // + // + // + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + [query addAttributeWithName:@"sid" stringValue:uuid]; + [query addAttributeWithName:@"mode" stringValue:@"tcp"]; + + NSUInteger i; + for(i = 0; i < [streamhosts count]; i++) + { + [query addChild:[streamhosts objectAtIndex:i]]; + } + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:jid elementID:uuid child:query]; + + [xmppStream sendElement:iq]; + + // Update state + state = STATE_REQUEST_SENT; +} + +/** + * Sends the reply, from target to initiator, notifying the initiator of the streamhost we connected to. +**/ +- (void)sendReply +{ + NSAssert(!isClient, @"Only the Target sends the reply"); + + XMPPLogTrace(); + + // + // + // + // + // + + NSXMLElement *streamhostUsed = [NSXMLElement elementWithName:@"streamhost-used"]; + [streamhostUsed addAttributeWithName:@"jid" stringValue:[proxyJID full]]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + [query addAttributeWithName:@"sid" stringValue:uuid]; + [query addChild:streamhostUsed]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"result" to:jid elementID:uuid child:query]; + + [xmppStream sendElement:iq]; +} + +/** + * Sends the activate message to the proxy after the target and initiator are both connected to the proxy. + * This method automatically updates the state. +**/ +- (void)sendActivate +{ + NSAssert(isClient, @"Only the Initiator activates the proxy"); + + XMPPLogTrace(); + + NSXMLElement *activate = [NSXMLElement elementWithName:@"activate" stringValue:[jid full]]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + [query addAttributeWithName:@"sid" stringValue:uuid]; + [query addChild:activate]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"set" to:proxyJID elementID:uuid child:query]; + + [xmppStream sendElement:iq]; + + // Update state + state = STATE_ACTIVATE_SENT; +} + +/** + * Sends the error, from target to initiator, notifying the initiator we were unable to connect to any streamhost. +**/ +- (void)sendError +{ + NSAssert(!isClient, @"Only the Target sends the error"); + + XMPPLogTrace(); + + // + // + // + // + // + + NSXMLElement *inf = [NSXMLElement elementWithName:@"item-not-found" xmlns:@"urn:ietf:params:xml:ns:xmpp-stanzas"]; + + NSXMLElement *error = [NSXMLElement elementWithName:@"error"]; + [error addAttributeWithName:@"code" stringValue:@"404"]; + [error addAttributeWithName:@"type" stringValue:@"cancel"]; + [error addChild:inf]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"error" to:jid elementID:uuid child:error]; + + [xmppStream sendElement:iq]; +} + +/** + * Invoked by XMPPClient when an IQ is received. + * We can determine if the IQ applies to us by checking its element ID. +**/ +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // Disco queries (sent to jabber server) use id=discoUUID + // P2P queries (sent to other Mojo app) use id=uuid + + if (state <= STATE_PROXY_DISCO_ADDR) + { + if (![discoUUID isEqualToString:[iq elementID]]) + { + // Doesn't apply to us, or is a delayed response that we've decided to ignore + return NO; + } + } + else + { + if (![uuid isEqualToString:[iq elementID]]) + { + // Doesn't apply to us + return NO; + } + } + + XMPPLogTrace2(@"%@: %@ - state(%i)", THIS_FILE, THIS_METHOD, state); + + if (state == STATE_PROXY_DISCO_ITEMS) + { + [self processDiscoItemsResponse:iq]; + } + else if (state == STATE_PROXY_DISCO_INFO) + { + [self processDiscoInfoResponse:iq]; + } + else if (state == STATE_PROXY_DISCO_ADDR) + { + [self processDiscoAddressResponse:iq]; + } + else if (state == STATE_REQUEST_SENT) + { + [self processRequestResponse:iq]; + } + else if (state == STATE_ACTIVATE_SENT) + { + [self processActivateResponse:iq]; + } + + return YES; +} + +- (void)processDiscoItemsResponse:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + // We queried the current proxy candidate for all known JIDs in it's disco list. + // + // + // + // + // + // + // + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/disco#items"]; + NSArray *items = [query elementsForName:@"item"]; + + [candidateJIDs release]; + candidateJIDs = [[NSMutableArray alloc] initWithCapacity:[items count]]; + + NSUInteger i; + for(i = 0; i < [items count]; i++) + { + NSString *itemJidStr = [[[items objectAtIndex:i] attributeForName:@"jid"] stringValue]; + XMPPJID *itemJid = [XMPPJID jidWithString:itemJidStr]; + + if(itemJid) + { + [candidateJIDs addObject:itemJid]; + } + } + + [self queryCandidateJIDs]; +} + +- (void)processDiscoInfoResponse:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + // We queried a potential proxy server to see if it was indeed a proxy. + // + // + // + // + // + // + // + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/disco#info"]; + NSArray *identities = [query elementsForName:@"identity"]; + + BOOL found = NO; + + NSUInteger i; + for(i = 0; i < [identities count] && !found; i++) + { + NSXMLElement *identity = [identities objectAtIndex:i]; + + NSString *category = [[identity attributeForName:@"category"] stringValue]; + NSString *type = [[identity attributeForName:@"type"] stringValue]; + + if([category isEqualToString:@"proxy"] && [type isEqualToString:@"bytestreams"]) + { + found = YES; + } + } + + if(found) + { + // We found a proxy service! + // Now we query the proxy for its public IP and port. + [self queryProxyAddress]; + } + else + { + // There are many jabber servers out there that advertise a proxy service via JID proxy.domain.tld. + // However, not all of these servers have an entry for proxy.domain.tld in the DNS servers. + // Thus, when we try to query the proxy JID, we end up getting a 404 error because our + // jabber server was unable to connect to the given JID. + // + // We could ignore the 404 error, and try to connect anyways, + // but this would be useless because we'd be unable to activate the stream later. + + XMPPJID *candidateJID = [candidateJIDs objectAtIndex:candidateJIDIndex]; + + // So the service was not a useable proxy service, or will not allow us to use its proxy. + // + // Now most servers have serveral services such as proxy, conference, pubsub, etc. + // If we queried a JID that started with "proxy", and it said no, + // chances are that none of the other services are proxies either, + // so we might as well not waste our time querying them. + + if([[candidateJID domain] hasPrefix:@"proxy"]) + { + // Move on to the next server + [self queryNextProxyCandidate]; + } + else + { + // Try the next JID in the list from the server + [self queryNextCandidateJID]; + } + } +} + +- (void)processDiscoAddressResponse:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + // We queried a proxy for its public IP and port. + // + // + // + // + // + // + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + NSXMLElement *streamhost = [query elementForName:@"streamhost"]; + + NSString *jidStr = [[streamhost attributeForName:@"jid"] stringValue]; + XMPPJID *streamhostJID = [XMPPJID jidWithString:jidStr]; + + NSString *host = [[streamhost attributeForName:@"host"] stringValue]; + UInt16 port = [[[streamhost attributeForName:@"port"] stringValue] intValue]; + + if(streamhostJID != nil || host != nil || port > 0) + { + [streamhost detach]; + [streamhosts addObject:streamhost]; + } + + // Finished with the current proxy candidate - move on to the next + [self queryNextProxyCandidate]; +} + +- (void)processRequestResponse:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + // Target has replied - hopefully they've been able to connect to one of the streamhosts + + NSXMLElement *query = [iq elementForName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + NSXMLElement *streamhostUsed = [query elementForName:@"streamhost-used"]; + + NSString *streamhostUsedJID = [[streamhostUsed attributeForName:@"jid"] stringValue]; + + BOOL found = NO; + NSUInteger i; + for(i = 0; i < [streamhosts count] && !found; i++) + { + NSXMLElement *streamhost = [streamhosts objectAtIndex:i]; + + NSString *streamhostJID = [[streamhost attributeForName:@"jid"] stringValue]; + + if([streamhostJID isEqualToString:streamhostUsedJID]) + { + NSAssert(proxyJID == nil && proxyHost == nil, @"proxy and proxyHost are expected to be nil"); + + proxyJID = [[XMPPJID jidWithString:streamhostJID] retain]; + + proxyHost = [[streamhost attributeForName:@"host"] stringValue]; + if([proxyHost isEqualToString:@"0.0.0.0"]) + { + proxyHost = [proxyJID full]; + } + [proxyHost retain]; + + proxyPort = [[[streamhost attributeForName:@"port"] stringValue] intValue]; + + found = YES; + } + } + + if(found) + { + // The target is connected to the proxy + // Now it's our turn to connect + [self initiatorConnect]; + } + else + { + // Target was unable to connect to any of the streamhosts we sent it + [self fail]; + } +} + +- (void)processActivateResponse:(XMPPIQ *)iq +{ + XMPPLogTrace(); + + NSString *type = [[iq attributeForName:@"type"] stringValue]; + + BOOL activated = NO; + if (type) + { + activated = [type caseInsensitiveCompare:@"result"] == NSOrderedSame; + } + + if (activated) { + [self succeed]; + } + else { + [self fail]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Proxy Discovery +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Each query we send during the proxy discovery process has a different element id. + * This allows us to easily use timeouts, so we can recover from offline servers, and overly slow servers. + * In other words, changing the discoUUID allows us to easily ignore delayed responses from a server. +**/ +- (void)updateDiscoUUID +{ + [discoUUID release]; + discoUUID = [[xmppStream generateUUID] retain]; +} + +/** + * Initiates the process of querying each item in the proxyCandidates array to determine if it supports XEP-65. + * In order to do this we have to: + * - ask the server for a list of services, which returns a list of JIDs + * - query each service JID to determine if it's a proxy + * - if it is a proxy, we ask the proxy for it's public IP and port +**/ +- (void)queryProxyCandidates +{ + XMPPLogTrace(); + + // Prepare the streamhosts array, which will hold all of our results + streamhosts = [[NSMutableArray alloc] initWithCapacity:[proxyCandidates count]]; + + // Start querying each candidate in order + proxyCandidateIndex = -1; + [self queryNextProxyCandidate]; +} + +/** + * Queries the next proxy candidate in the list. + * If we've queried every candidate, then sends the request to the target, or fails if no proxies were found. +**/ +- (void)queryNextProxyCandidate +{ + XMPPLogTrace(); + + // Update state + state = STATE_PROXY_DISCO_ITEMS; + + // We start off with multiple proxy candidates (servers that have been known to be proxy servers in the past). + // We can stop when we've found at least 2 proxies. + + XMPPJID *proxyCandidateJID = nil; + + if ([streamhosts count] < 2) + { + while ((proxyCandidateJID == nil) && (++proxyCandidateIndex < [proxyCandidates count])) + { + NSString *proxyCandidate = [proxyCandidates objectAtIndex:proxyCandidateIndex]; + proxyCandidateJID = [XMPPJID jidWithString:proxyCandidate]; + + if (proxyCandidateJID == nil) + { + XMPPLogWarn(@"%@: Invalid proxy candidate '%@', not a valid JID", THIS_FILE, proxyCandidate); + } + } + } + + if (proxyCandidateJID) + { + [self updateDiscoUUID]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/disco#items"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:proxyCandidateJID elementID:discoUUID child:query]; + + [xmppStream sendElement:iq]; + + [self setupDiscoTimerForDiscoItems]; + } + else + { + if ([streamhosts count] > 0) + { + // We've got a list of potential proxy servers to send to the initiator + + XMPPLogVerbose(@"%@: Streamhosts: \n%@", THIS_FILE, streamhosts); + + [self sendRequest]; + } + else + { + // We were unable to find a single proxy server from our list + + XMPPLogVerbose(@"%@: No proxies found", THIS_FILE); + + [self fail]; + } + } +} + +/** + * Initiates the process of querying each candidate JID to determine if it represents a proxy service. + * This process will be stopped when a proxy service is found, or after each candidate JID has been queried. +**/ +- (void)queryCandidateJIDs +{ + XMPPLogTrace(); + + // Most of the time, the proxy will have a domain name that includes the word "proxy". + // We can speed up the process of discovering the proxy by searching for these domains, and querying them first. + + NSUInteger i; + for (i = 0; i < [candidateJIDs count]; i++) + { + XMPPJID *candidateJID = [candidateJIDs objectAtIndex:i]; + + NSRange proxyRange = [[candidateJID domain] rangeOfString:@"proxy" options:NSCaseInsensitiveSearch]; + + if (proxyRange.length > 0) + { + [candidateJID retain]; + [candidateJIDs removeObjectAtIndex:i]; + [candidateJIDs insertObject:candidateJID atIndex:0]; + [candidateJID release]; + } + } + + XMPPLogVerbose(@"%@: CandidateJIDs: \n%@", THIS_FILE, candidateJIDs); + + // Start querying each candidate in order (we can stop when we find one) + candidateJIDIndex = -1; + [self queryNextCandidateJID]; +} + +/** + * Queries the next candidate JID in the list. + * If we've queried every item, we move on to the next proxy candidate. +**/ +- (void)queryNextCandidateJID +{ + XMPPLogTrace(); + + // Update state + state = STATE_PROXY_DISCO_INFO; + + candidateJIDIndex++; + if (candidateJIDIndex < [candidateJIDs count]) + { + [self updateDiscoUUID]; + + XMPPJID *candidateJID = [candidateJIDs objectAtIndex:candidateJIDIndex]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/disco#info"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:candidateJID elementID:discoUUID child:query]; + + [xmppStream sendElement:iq]; + + [self setupDiscoTimerForDiscoInfo]; + } + else + { + // Ran out of candidate JIDs for the current proxy candidate. + // Time to move on to the next proxy candidate. + [self queryNextProxyCandidate]; + } +} + +/** + * Once we've discovered a proxy service, we need to query it to obtain its public IP and port. +**/ +- (void)queryProxyAddress +{ + XMPPLogTrace(); + + // Update state + state = STATE_PROXY_DISCO_ADDR; + + [self updateDiscoUUID]; + + XMPPJID *candidateJID = [candidateJIDs objectAtIndex:candidateJIDIndex]; + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/bytestreams"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:candidateJID elementID:discoUUID child:query]; + + [xmppStream sendElement:iq]; + + [self setupDiscoTimerForDiscoAddress]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Proxy Connection +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)targetConnect +{ + XMPPLogTrace(); + + // Update state + state = STATE_TARGET_CONNECT; + + // Start trying to connect to each streamhost in order + streamhostIndex = -1; + [self targetNextConnect]; +} + +- (void)targetNextConnect +{ + XMPPLogTrace(); + + streamhostIndex++; + if(streamhostIndex < [streamhosts count]) + { + NSXMLElement *streamhost = [streamhosts objectAtIndex:streamhostIndex]; + + [proxyJID release]; + [proxyHost release]; + + proxyJID = [[XMPPJID jidWithString:[[streamhost attributeForName:@"jid"] stringValue]] retain]; + + proxyHost = [[streamhost attributeForName:@"host"] stringValue]; + if([proxyHost isEqualToString:@"0.0.0.0"]) + { + proxyHost = [proxyJID full]; + } + [proxyHost retain]; + + proxyPort = [[[streamhost attributeForName:@"port"] stringValue] intValue]; + + NSAssert([asyncSocket isDisconnected], @"Expecting the socket to be disconnected at this point..."); + + if (asyncSocket == nil) + { + asyncSocket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:turnQueue]; + } + + XMPPLogVerbose(@"TURNSocket: targetNextConnect: %@(%@:%hu)", [proxyJID full], proxyHost, proxyPort); + + NSError *err = nil; + if (![asyncSocket connectToHost:proxyHost onPort:proxyPort withTimeout:TIMEOUT_CONNECT error:&err]) + { + XMPPLogError(@"TURNSocket: targetNextConnect: err: %@", err); + [self targetNextConnect]; + } + } + else + { + [self sendError]; + [self fail]; + } +} + +- (void)initiatorConnect +{ + NSAssert(asyncSocket == nil, @"Expecting asyncSocket to be nil"); + + asyncSocket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:turnQueue]; + + XMPPLogVerbose(@"TURNSocket: initiatorConnect: %@(%@:%hu)", [proxyJID full], proxyHost, proxyPort); + + NSError *err = nil; + if (![asyncSocket connectToHost:proxyHost onPort:proxyPort withTimeout:TIMEOUT_CONNECT error:&err]) + { + XMPPLogError(@"TURNSocket: initiatorConnect: err: %@", err); + [self fail]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark SOCKS +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Sends the SOCKS5 open/handshake/authentication data, and starts reading the response. + * We attempt to gain anonymous access (no authentication). +**/ +- (void)socksOpen +{ + XMPPLogTrace(); + + // +-----+-----------+---------+ + // NAME | VER | NMETHODS | METHODS | + // +-----+-----------+---------+ + // SIZE | 1 | 1 | 1 - 255 | + // +-----+-----------+---------+ + // + // Note: Size is in bytes + // + // Version = 5 (for SOCKS5) + // NumMethods = 1 + // Method = 0 (No authentication, anonymous access) + + void *byteBuffer = malloc(3); + + UInt8 ver = 5; + memcpy(byteBuffer+0, &ver, sizeof(ver)); + + UInt8 nMethods = 1; + memcpy(byteBuffer+1, &nMethods, sizeof(nMethods)); + + UInt8 method = 0; + memcpy(byteBuffer+2, &method, sizeof(method)); + + NSData *data = [NSData dataWithBytesNoCopy:byteBuffer length:3 freeWhenDone:YES]; + XMPPLogVerbose(@"TURNSocket: SOCKS_OPEN: %@", data); + + [asyncSocket writeData:data withTimeout:-1 tag:SOCKS_OPEN]; + + // +-----+--------+ + // NAME | VER | METHOD | + // +-----+--------+ + // SIZE | 1 | 1 | + // +-----+--------+ + // + // Note: Size is in bytes + // + // Version = 5 (for SOCKS5) + // Method = 0 (No authentication, anonymous access) + + [asyncSocket readDataToLength:2 withTimeout:TIMEOUT_READ tag:SOCKS_OPEN]; +} + +/** + * Sends the SOCKS5 connect data (according to XEP-65), and starts reading the response. +**/ +- (void)socksConnect +{ + XMPPLogTrace(); + + XMPPJID *myJID = [xmppStream myJID]; + + // From XEP-0065: + // + // The [address] MUST be SHA1(SID + Initiator JID + Target JID) and + // the output is hexadecimal encoded (not binary). + + XMPPJID *initiatorJID = isClient ? myJID : jid; + XMPPJID *targetJID = isClient ? jid : myJID; + + NSString *hashMe = [NSString stringWithFormat:@"%@%@%@", uuid, [initiatorJID full], [targetJID full]]; + NSData *hashRaw = [[hashMe dataUsingEncoding:NSUTF8StringEncoding] sha1Digest]; + NSData *hash = [[hashRaw hexStringValue] dataUsingEncoding:NSUTF8StringEncoding]; + + XMPPLogVerbose(@"TURNSocket: hashMe : %@", hashMe); + XMPPLogVerbose(@"TURNSocket: hashRaw: %@", hashRaw); + XMPPLogVerbose(@"TURNSocket: hash : %@", hash); + + // +-----+-----+-----+------+------+------+ + // NAME | VER | CMD | RSV | ATYP | ADDR | PORT | + // +-----+-----+-----+------+------+------+ + // SIZE | 1 | 1 | 1 | 1 | var | 2 | + // +-----+-----+-----+------+------+------+ + // + // Note: Size is in bytes + // + // Version = 5 (for SOCKS5) + // Command = 1 (for Connect) + // Reserved = 0 + // Address Type = 3 (1=IPv4, 3=DomainName 4=IPv6) + // Address = P:D (P=LengthOfDomain D=DomainWithoutNullTermination) + // Port = 0 + + uint byteBufferLength = 4 + 1 + [hash length] + 2; + void *byteBuffer = malloc(byteBufferLength); + + UInt8 ver = 5; + memcpy(byteBuffer+0, &ver, sizeof(ver)); + + UInt8 cmd = 1; + memcpy(byteBuffer+1, &cmd, sizeof(cmd)); + + UInt8 rsv = 0; + memcpy(byteBuffer+2, &rsv, sizeof(rsv)); + + UInt8 atyp = 3; + memcpy(byteBuffer+3, &atyp, sizeof(atyp)); + + UInt8 hashLength = [hash length]; + memcpy(byteBuffer+4, &hashLength, sizeof(hashLength)); + + memcpy(byteBuffer+5, [hash bytes], [hash length]); + + UInt16 port = 0; + memcpy(byteBuffer+5+[hash length], &port, sizeof(port)); + + NSData *data = [NSData dataWithBytesNoCopy:byteBuffer length:byteBufferLength freeWhenDone:YES]; + XMPPLogVerbose(@"TURNSocket: SOCKS_CONNECT: %@", data); + + [asyncSocket writeData:data withTimeout:-1 tag:SOCKS_CONNECT]; + + // +-----+-----+-----+------+------+------+ + // NAME | VER | REP | RSV | ATYP | ADDR | PORT | + // +-----+-----+-----+------+------+------+ + // SIZE | 1 | 1 | 1 | 1 | var | 2 | + // +-----+-----+-----+------+------+------+ + // + // Note: Size is in bytes + // + // Version = 5 (for SOCKS5) + // Reply = 0 (0=Succeeded, X=ErrorCode) + // Reserved = 0 + // Address Type = 3 (1=IPv4, 3=DomainName 4=IPv6) + // Address = P:D (P=LengthOfDomain D=DomainWithoutNullTermination) + // Port = 0 + // + // It is expected that the SOCKS server will return the same address given in the connect request. + // But according to XEP-65 this is only marked as a SHOULD and not a MUST. + // So just in case, we'll read up to the address length now, and then read in the address+port next. + + [asyncSocket readDataToLength:5 withTimeout:TIMEOUT_READ tag:SOCKS_CONNECT_REPLY_1]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark AsyncSocket Delegate Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port +{ + XMPPLogTrace(); + + // Start the SOCKS protocol stuff + [self socksOpen]; +} + +- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag +{ + XMPPLogTrace(); + + if (tag == SOCKS_OPEN) + { + // See socksOpen method for socks reply format + + UInt8 ver = [NSNumber extractUInt8FromData:data atOffset:0]; + UInt8 mtd = [NSNumber extractUInt8FromData:data atOffset:1]; + + XMPPLogVerbose(@"TURNSocket: SOCKS_OPEN: ver(%o) mtd(%o)", ver, mtd); + + if(ver == 5 && mtd == 0) + { + [self socksConnect]; + } + else + { + // Some kind of error occurred. + // The proxy probably requires some kind of authentication. + [asyncSocket disconnect]; + } + } + else if (tag == SOCKS_CONNECT_REPLY_1) + { + // See socksConnect method for socks reply format + + XMPPLogVerbose(@"TURNSocket: SOCKS_CONNECT_REPLY_1: %@", data); + + UInt8 ver = [NSNumber extractUInt8FromData:data atOffset:0]; + UInt8 rep = [NSNumber extractUInt8FromData:data atOffset:1]; + + XMPPLogVerbose(@"TURNSocket: SOCKS_CONNECT_REPLY_1: ver(%o) rep(%o)", ver, rep); + + if(ver == 5 && rep == 0) + { + // We read in 5 bytes which we expect to be: + // 0: ver = 5 + // 1: rep = 0 + // 2: rsv = 0 + // 3: atyp = 3 + // 4: size = size of addr field + // + // However, some servers don't follow the protocol, and send a atyp value of 0. + + UInt8 atyp = [NSNumber extractUInt8FromData:data atOffset:3]; + + if (atyp == 3) + { + UInt8 addrLength = [NSNumber extractUInt8FromData:data atOffset:4]; + UInt8 portLength = 2; + + XMPPLogVerbose(@"TURNSocket: addrLength: %o", addrLength); + XMPPLogVerbose(@"TURNSocket: portLength: %o", portLength); + + [asyncSocket readDataToLength:(addrLength+portLength) + withTimeout:TIMEOUT_READ + tag:SOCKS_CONNECT_REPLY_2]; + } + else if (atyp == 0) + { + // The size field was actually the first byte of the port field + // We just have to read in that last byte + [asyncSocket readDataToLength:1 withTimeout:TIMEOUT_READ tag:SOCKS_CONNECT_REPLY_2]; + } + else + { + XMPPLogError(@"TURNSocket: Unknown atyp field in connect reply"); + [asyncSocket disconnect]; + } + } + else + { + // Some kind of error occurred. + [asyncSocket disconnect]; + } + } + else if (tag == SOCKS_CONNECT_REPLY_2) + { + // See socksConnect method for socks reply format + + XMPPLogVerbose(@"TURNSocket: SOCKS_CONNECT_REPLY_2: %@", data); + + if (isClient) + { + [self sendActivate]; + } + else + { + [self sendReply]; + [self succeed]; + } + } +} + +- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err +{ + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, err); + + if (state == STATE_TARGET_CONNECT) + { + [self targetNextConnect]; + } + else if (state == STATE_INITIATOR_CONNECT) + { + [self fail]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Timeouts +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setupDiscoTimer:(NSTimeInterval)timeout +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + if (discoTimer == NULL) + { + discoTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, turnQueue); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(discoTimer, tt, DISPATCH_TIME_FOREVER, 0.1); + dispatch_resume(discoTimer); + } + else + { + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(discoTimer, tt, DISPATCH_TIME_FOREVER, 0.1); + } +} + +- (void)setupDiscoTimerForDiscoItems +{ + XMPPLogTrace(); + + [self setupDiscoTimer:TIMEOUT_DISCO_ITEMS]; + + NSString *theUUID = discoUUID; + + dispatch_source_set_event_handler(discoTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self doDiscoItemsTimeout:theUUID]; + [pool drain]; + }); +} + +- (void)setupDiscoTimerForDiscoInfo +{ + XMPPLogTrace(); + + [self setupDiscoTimer:TIMEOUT_DISCO_INFO]; + + NSString *theUUID = discoUUID; + + dispatch_source_set_event_handler(discoTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self doDiscoInfoTimeout:theUUID]; + [pool drain]; + }); +} + +- (void)setupDiscoTimerForDiscoAddress +{ + XMPPLogTrace(); + + [self setupDiscoTimer:TIMEOUT_DISCO_ADDR]; + + NSString *theUUID = discoUUID; + + dispatch_source_set_event_handler(discoTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self doDiscoAddressTimeout:theUUID]; + [pool drain]; + }); +} + +- (void)doDiscoItemsTimeout:(NSString *)theUUID +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + if (state == STATE_PROXY_DISCO_ITEMS) + { + if ([theUUID isEqualToString:discoUUID]) + { + XMPPLogTrace(); + + // Server isn't responding - server may be offline + [self queryNextProxyCandidate]; + } + } +} + +- (void)doDiscoInfoTimeout:(NSString *)theUUID +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + if (state == STATE_PROXY_DISCO_INFO) + { + if ([theUUID isEqualToString:discoUUID]) + { + XMPPLogTrace(); + + // Move on to the next proxy candidate + [self queryNextProxyCandidate]; + } + } +} + +- (void)doDiscoAddressTimeout:(NSString *)theUUID +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + if (state == STATE_PROXY_DISCO_ADDR) + { + if ([theUUID isEqualToString:discoUUID]) + { + XMPPLogTrace(); + + // Server is taking a long time to respond to a simple query. + // We could jump to the next candidate JID, but we'll take this as a sign of an overloaded server. + [self queryNextProxyCandidate]; + } + } +} + +- (void)doTotalTimeout +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + if ((state != STATE_DONE) && (state != STATE_FAILURE)) + { + XMPPLogTrace(); + + // A timeout occured to cancel the entire TURN procedure. + // This probably means the other endpoint crashed, or a network error occurred. + // In either case, we can consider this a failure, and recycle the memory associated with this object. + + [self fail]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Finish and Cleanup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)succeed +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Record finish time + finishTime = [[NSDate alloc] init]; + + // Update state + state = STATE_DONE; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ([delegate respondsToSelector:@selector(turnSocket:didSucceed:)]) + { + [delegate turnSocket:self didSucceed:asyncSocket]; + } + + [pool drain]; + }); + + [self cleanup]; +} + +- (void)fail +{ + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Record finish time + finishTime = [[NSDate alloc] init]; + + // Update state + state = STATE_FAILURE; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ([delegate respondsToSelector:@selector(turnSocketDidFail:)]) + { + [delegate turnSocketDidFail:self]; + } + + [pool drain]; + }); + + [self cleanup]; +} + +- (void)cleanup +{ + // This method must be run on the turnQueue + NSAssert(dispatch_get_current_queue() == turnQueue, @"Invoked on incorrect queue."); + + XMPPLogTrace(); + + if (turnTimer) + { + dispatch_source_cancel(turnTimer); + dispatch_release(turnTimer); + turnTimer = NULL; + } + + if (discoTimer) + { + dispatch_source_cancel(discoTimer); + dispatch_release(discoTimer); + discoTimer = NULL; + } + + // Remove self as xmpp delegate + [xmppStream removeDelegate:self delegateQueue:turnQueue]; + + // Remove self from existingStuntSockets dictionary so we can be deallocated + @synchronized(existingTurnSockets) + { + [existingTurnSockets removeObjectForKey:uuid]; + } +} + +@end diff --git a/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.h b/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.h new file mode 100644 index 0000000..bc142d5 --- /dev/null +++ b/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.h @@ -0,0 +1,26 @@ +// +// NSDate+XMPPDateTimeProfiles.h +// +// NSDate category to implement XEP-0082. +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + +#import + +@interface NSDate(XMPPDateTimeProfiles) + + ++ (NSDate *)dateWithXmppDateString:(NSString *)str; ++ (NSDate *)dateWithXmppTimeString:(NSString *)str; ++ (NSDate *)dateWithXmppDateTimeString:(NSString *)str; + + +- (NSString *)xmppDateString; +- (NSString *)xmppTimeString; +- (NSString *)xmppDateTimeString; + + +@end diff --git a/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.m b/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.m new file mode 100644 index 0000000..546aa22 --- /dev/null +++ b/xmpp/Extensions/XEP-0082/NSDate+XMPPDateTimeProfiles.m @@ -0,0 +1,79 @@ +// +// NSDate+XMPPDateTimeProfiles.m +// +// NSDate category to implement XEP-0082. +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. +// Copyright 2010 Martin Morrison. All rights reserved. +// + +#import "NSDate+XMPPDateTimeProfiles.h" +#import "XMPPDateTimeProfiles.h" + + +@interface NSDate(XMPPDateTimeProfilesPrivate) +- (NSString *)xmppStringWithDateFormat:(NSString *)dateFormat; +@end + + +@implementation NSDate(XMPPDateTimeProfiles) + + +#pragma mark - +#pragma mark Convert from XMPP string to NSDate + + ++ (NSDate *)dateWithXmppDateString:(NSString *)str { + return [XMPPDateTimeProfiles parseDate:str]; +} + + ++ (NSDate *)dateWithXmppTimeString:(NSString *)str { + return [XMPPDateTimeProfiles parseTime:str]; +} + + ++ (NSDate *)dateWithXmppDateTimeString:(NSString *)str { + return [XMPPDateTimeProfiles parseDateTime:str]; +} + + +#pragma mark - +#pragma mark Convert from NSDate to XMPP string + + +- (NSString *)xmppDateString { + return [self xmppStringWithDateFormat:@"yyyy-MM-dd"]; +} + + +- (NSString *)xmppTimeString { + return [self xmppStringWithDateFormat:@"HH:mm:ss'Z'"]; +} + + +- (NSString *)xmppDateTimeString { + return [self xmppStringWithDateFormat:@"yyyy-MM-dd'T'HH:mm:ss'Z'"]; +} + + +#pragma mark - +#pragma mark XMPPDateTimeProfilesPrivate methods + + +- (NSString *)xmppStringWithDateFormat:(NSString *)dateFormat +{ + NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init]; + [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; + [dateFormatter setDateFormat:dateFormat]; + [dateFormatter setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]]; + + NSString *str = [dateFormatter stringFromDate:self]; + [dateFormatter release]; + + return str; +} + + +@end diff --git a/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.h b/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.h new file mode 100644 index 0000000..5a717e0 --- /dev/null +++ b/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.h @@ -0,0 +1,17 @@ +#import +#import "NSDate+XMPPDateTimeProfiles.h" + +@interface XMPPDateTimeProfiles : NSObject + +/** + * The following methods attempt to parse the given string following XEP-0082. + * They return nil if the given string doesn't follow the spec. +**/ + ++ (NSDate *)parseDate:(NSString *)dateStr; ++ (NSDate *)parseTime:(NSString *)timeStr; ++ (NSDate *)parseDateTime:(NSString *)dateTimeStr; + ++ (NSTimeZone *)parseTimeZoneOffset:(NSString *)tzo; + +@end diff --git a/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.m b/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.m new file mode 100644 index 0000000..3fa81be --- /dev/null +++ b/xmpp/Extensions/XEP-0082/XMPPDateTimeProfiles.m @@ -0,0 +1,293 @@ +#import "XMPPDateTimeProfiles.h" +#import "NSNumber+XMPP.h" + + +@interface XMPPDateTimeProfiles (PrivateAPI) ++ (NSDate *)parseDateTime:(NSString *)dateTimeStr withMandatoryTimeZone:(BOOL)mandatoryTZ; +@end + + +@implementation XMPPDateTimeProfiles + +/** + * The following acronyms and characters are used from XEP-0082 to represent time-related concepts: + * + * CCYY four-digit year portion of Date + * MM two-digit month portion of Date + * DD two-digit day portion of Date + * - ISO 8601 separator among Date portions + * T ISO 8601 separator between Date and Time + * hh two-digit hour portion of Time (00 through 23) + * mm two-digit minutes portion of Time (00 through 59) + * ss two-digit seconds portion of Time (00 through 59) + * : ISO 8601 separator among Time portions + * . ISO 8601 separator between seconds and milliseconds + * sss fractional second addendum to Time (MAY contain any number of digits) + * TZD Time Zone Definition (either "Z" for UTC or "(+|-)hh:mm" for a specific time zone) + * +**/ + ++ (NSDate *)parseDate:(NSString *)dateStr +{ + if ([dateStr length] < 10) return nil; + + // The Date profile defines a date without including the time of day. + // The lexical representation is as follows: + // + // CCYY-MM-DD + // + // Example: + // + // 1776-07-04 + + NSDateFormatter *df = [[NSDateFormatter alloc] init]; + [df setFormatterBehavior:NSDateFormatterBehavior10_4]; // Use unicode patterns (as opposed to 10_3) + [df setDateFormat:@"yyyy-MM-dd"]; + + NSDate *result = [df dateFromString:dateStr]; + + [df release]; + return result; +} + ++ (NSDate *)parseTime:(NSString *)timeStr +{ + // The Time profile is used to specify an instant of time that recurs (e.g., every day). + // The lexical representation is as follows: + // + // hh:mm:ss[.sss][TZD] + // + // The Time Zone Definition is optional; if included, it MUST be either UTC (denoted by addition + // of the character 'Z' to the end of the string) or some offset from UTC (denoted by addition + // of '[+|-]' and 'hh:mm' to the end of the string). + // + // Examples: + // + // 16:00:00 + // 16:00:00Z + // 16:00:00+07:00 + // 16:00:00.123 + // 16:00:00.123Z + // 16:00:00.123+07:00 + + + // Extract the current day so the result can be on the current day. + // Why do we bother doing this? + // + // First, it is rather intuitive. + // Second, if we don't we risk being on a date with a conflicting DST (daylight saving time). + // + // For example, -0800 instead of the current -0700. + // This can be rather confusing when printing the result. + + NSDateFormatter *df = [[NSDateFormatter alloc] init]; + [df setFormatterBehavior:NSDateFormatterBehavior10_4]; // Use unicode patterns (as opposed to 10_3) + [df setDateFormat:@"yyyy-MM-dd"]; + + NSString *today = [df stringFromDate:[NSDate date]]; + [df release]; + + NSString *dateTimeStr = [NSString stringWithFormat:@"%@T%@", today, timeStr]; + + return [self parseDateTime:dateTimeStr withMandatoryTimeZone:NO]; +} + ++ (NSDate *)parseDateTime:(NSString *)dateTimeStr +{ + // The DateTime profile is used to specify a non-recurring moment in time to an accuracy of seconds (or, + // optionally, fractions of a second). The format is as follows: + // + // CCYY-MM-DDThh:mm:ss[.sss]TZD + // + // The Time Zone Definition is mandatory and MUST be either UTC (denoted by addition of the character 'Z' + // to the end of the string) or some offset from UTC (denoted by addition of '[+|-]' and 'hh:mm' to the + // end of the string). + // + // Examples: + // + // 1969-07-21T02:56:15Z + // 1969-07-20T21:56:15-05:00 + // 1969-07-21T02:56:15.123Z + // 1969-07-20T21:56:15.123-05:00 + + return [self parseDateTime:dateTimeStr withMandatoryTimeZone:YES]; +} + ++ (NSDate *)parseDateTime:(NSString *)dateTimeStr withMandatoryTimeZone:(BOOL)mandatoryTZ +{ + if ([dateTimeStr length] < 19) return nil; + + // The DateTime profile is used to specify a non-recurring moment in time to an accuracy of seconds (or, + // optionally, fractions of a second). The format is as follows: + // + // CCYY-MM-DDThh:mm:ss[.sss]{TZD} + // + // Examples: + // + // 1969-07-21T02:56:15 + // 1969-07-21T02:56:15Z + // 1969-07-20T21:56:15-05:00 + // 1969-07-21T02:56:15.123 + // 1969-07-21T02:56:15.123Z + // 1969-07-20T21:56:15.123-05:00 + + BOOL hasMilliseconds = NO; + BOOL hasTimeZoneInfo = NO; + BOOL hasTimeZoneOffset = NO; + + if ([dateTimeStr length] > 19) + { + unichar c = [dateTimeStr characterAtIndex:19]; + + // Check for optional milliseconds + if (c == '.') + { + hasMilliseconds = YES; + + if ([dateTimeStr length] < 23) return nil; + + if ([dateTimeStr length] > 23) + { + c = [dateTimeStr characterAtIndex:23]; + } + } + + // Check for optional time zone info + if (c == 'Z') + { + hasTimeZoneInfo = YES; + hasTimeZoneOffset = NO; + } + else if (c == '+' || c == '-') + { + hasTimeZoneInfo = YES; + hasTimeZoneOffset = YES; + + if (hasMilliseconds) + { + if ([dateTimeStr length] < 29) return nil; + } + else + { + if ([dateTimeStr length] < 25) return nil; + } + } + } + + if (mandatoryTZ && !hasTimeZoneInfo) return nil; + + NSDateFormatter *df = [[NSDateFormatter alloc] init]; + [df setFormatterBehavior:NSDateFormatterBehavior10_4]; // Use unicode patterns (as opposed to 10_3) + + if (hasMilliseconds) + { + if (hasTimeZoneInfo) + { + if (hasTimeZoneOffset) + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss.SSS"]; // Offset calculated separately + else + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"]; + } + else + { + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss.SSS"]; + } + } + else if (hasTimeZoneInfo) + { + if (hasTimeZoneOffset) + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss"]; // Offset calculated separately + else + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss'Z'"]; + } + else + { + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss"]; + } + + NSDate *result; + + if (hasTimeZoneInfo && !hasTimeZoneOffset) + { + [df setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]]; + + result = [df dateFromString:dateTimeStr]; + } + else if (hasTimeZoneInfo && hasTimeZoneOffset) + { + NSString *dto; + NSString *tzo; + + if (hasMilliseconds) + { + dto = [dateTimeStr substringToIndex:23]; + tzo = [dateTimeStr substringFromIndex:23]; + } + else + { + dto = [dateTimeStr substringToIndex:19]; + tzo = [dateTimeStr substringFromIndex:19]; + } + + NSTimeZone *timeZone = [self parseTimeZoneOffset:tzo]; + if (timeZone == nil) + { + result = nil; + } + else + { + [df setTimeZone:timeZone]; + result = [df dateFromString:dto]; + } + } + else + { + result = [df dateFromString:dateTimeStr]; + } + + [df release]; + return result; +} + ++ (NSTimeZone *)parseTimeZoneOffset:(NSString *)tzo +{ + // The tzo value is supposed to start with '+' or '-'. + // Spec says: (+-)hh:mm + // + // hh : two-digit hour portion (00 through 23) + // mm : two-digit minutes portion (00 through 59) + + if ([tzo length] != 6) + { + return nil; + } + + NSString *hoursStr = [tzo substringWithRange:NSMakeRange(1, 2)]; + NSString *minutesStr = [tzo substringWithRange:NSMakeRange(4, 2)]; + + NSUInteger hours; + if (![NSNumber parseString:hoursStr intoNSUInteger:&hours]) + return nil; + + NSUInteger minutes; + if (![NSNumber parseString:minutesStr intoNSUInteger:&minutes]) + return nil; + + if (hours > 23) return nil; + if (minutes > 59) return nil; + + NSInteger secondsOffset = (NSInteger)((hours * 60 * 60) + (minutes * 60)); + + if ([tzo hasPrefix:@"-"]) + { + secondsOffset = -1 * secondsOffset; + } + else if (![tzo hasPrefix:@"+"]) + { + return nil; + } + + return [NSTimeZone timeZoneForSecondsFromGMT:secondsOffset]; +} + +@end diff --git a/xmpp/Extensions/XEP-0100/XMPPTransports.h b/xmpp/Extensions/XEP-0100/XMPPTransports.h new file mode 100644 index 0000000..31a0b46 --- /dev/null +++ b/xmpp/Extensions/XEP-0100/XMPPTransports.h @@ -0,0 +1,21 @@ +#import + +@class XMPPStream; + + +@interface XMPPTransports : NSObject +{ + XMPPStream *xmppStream; +} + +- (id)initWithStream:(XMPPStream *)xmppStream; + +@property (nonatomic, readonly) XMPPStream *xmppStream; + +- (void)queryGatewayDiscoveryIdentityForLegacyService:(NSString *)service; +- (void)queryGatewayAgentInfo; +- (void)queryRegistrationRequirementsForLegacyService:(NSString *)service; +- (void)registerLegacyService:(NSString *)service username:(NSString *)username password:(NSString *)password; +- (void)unregisterLegacyService:(NSString *)service; + +@end diff --git a/xmpp/Extensions/XEP-0100/XMPPTransports.m b/xmpp/Extensions/XEP-0100/XMPPTransports.m new file mode 100644 index 0000000..573fbeb --- /dev/null +++ b/xmpp/Extensions/XEP-0100/XMPPTransports.m @@ -0,0 +1,149 @@ +#import "XMPPTransports.h" +#import "XMPP.h" + + +@implementation XMPPTransports + +@synthesize xmppStream; + +- (id)initWithStream:(XMPPStream *)stream +{ + if ((self = [super init])) + { + xmppStream = [stream retain]; + } + return self; +} + +- (void)dealloc +{ + [xmppStream release]; + [super dealloc]; +} + +/** + * Registration process + * @see: http://www.xmpp.org/extensions/xep-0100.html#usecases-jabber-register-pri +**/ + +- (void)queryGatewayDiscoveryIdentityForLegacyService:(NSString *)service +{ + XMPPJID *myJID = xmppStream.myJID; + + NSString *toValue = [NSString stringWithFormat:@"%@.%@", service, [myJID domain]]; + + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"http://jabber.org/protocol/disco#info"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"get"]; + [iq addAttributeWithName:@"from" stringValue:[myJID full]]; + [iq addAttributeWithName:@"to" stringValue:toValue]; + [iq addAttributeWithName:@"id" stringValue:@"disco1"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +- (void)queryGatewayAgentInfo +{ + XMPPJID *myJID = xmppStream.myJID; + + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:agents"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"get"]; + [iq addAttributeWithName:@"from" stringValue:[myJID full]]; + [iq addAttributeWithName:@"to" stringValue:[myJID domain]]; + [iq addAttributeWithName:@"id" stringValue:@"agent1"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +- (void)queryRegistrationRequirementsForLegacyService:(NSString *)service +{ + XMPPJID *myJID = xmppStream.myJID; + + NSString *toValue = [NSString stringWithFormat:@"%@.%@", service, [myJID domain]]; + + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:register"]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"get"]; + [iq addAttributeWithName:@"from" stringValue:[myJID full]]; + [iq addAttributeWithName:@"to" stringValue:toValue]; + [iq addAttributeWithName:@"id" stringValue:@"reg1"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +- (void)registerLegacyService:(NSString *)service username:(NSString *)username password:(NSString *)password +{ + XMPPJID *myJID = xmppStream.myJID; + + NSString *toValue = [NSString stringWithFormat:@"%@.%@", service, [myJID domain]]; + + // + // + // username + // password + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:register"]; + [query addChild:[NSXMLElement elementWithName:@"username" stringValue:username]]; + [query addChild:[NSXMLElement elementWithName:@"password" stringValue:password]]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addAttributeWithName:@"from" stringValue:[myJID full]]; + [iq addAttributeWithName:@"to" stringValue:toValue]; + [iq addAttributeWithName:@"id" stringValue:@"reg2"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +/** + * Unregistration process + * @see: http://www.xmpp.org/extensions/xep-0100.html#usecases-jabber-unregister-pri +**/ +- (void)unregisterLegacyService:(NSString *)service +{ + XMPPJID *myJID = xmppStream.myJID; + + NSString *toValue = [NSString stringWithFormat:@"%@.%@", service, [myJID domain]]; + + // + // + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:@"jabber:iq:register"]; + [query addChild:[NSXMLElement elementWithName:@"remove"]]; + + NSXMLElement *iq = [NSXMLElement elementWithName:@"iq"]; + [iq addAttributeWithName:@"type" stringValue:@"set"]; + [iq addAttributeWithName:@"from" stringValue:[myJID full]]; + [iq addAttributeWithName:@"to" stringValue:toValue]; + [iq addAttributeWithName:@"id" stringValue:@"unreg1"]; + [iq addChild:query]; + + [xmppStream sendElement:iq]; +} + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/elements b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/elements new file mode 100644 index 0000000000000000000000000000000000000000..ad0de649ee6082856cbb200e91a9fb0d6a92a645 GIT binary patch literal 45046 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 literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/layout b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilities.xcdatamodel/layout new file mode 100644 index 0000000000000000000000000000000000000000..e2f28f0543d029cceb33811e5e54fe610680ad06 GIT binary patch literal 7630 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 Q0Vq9mSM0a*-{ji=0|gp+egFUf literal 0 HcmV?d00001 diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.h b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.h new file mode 100644 index 0000000..287d2d1 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.h @@ -0,0 +1,35 @@ +#import +#import + +#import "XMPPCapabilities.h" +#import "XMPPCoreDataStorage.h" + +/** + * This class is an example implementation of XMPPCapabilitiesStorage using core data. + * You are free to substitute your own storage class. +**/ + +@interface XMPPCapabilitiesCoreDataStorage : XMPPCoreDataStorage +{ + // Inherits protected variables from XMPPCoreDataStorage +} + +/** + * XEP-0115 provides a mechanism for hashing a list of capabilities. + * Clients then broadcast this hash instead of the entire list to save bandwidth. + * Because the hashing is standardized, it is safe to persistently store the linked hash & capabilities. + * + * For this reason, it is recommended you use this sharedInstance across all your xmppStreams. + * This way all streams can shared a knowledgebase concerning known hashes. + * + * All other aspects of capabilities handling (such as JID's, lookup failures, etc) are kept separate between streams. +**/ ++ (XMPPCapabilitiesCoreDataStorage *)sharedInstance; + +// +// This class inherits from XMPPCoreDataStorage. +// +// Please see the XMPPCoreDataStorage header file for more information. +// + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.m b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.m new file mode 100644 index 0000000..4cd6dad --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapabilitiesCoreDataStorage.m @@ -0,0 +1,603 @@ +#import "XMPPCapabilitiesCoreDataStorage.h" +#import "XMPPCapsCoreDataStorageObject.h" +#import "XMPPCapsResourceCoreDataStorageObject.h" +#import "XMPP.h" +#import "XMPPCoreDataStorageProtected.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@implementation XMPPCapabilitiesCoreDataStorage + +static XMPPCapabilitiesCoreDataStorage *sharedInstance; + ++ (XMPPCapabilitiesCoreDataStorage *)sharedInstance +{ + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + + sharedInstance = [[XMPPCapabilitiesCoreDataStorage alloc] initWithDatabaseFilename:nil]; + }); + + return sharedInstance; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Setup +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)configureWithParent:(XMPPCapabilities *)aParent queue:(dispatch_queue_t)queue +{ + return [super configureWithParent:aParent queue:queue]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (XMPPCapsResourceCoreDataStorageObject *)resourceForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, jid); + + if (jid == nil) return nil; + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPCapsResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSPredicate *predicate; + if (stream == nil) + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@", [jid full]]; + else + predicate = [NSPredicate predicateWithFormat:@"jidStr == %@ AND streamBareJidStr == %@", + [jid full], [[self myJIDForXMPPStream:stream] bare]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + XMPPCapsResourceCoreDataStorageObject *resource = [results lastObject]; + + XMPPLogVerbose(@"%@: %@ - %@", THIS_FILE, THIS_METHOD, resource); + return resource; +} + +- (XMPPCapsCoreDataStorageObject *)capsForHash:(NSString *)hash algorithm:(NSString *)hashAlg +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: capsForHash:%@ algorithm:%@", THIS_FILE, hash, hashAlg); + + if (hash == nil) return nil; + if (hashAlg == nil) return nil; + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPCapsCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSPredicate *predicate = [NSPredicate predicateWithFormat:@"hashStr == %@ AND hashAlgorithm == %@", + hash, hashAlg]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setFetchLimit:1]; + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + XMPPCapsCoreDataStorageObject *caps = [results lastObject]; + + XMPPLogVerbose(@"%@: %@ - %@", THIS_FILE, THIS_METHOD, caps); + return caps; +} + +- (void)_clearAllNonPersistentCapabilitiesForXMPPStream:(XMPPStream *)stream +{ + NSAssert(dispatch_get_current_queue() == storageQueue, @"Invoked on incorrect queue"); + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPCapsResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setFetchBatchSize:saveThreshold]; + + if (stream) + { + NSPredicate *predicate = [NSPredicate predicateWithFormat:@"streamBareJidStr == %@", + [[self myJIDForXMPPStream:stream] bare]]; + + [fetchRequest setPredicate:predicate]; + } + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + + for (XMPPCapsResourceCoreDataStorageObject *resource in results) + { + NSString *hash = resource.hashStr; + NSString *hashAlg = resource.hashAlgorithm; + + BOOL nonPersistentCapabilities = ((hash == nil) || (hashAlg == nil)); + + if (nonPersistentCapabilities) + { + XMPPCapsCoreDataStorageObject *caps = resource.caps; + if (caps) + { + [[self managedObjectContext] deleteObject:caps]; + } + } + + [[self managedObjectContext] deleteObject:resource]; + + if (++unsavedCount >= saveThreshold) + { + [self save]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Overrides +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)addPersistentStorePath:(NSString *)storePath error:(NSError **)error +{ + BOOL result = [super addPersistentStorePath:storePath error:error]; + + if (!result && + [*error code] == NSMigrationMissingSourceModelError && + [[*error domain] isEqualToString:NSCocoaErrorDomain]) { + // If we get this error while trying to add the persistent store, it most likely means the model changed. + // Since we are caching capabilities, it is safe to delete the persistent store and create a new one. + + if ([[NSFileManager defaultManager] fileExistsAtPath:storePath]) + { + [[NSFileManager defaultManager] removeItemAtPath:storePath error:nil]; + + // Try creating the store again, without creating a deletion/creation loop. + result = [super addPersistentStorePath:storePath error:error]; + } + } + + return result; +} + +- (void)didCreateManagedObjectContext +{ + // This method is overriden from the XMPPCoreDataStore superclass. + + [self _clearAllNonPersistentCapabilitiesForXMPPStream:nil]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Protocol Public API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)areCapabilitiesKnownForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + __block BOOL result; + + [self executeBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + result = (resource.caps != nil); + + }]; + + return result; +} + +- (NSXMLElement *)capabilitiesForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + return [self capabilitiesForJID:jid ext:nil xmppStream:stream]; +} + +- (NSXMLElement *)capabilitiesForJID:(XMPPJID *)jid ext:(NSString **)extPtr xmppStream:(XMPPStream *)stream +{ + // By design this method should not be invoked from the storageQueue. + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + __block NSXMLElement *result = nil; + __block NSString *ext = nil; + + [self executeBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + + if (resource) + { + result = [[[resource caps] capabilities] retain]; + ext = [[resource ext] retain]; + } + + }]; + + if (extPtr) + *extPtr = [ext autorelease]; + else + [ext release]; + + return [result autorelease]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Protocol Private API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)setCapabilitiesNode:(NSString *)node + ver:(NSString *)ver + ext:(NSString *)ext + hash:(NSString *)hash + algorithm:(NSString *)hashAlg + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream + andGetNewCapabilities:(NSXMLElement **)newCapabilitiesPtr +{ + + XMPPLogTrace(); + + __block BOOL result; + __block NSXMLElement *newCapabilities = nil; + + [self executeBlock:^{ + + BOOL hashChange = NO; + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + if (resource) + { + resource.node = node; + resource.ver = ver; + resource.ext = ext; + + if (![hash isEqual:[resource hashStr]]) + { + hashChange = YES; + resource.hashStr = hash; + } + + if (![hashAlg isEqual:[resource hashAlgorithm]]) + { + hashChange = YES; + resource.hashAlgorithm = hashAlg; + } + } + else + { + resource = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPCapsResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + resource.jidStr = [jid full]; + resource.streamBareJidStr = [[self myJIDForXMPPStream:stream] bare]; + + resource.node = node; + resource.ver = ver; + resource.ext = ext; + + resource.hashStr = hash; + resource.hashAlgorithm = hashAlg; + + hashChange = ((hash != nil) || (hashAlg != nil)); + } + + if (hashChange) + { + resource.caps = [self capsForHash:hash algorithm:hashAlg]; + + newCapabilities = [resource.caps.capabilities retain]; + } + + // Return whether or not the capabilities are known for the given jid + + result = (resource.caps != nil); + + }]; + + + if (newCapabilitiesPtr) + *newCapabilitiesPtr = [newCapabilities autorelease]; + else + [newCapabilities release]; + + return result; +} + +- (BOOL)getCapabilitiesHash:(NSString **)hashPtr + algorithm:(NSString **)hashAlgPtr + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream +{ + // By design this method should not be invoked from the storageQueue. + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + __block BOOL result; + __block NSString *hash; + __block NSString *hashAlg; + + [self executeBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + if (resource) + { + hash = [resource.hashStr retain]; + hashAlg = [resource.hashAlgorithm retain]; + + result = (hash && hashAlg); + } + else + { + hash = nil; + hashAlg = nil; + + result = NO; + } + + }]; + + + if (hashPtr) + *hashPtr = [hash autorelease]; + else + [hash release]; + + if (hashAlgPtr) + *hashAlgPtr = [hashAlg autorelease]; + else + [hashAlg release]; + + return result; +} + +- (void)clearCapabilitiesHashAndAlgorithmForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + if (resource) + { + BOOL clearCaps = NO; + + NSString *hash = resource.hashStr; + NSString *hashAlg = resource.hashAlgorithm; + + if (hash && hashAlg) + { + clearCaps = YES; + } + + resource.hashStr = nil; + resource.hashAlgorithm = nil; + + if (clearCaps) + { + resource.caps = nil; + } + } + + }]; +} + +- (void)getCapabilitiesKnown:(BOOL *)areCapabilitiesKnownPtr + failed:(BOOL *)haveFailedFetchingBeforePtr + node:(NSString **)nodePtr + ver:(NSString **)verPtr + ext:(NSString **)extPtr + hash:(NSString **)hashPtr + algorithm:(NSString **)hashAlgPtr + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream +{ + // By design this method should not be invoked from the storageQueue. + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + __block BOOL areCapabilitiesKnown; + __block BOOL haveFailedFetchingBefore; + __block NSString *node; + __block NSString *ver; + __block NSString *ext; + __block NSString *hash; + __block NSString *hashAlg; + + [self executeBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + + if (resource == nil) + { + // We don't know anything about the given jid + + areCapabilitiesKnown = NO; + haveFailedFetchingBefore = NO; + + node = nil; + ver = nil; + ext = nil; + hash = nil; + hashAlg = nil; + } + else + { + areCapabilitiesKnown = (resource.caps != nil); + haveFailedFetchingBefore = resource.haveFailed; + + node = [resource.node retain]; + ver = [resource.ver retain]; + ext = [resource.ext retain]; + hash = [resource.hashStr retain]; + hashAlg = [resource.hashAlgorithm retain]; + } + + }]; + + if (nodePtr) *nodePtr = [node autorelease]; else [node release]; + if (verPtr) *verPtr = [ver autorelease]; else [ver release]; + if (extPtr) *extPtr = [ext autorelease]; else [ext release]; + if (hashPtr) *hashPtr = [hash autorelease]; else [hash release]; + if (hashAlgPtr) *hashAlgPtr = [hashAlg autorelease]; else [hashAlg release]; +} + +- (void)setCapabilities:(NSXMLElement *)capabilities forHash:(NSString *)hash algorithm:(NSString *)hashAlg +{ + XMPPLogTrace(); + + if (hash == nil) return; + if (hashAlg == nil) return; + + [self scheduleBlock:^{ + + XMPPCapsCoreDataStorageObject *caps = [self capsForHash:hash algorithm:hashAlg]; + if (caps) + { + caps.capabilities = capabilities; + } + else + { + caps = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPCapsCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + caps.hashStr = hash; + caps.hashAlgorithm = hashAlg; + + caps.capabilities = capabilities; + } + + NSEntityDescription *entity = [NSEntityDescription entityForName:@"XMPPCapsResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + + NSPredicate *predicate; + predicate = [NSPredicate predicateWithFormat:@"hashStr == %@ AND hashAlgorithm == %@", hash, hashAlg]; + + NSFetchRequest *fetchRequest = [[[NSFetchRequest alloc] init] autorelease]; + [fetchRequest setEntity:entity]; + [fetchRequest setPredicate:predicate]; + [fetchRequest setFetchBatchSize:saveThreshold]; + + NSArray *results = [[self managedObjectContext] executeFetchRequest:fetchRequest error:nil]; + + NSUInteger unsavedCount = [self numberOfUnsavedChanges]; + + for (XMPPCapsResourceCoreDataStorageObject *resource in results) + { + resource.caps = caps; + + if (++unsavedCount >= saveThreshold) + { + [self save]; + } + } + + }]; +} + +- (void)setCapabilities:(NSXMLElement *)capabilities forJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + // By design this method should not be invoked from the storageQueue. + NSAssert(dispatch_get_current_queue() != storageQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if (jid == nil) return; + + [self scheduleBlock:^{ + + XMPPCapsCoreDataStorageObject *caps; + caps = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPCapsCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + caps.capabilities = capabilities; + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + + if (resource == nil) + { + resource = [NSEntityDescription insertNewObjectForEntityForName:@"XMPPCapsResourceCoreDataStorageObject" + inManagedObjectContext:[self managedObjectContext]]; + resource.jidStr = [jid full]; + resource.streamBareJidStr = [[self myJIDForXMPPStream:stream] bare]; + } + + resource.caps = caps; + + }]; +} + +- (void)setCapabilitiesFetchFailedForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + resource.haveFailed = YES; + + }]; +} + +- (void)clearAllNonPersistentCapabilitiesForXMPPStream:(XMPPStream *)stream +{ + // This method is called for the protocol, + // but is also called when we first load the database file from disk. + + XMPPLogTrace(); + + [self scheduleBlock:^{ + + [self _clearAllNonPersistentCapabilitiesForXMPPStream:stream]; + + }]; +} + +- (void)clearNonPersistentCapabilitiesForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream +{ + XMPPLogTrace(); + + [self scheduleBlock:^{ + + XMPPCapsResourceCoreDataStorageObject *resource = [self resourceForJID:jid xmppStream:stream]; + + if (resource != nil) + { + NSString *hash = resource.hashStr; + NSString *hashAlg = resource.hashAlgorithm; + + if (hash && hashAlg) + { + // The associated capabilities are persistent + } + else + { + XMPPCapsCoreDataStorageObject *caps = resource.caps; + if (caps) + { + [[self managedObjectContext] deleteObject:caps]; + } + } + + [[self managedObjectContext] deleteObject:resource]; + } + + }]; +} + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.h b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.h new file mode 100644 index 0000000..b474ef4 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.h @@ -0,0 +1,30 @@ +#import + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPCapsResourceCoreDataStorageObject; + + +@interface XMPPCapsCoreDataStorageObject : NSManagedObject + +@property (nonatomic, retain) NSXMLElement *capabilities; + +@property (nonatomic, retain) NSString * hashStr; +@property (nonatomic, retain) NSString * hashAlgorithm; +@property (nonatomic, retain) NSString * capabilitiesStr; + +@property (nonatomic, retain) NSSet * resources; + +@end + + +@interface XMPPCapsCoreDataStorageObject (CoreDataGeneratedAccessors) + +- (void)addResourcesObject:(XMPPCapsResourceCoreDataStorageObject *)value; +- (void)removeResourcesObject:(XMPPCapsResourceCoreDataStorageObject *)value; +- (void)addResources:(NSSet *)value; +- (void)removeResources:(NSSet *)value; + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.m b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.m new file mode 100644 index 0000000..02a7761 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsCoreDataStorageObject.m @@ -0,0 +1,26 @@ +#import "XMPPCapsCoreDataStorageObject.h" +#import "XMPPCapsResourceCoreDataStorageObject.h" +#import "XMPP.h" + + +@implementation XMPPCapsCoreDataStorageObject + +@dynamic capabilities; + +@dynamic hashStr; +@dynamic hashAlgorithm; +@dynamic capabilitiesStr; + +@dynamic resources; + +- (NSXMLElement *)capabilities +{ + return [[[NSXMLElement alloc] initWithXMLString:[self capabilitiesStr] error:nil] autorelease]; +} + +- (void)setCapabilities:(NSXMLElement *)caps +{ + self.capabilitiesStr = [caps compactXMLString]; +} + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.h b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.h new file mode 100644 index 0000000..3ae61ee --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.h @@ -0,0 +1,23 @@ +#import + +@class XMPPCapsCoreDataStorageObject; + + +@interface XMPPCapsResourceCoreDataStorageObject : NSManagedObject + +@property (nonatomic, retain) NSString * jidStr; +@property (nonatomic, retain) NSString * streamBareJidStr; + +@property (nonatomic, assign) BOOL haveFailed; +@property (nonatomic, retain) NSNumber * failed; + +@property (nonatomic, retain) NSString * node; +@property (nonatomic, retain) NSString * ver; +@property (nonatomic, retain) NSString * ext; + +@property (nonatomic, retain) NSString * hashStr; +@property (nonatomic, retain) NSString * hashAlgorithm; + +@property (nonatomic, retain) XMPPCapsCoreDataStorageObject * caps; + +@end diff --git a/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.m b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.m new file mode 100644 index 0000000..44bf650 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/CoreDataStorage/XMPPCapsResourceCoreDataStorageObject.m @@ -0,0 +1,32 @@ +#import "XMPPCapsResourceCoreDataStorageObject.h" +#import "XMPPCapsCoreDataStorageObject.h" + + +@implementation XMPPCapsResourceCoreDataStorageObject + +@dynamic jidStr; +@dynamic streamBareJidStr; + +@dynamic haveFailed; +@dynamic failed; + +@dynamic node; +@dynamic ver; +@dynamic ext; + +@dynamic hashStr; +@dynamic hashAlgorithm; + +@dynamic caps; + +- (BOOL)haveFailed +{ + return [[self failed] boolValue]; +} + +- (void)setHaveFailed:(BOOL)flag +{ + self.failed = [NSNumber numberWithBool:flag]; +} + +@end diff --git a/xmpp/Extensions/XEP-0115/XMPPCapabilities.h b/xmpp/Extensions/XEP-0115/XMPPCapabilities.h new file mode 100644 index 0000000..a465a05 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/XMPPCapabilities.h @@ -0,0 +1,349 @@ +#import +#import "XMPPModule.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPIQ; +@class XMPPJID; +@class XMPPStream; +@protocol XMPPCapabilitiesStorage; +@protocol XMPPCapabilitiesDelegate; + +/** + * This class provides support for capabilities discovery. + * + * It collects our capabilities and publishes them according to the XEP by: + * - Injecting the element into outgoing presence stanzas + * - Responding to incoming disco#info queries + * + * It also collects the capabilities of available resources, + * provides a mechanism to persistently store XEP-0115 hased caps, + * and makes available a simple API to query (disco#info) a resource or server. +**/ +@interface XMPPCapabilities : XMPPModule +{ + id xmppCapabilitiesStorage; + + NSXMLElement *myCapabilitiesQuery; // Full list of capabilites + NSXMLElement *myCapabilitiesC; // Hashed element + BOOL collectingMyCapabilities; + + NSMutableSet *discoRequestJidSet; + NSMutableDictionary *discoRequestHashDict; + NSMutableDictionary *discoTimerJidDict; + + BOOL autoFetchHashedCapabilities; + BOOL autoFetchNonHashedCapabilities; + + NSTimeInterval capabilitiesRequestTimeout; + + NSMutableSet *timers; +} + +- (id)initWithCapabilitiesStorage:(id )storage; +- (id)initWithCapabilitiesStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue; + +@property (nonatomic, readonly) id xmppCapabilitiesStorage; + +/** + * Defines fetching behavior for entities using the XEP-0115 standard. + * + * XEP-0115 defines a technique for hashing capabilities (disco info responses), + * and broadcasting them within a presence element. + * Due to the standardized hashing technique, capabilities associated with a hash may be persisted indefinitely. + * + * The end result is that capabilities need to be fetched less often + * since they are already known due to the caching of responses. + * + * The default value is YES. +**/ +@property (assign) BOOL autoFetchHashedCapabilities; + +/** + * Defines fetching behavior for entities NOT using the XEP-0115 standard. + * + * Because the capabilities are not associated with a standardized hash, + * it is not possible to cache the capabilities between sessions. + * + * The default value is NO. + * + * It is recommended you leave this value set to NO unless you + * know that you'll need the capabilities of every resource, + * and that fetching of the capabilities cannot be delayed. + * + * You may always fetch the capabilities (if/when needed) via the fetchCapabilitiesForJID method. +**/ +@property (assign) BOOL autoFetchNonHashedCapabilities; + +/** + * Manually fetch the capabilities for the given jid. + * + * The jid must be a full jid (user@domain/resource) or a domain JID (domain without user or resource). + * You would pass a full jid if you wanted to know the capabilities of a particular user's resource. + * You would pass a domain jid if you wanted to know the capabilities of a particular server. + * + * If there is an existing disco request associated with the given jid, this method does nothing. + * + * When the capabilities are received, + * the xmppCapabilities:didDiscoverCapabilities:forJID: delegate method is invoked. +**/ +- (void)fetchCapabilitiesForJID:(XMPPJID *)jid; + +/** + * This module automatically collects my capabilities. + * See the xmppCapabilities:collectingMyCapabilities: delegate method. + * + * The design of XEP-115 is such that capabilites are expected to remain rather static. + * However, if the capabilities change, this method may be used to perform a manual update. +**/ +- (void)recollectMyCapabilities; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPCapabilitiesStorage +@required + +// +// +// -- PUBLIC METHODS -- +// +// + +/** + * Returns whether or not we know the capabilities for a given jid. + * + * The stream parameter is optional. + * If given, the jid must have been registered via the given stream. + * Otherwise it will match the given jid from any stream this storage instance is managing. +**/ +- (BOOL)areCapabilitiesKnownForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Returns the capabilities for the given jid. + * The returned element is the element response to a disco#info request. + * + * The stream parameter is optional. + * If given, the jid must have been registered via the given stream. + * Otherwise it will match the given jid from any stream this storage instance is managing. +**/ +- (NSXMLElement *)capabilitiesForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Returns the capabilities for the given jid. + * The returned element is the element response to a disco#info request. + * + * The given jid should be a full jid (user@domain/resource) or a domin JID (domain without user or resource). + * + * If the jid has broadcast capabilities via the legacy format of XEP-0115, + * the extension list may optionally be retrieved via the ext parameter. + * + * For example, the jid may send a presence element like: + * + * + * + * + * + * In the above example, the ext string would be set to "rdserver rdclient avcap". + * + * You may pass nil for extPtr if you don't care about the legacy attributes, + * or you could simply use the capabilitiesForJID: method above. + * + * The stream parameter is optional. + * If given, the jid must have been registered via the given stream. + * Otherwise it will match the given jid from any stream this storage instance is managing. +**/ +- (NSXMLElement *)capabilitiesForJID:(XMPPJID *)jid ext:(NSString **)extPtr xmppStream:(XMPPStream *)stream; + +// +// +// -- PRIVATE METHODS -- +// +// These methods are designed to be used ONLY by the XMPPCapabilities class. +// +// + +/** + * Configures the capabilities storage class, passing it's parent and parent's dispatch queue. + * + * This method is called by the init methods of the XMPPCapabilities class. + * This method is designed to inform the storage class of it's parent + * and of the dispatch queue the parent will be operating on. + * + * It is strongly recommended the storage class operate on the same queue as it's parent + * as the majority of the time it will be getting called by the parent. + * Thus if both are operating on the same queue, the combination can run faster. + * + * This method should return YES if it was configured properly. + * A storage class is generally meant to be used once, and only with a single parent at a time. + * Thus if you attempt to use a single storage class with multiple parents, this method may return NO. + * The XMPPCapabilites class is configured to ignore the passed + * storage class in it's init method if this method returns NO. +**/ +- (BOOL)configureWithParent:(XMPPCapabilities *)aParent queue:(dispatch_queue_t)queue; + +/** + * Sets metadata for the given jid. + * + * This method should return: + * - YES if the capabilities for the given jid are known. + * - NO if the capabilities for the given jid are NOT known. + * + * If the hash and algorithm are given, and an associated set of capabilities matches the hash/algorithm, + * this method should link the jid to the capabilities and return YES. + * + * If the linked set of capabilities was not previously linked to the jid, + * the newCapabilities parameter shoud be filled out. + * + * This method may be called multiple times for a given jid with the same information. + * If this method sets the newCapabilitiesPtr parameter, + * the XMPPCapabilities module will invoke the xmppCapabilities:didDiscoverCapabilities:forJID: delegate method. + * This delegate method is designed to be invoked only when the capabilities for the given JID have changed. + * That is, the capabilities for the jid have been discovered for the first time (jid just signed in) + * or the capabilities for the given jid have changed (jid broadcast new capabilities). +**/ +- (BOOL)setCapabilitiesNode:(NSString *)node + ver:(NSString *)ver + ext:(NSString *)ext + hash:(NSString *)hash + algorithm:(NSString *)hashAlg + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream + andGetNewCapabilities:(NSXMLElement **)newCapabilitiesPtr; + +/** + * Fetches the associated capabilities hash for a given jid. + * + * If the jid is not associated with a capabilities hash, this method should return NO. + * Otherwise it should return YES, and set the corresponding variables. +**/ +- (BOOL)getCapabilitiesHash:(NSString **)hashPtr + algorithm:(NSString **)hashAlgPtr + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream; + +/** + * Clears any associated hash from a jid. + * If the jid is linked to a set of capabilities, it should be unlinked. + * + * This method should not clear the actual capabilities information itself. + * It should simply unlink the connection between the jid and the capabilities. +**/ +- (void)clearCapabilitiesHashAndAlgorithmForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Gets the metadata for the given jid. + * + * If the capabilities are known, the areCapabilitiesKnown boolean should be set to YES. +**/ +- (void)getCapabilitiesKnown:(BOOL *)areCapabilitiesKnownPtr + failed:(BOOL *)haveFailedFetchingBeforePtr + node:(NSString **)nodePtr + ver:(NSString **)verPtr + ext:(NSString **)extPtr + hash:(NSString **)hashPtr + algorithm:(NSString **)hashAlgPtr + forJID:(XMPPJID *)jid + xmppStream:(XMPPStream *)stream; + +/** + * Sets the capabilities associated with a given hash. + * + * Since the capabilities are linked to a hash, these capabilities (and associated hash) + * should be persisted to disk and persisted between multiple sessions/streams. + * + * It is the responsibility of the storage implementation to link the + * associated jids (those with the given hash) to the given set of capabilities. + * + * Implementation Note: + * + * If we receive multiple simultaneous presence elements from + * multiple jids all broadcasting the same capabilities hash: + * + * - A single disco request will be sent to one of the jids. + * - When the response comes back, the setCapabilities:forHash:algorithm: method will be invoked. + * + * The setCapabilities:forJID: method will NOT be invoked for each corresponding jid. + * This is by design to allow the storage implementation to optimize itself. +**/ +- (void)setCapabilities:(NSXMLElement *)caps forHash:(NSString *)hash algorithm:(NSString *)hashAlg; + +/** + * Sets the capabilities for a given jid. + * + * The jid is guaranteed NOT to be associated with a capabilities hash. + * + * Since the capabilities are NOT linked to a hash, + * these capabilities should not be persisted between multiple sessions/streams. + * See the various clear methods below. +**/ +- (void)setCapabilities:(NSXMLElement *)caps forJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Marks the disco fetch request as failed so we know not to bother trying again. + * + * This is temporary metadata associated with the jid. + * It should be cleared when we go unavailable or offline, or if the given jid goes unavailable. + * See the various clear methods below. +**/ +- (void)setCapabilitiesFetchFailedForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * This method is called when we go unavailable or offline. + * + * This method should clear all metadata (node, ver, ext, hash, algorithm, failed) from all jids in the roster. + * All jids should be unlinked from associated capabilities. + * + * If the associated capabilities are persistent, they should not be cleared. + * That is, if the associated capabilities are associated with a hash, they should be persisted. + * + * Non persistent capabilities (those not associated with a hash) + * should be cleared at this point as they will no longer be linked to any users. +**/ +- (void)clearAllNonPersistentCapabilitiesForXMPPStream:(XMPPStream *)stream; + +/** + * This method is called when the given jid goes unavailable. + * + * This method should clear all metadata (node, ver, ext, hash ,algorithm, failed) from the given jid. + * The jid should be unlinked from associated capabilities. + * + * If the associated capabilities are persistent, they should not be cleared. + * That is, if the associated capabilities are associated with a hash, they should be persisted. + * + * Non persistent capabilities (those not associated with a hash) should be cleared. +**/ +- (void)clearNonPersistentCapabilitiesForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPCapabilitiesDelegate +@optional + +/** + * Use this delegate method to add specific capabilities. + * This method in invoked automatically when the stream is connected for the first time, + * or if the module detects an outgoing presence element and my capabilities haven't been collected yet + * + * The design of XEP-115 is such that capabilites are expected to remain rather static. + * However, if the capabilities change, the recollectMyCapabilities method may be used to perform a manual update. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender collectingMyCapabilities:(NSXMLElement *)query; + +/** + * Invoked when capabilities have been discovered for an available JID. + * + * The caps element is the element response to a disco#info request. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender didDiscoverCapabilities:(NSXMLElement *)caps forJID:(XMPPJID *)jid; + +@end diff --git a/xmpp/Extensions/XEP-0115/XMPPCapabilities.m b/xmpp/Extensions/XEP-0115/XMPPCapabilities.m new file mode 100644 index 0000000..209e940 --- /dev/null +++ b/xmpp/Extensions/XEP-0115/XMPPCapabilities.m @@ -0,0 +1,1695 @@ +#import "XMPP.h" +#import "XMPPLogging.h" +#import "XMPPCapabilities.h" +#import "NSData+XMPP.h" + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_VERBOSE; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +/** + * Defines the timeout for a capabilities request. + * + * There are two reasons to have a timeout: + * - To prevent the discoRequest variables from growing indefinitely if responses are not received. + * - If a request is sent to a jid broadcasting a capabilities hash, and it does not respond within the timeout, + * we can then send a request to a different jid broadcasting the same capabilities hash. + * + * Remember, if multiple jids all broadcast the same capabilities hash, + * we only (initially) send a disco request to the first jid. + * This is an obvious optimization to remove unnecessary traffic and cpu load. + * + * However, if that jid doesn't respond within a sensible time period, + * we should move on to the next jid in the list. +**/ +#define CAPABILITIES_REQUEST_TIMEOUT 30.0 // seconds + +/** + * Define various xmlns values. +**/ +#define XMLNS_DISCO_INFO @"http://jabber.org/protocol/disco#info" +#define XMLNS_CAPS @"http://jabber.org/protocol/caps" + +/** + * Application identifier. + * According to the XEP it is RECOMMENDED for the value of the 'node' attribute to be an HTTP URL. +**/ +#ifndef DISCO_NODE + #define DISCO_NODE @"http://code.google.com/p/xmppframework" +#endif + +@interface GCDTimerWrapper : NSObject +{ + dispatch_source_t timer; +} + +- (id)initWithDispatchTimer:(dispatch_source_t)aTimer; +- (void)cancel; + +@end + +@interface XMPPCapabilities (PrivateAPI) + +- (void)continueCollectMyCapabilities:(NSXMLElement *)query; + +- (void)maybeQueryNextJidWithHashKey:(NSString *)key dueToHashMismatch:(BOOL)hashMismatch; + +- (void)setupTimeoutForDiscoRequestFromJID:(XMPPJID *)jid; +- (void)setupTimeoutForDiscoRequestFromJID:(XMPPJID *)jid withHashKey:(NSString *)key; + +- (void)cancelTimeoutForDiscoRequestFromJID:(XMPPJID *)jid; + +- (void)processTimeoutWithHashKey:(NSString *)key; +- (void)processTimeoutWithJID:(XMPPJID *)jid; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPCapabilities + +@dynamic xmppCapabilitiesStorage; +@dynamic autoFetchHashedCapabilities; +@dynamic autoFetchNonHashedCapabilities; + +- (id)init +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPCapabilities.h are supported. + + return [self initWithCapabilitiesStorage:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPCapabilities.h are supported. + + return [self initWithCapabilitiesStorage:nil dispatchQueue:NULL]; +} + +- (id)initWithCapabilitiesStorage:(id )storage +{ + return [self initWithCapabilitiesStorage:storage dispatchQueue:NULL]; +} + +- (id)initWithCapabilitiesStorage:(id )storage dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(storage != nil); + + if ((self = [super initWithDispatchQueue:queue])) + { + if ([storage configureWithParent:self queue:moduleQueue]) + { + xmppCapabilitiesStorage = [storage retain]; + } + else + { + XMPPLogError(@"%@: %@ - Unable to configure storage!", THIS_FILE, THIS_METHOD); + } + + // discoRequestJidSet: + // + // A set which contains every JID for which a current disco request applies. + // Note that one disco request may satisfy multiple jids in this set. + // This is the case if multiple jids broadcast the same capabilities hash. + // When this happens we send a single disco request to one of the jids, + // but every single jid with that hash is included in this set. + // This allows us to quickly and easily see if there is an outstanding disco request for a jid. + // + // discoRequestHashDict: + // + // A dictionary which tells us about disco requests that have been sent concerning hashed capabilities. + // It maps from hash (key=hash+hashAlgorithm) to an array of jids that use this hash. + // + // discoTimerJidDict: + // + // A dictionary that contains all the timers for timing out disco requests. + // It maps from jid to associated timer. + + discoRequestJidSet = [[NSMutableSet alloc] init]; + discoRequestHashDict = [[NSMutableDictionary alloc] init]; + discoTimerJidDict = [[NSMutableDictionary alloc] init]; + + autoFetchHashedCapabilities = YES; + autoFetchNonHashedCapabilities = NO; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + // Custom code goes here (if needed) + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + // Custom code goes here (if needed) + + [super deactivate]; +} + +- (void)dealloc +{ + [xmppCapabilitiesStorage release]; + + [myCapabilitiesQuery release]; + [myCapabilitiesC release]; + + [discoRequestJidSet release]; + [discoRequestHashDict release]; + + for (GCDTimerWrapper *timerWrapper in discoTimerJidDict) + { + [timerWrapper cancel]; + } + [discoTimerJidDict release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id )xmppCapabilitiesStorage +{ + return xmppCapabilitiesStorage; +} + +- (BOOL)autoFetchHashedCapabilities +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = autoFetchHashedCapabilities; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +- (void)setAutoFetchHashedCapabilities:(BOOL)flag +{ + dispatch_block_t block = ^{ + autoFetchHashedCapabilities = flag; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (BOOL)autoFetchNonHashedCapabilities +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = autoFetchNonHashedCapabilities; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return result; +} + +- (void)setAutoFetchNonHashedCapabilities:(BOOL)flag +{ + dispatch_block_t block = ^{ + autoFetchNonHashedCapabilities = flag; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Hashing +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +static NSString* encodeLt(NSString *str) +{ + // From the RFC: + // + // If the string "<" appears in any of the hash values, + // then that value MUST NOT convert it to "<" because + // completing such a conversion would open the protocol to trivial attacks. + // + // All of the XML libraries perform this conversion for us automatically (which makes sense). + // Furthermore, it is illegal for an attribute or namespace value to have a raw "<" character (as per XML). + // So the solution is very simple: + // Just convert any '<' characters to the escaped "<" string. + + return [str stringByReplacingOccurrencesOfString:@"<" withString:@"<"]; +} + +static NSInteger sortIdentities(NSXMLElement *identity1, NSXMLElement *identity2, void *context) +{ + // Sort the service discovery identities by category and then by type and then by xml:lang (if it exists). + // + // All sort operations MUST be performed using "i;octet" collation as specified in Section 9.3 of RFC 4790. + + NSComparisonResult result; + + NSString *category1 = [identity1 attributeStringValueForName:@"category" withDefaultValue:@""]; + NSString *category2 = [identity2 attributeStringValueForName:@"category" withDefaultValue:@""]; + + category1 = encodeLt(category1); + category2 = encodeLt(category2); + + result = [category1 compare:category2 options:NSLiteralSearch]; + if (result != NSOrderedSame) + { + return result; + } + + NSString *type1 = [identity1 attributeStringValueForName:@"type" withDefaultValue:@""]; + NSString *type2 = [identity2 attributeStringValueForName:@"type" withDefaultValue:@""]; + + type1 = encodeLt(type1); + type2 = encodeLt(type2); + + result = [type1 compare:type2 options:NSLiteralSearch]; + if (result != NSOrderedSame) + { + return result; + } + + NSString *lang1 = [identity1 attributeStringValueForName:@"xml:lang" withDefaultValue:@""]; + NSString *lang2 = [identity2 attributeStringValueForName:@"xml:lang" withDefaultValue:@""]; + + lang1 = encodeLt(lang1); + lang2 = encodeLt(lang2); + + result = [lang1 compare:lang2 options:NSLiteralSearch]; + if (result != NSOrderedSame) + { + return result; + } + + NSString *name1 = [identity1 attributeStringValueForName:@"name" withDefaultValue:@""]; + NSString *name2 = [identity2 attributeStringValueForName:@"name" withDefaultValue:@""]; + + name1 = encodeLt(name1); + name2 = encodeLt(name2); + + return [name1 compare:name2 options:NSLiteralSearch]; +} + +static NSInteger sortFeatures(NSXMLElement *feature1, NSXMLElement *feature2, void *context) +{ + // All sort operations MUST be performed using "i;octet" collation as specified in Section 9.3 of RFC 4790. + + NSString *var1 = [feature1 attributeStringValueForName:@"var" withDefaultValue:@""]; + NSString *var2 = [feature2 attributeStringValueForName:@"var" withDefaultValue:@""]; + + var1 = encodeLt(var1); + var2 = encodeLt(var2); + + return [var1 compare:var2 options:NSLiteralSearch]; +} + +static NSString* extractFormTypeValue(NSXMLElement *form) +{ + // From the RFC: + // + // If the FORM_TYPE field is not of type "hidden" or the form does not + // include a FORM_TYPE field, ignore the form but continue processing. + // + // If the FORM_TYPE field contains more than one element with different XML character data, + // consider the entire response to be ill-formed. + + // This method will return: + // + // - The form type's value if it exists + // - An empty string if it does not contain a form type field (or the form type is not of type hidden) + // - Nil if the form type is invalid (contains more than one element which are different) + // + // In other words + // + // - Non-empty string -> proper form + // - Empty string -> ignore form + // - Nil -> Entire response is to be considered ill-formed + // + // The returned value is properly encoded via encodeLt() and contains the trailing '<' character. + + NSArray *fields = [form elementsForName:@"field"]; + for (NSXMLElement *field in fields) + { + NSString *var = [field attributeStringValueForName:@"var"]; + NSString *type = [field attributeStringValueForName:@"type"]; + + if ([var isEqualToString:@"FORM_TYPE"] && [type isEqualToString:@"hidden"]) + { + NSArray *values = [field elementsForName:@"value"]; + + if ([values count] > 0) + { + if ([values count] > 1) + { + NSString *baseValue = [[values objectAtIndex:0] stringValue]; + + NSUInteger i; + for (i = 1; i < [values count]; i++) + { + NSString *value = [[values objectAtIndex:i] stringValue]; + + if (![value isEqualToString:baseValue]) + { + // Multiple elements with differing XML character data + return nil; + } + } + } + + NSString *result = [[values lastObject] stringValue]; + if (result == nil) + { + // This is why the result contains the trailing '<' character. + result = @""; + } + + return [NSString stringWithFormat:@"%@<", encodeLt(result)]; + } + } + } + + return @""; +} + +static NSInteger sortForms(NSXMLElement *form1, NSXMLElement *form2, void *context) +{ + // Sort the forms by the FORM_TYPE (i.e., by the XML character data of the element. + // + // All sort operations MUST be performed using "i;octet" collation as specified in Section 9.3 of RFC 4790. + + NSString *formTypeValue1 = extractFormTypeValue(form1); + NSString *formTypeValue2 = extractFormTypeValue(form2); + + // The formTypeValue variable is guaranteed to be properly encoded. + + return [formTypeValue1 compare:formTypeValue2 options:NSLiteralSearch]; +} + +static NSInteger sortFormFields(NSXMLElement *field1, NSXMLElement *field2, void *context) +{ + // Sort the fields by the "var" attribute. + // + // All sort operations MUST be performed using "i;octet" collation as specified in Section 9.3 of RFC 4790. + + NSString *var1 = [field1 attributeStringValueForName:@"var" withDefaultValue:@""]; + NSString *var2 = [field2 attributeStringValueForName:@"var" withDefaultValue:@""]; + + var1 = encodeLt(var1); + var2 = encodeLt(var2); + + return [var1 compare:var2 options:NSLiteralSearch]; +} + +static NSInteger sortFieldValues(NSXMLElement *value1, NSXMLElement *value2, void *context) +{ + NSString *str1 = [value1 stringValue]; + NSString *str2 = [value2 stringValue]; + + if (str1 == nil) str1 = @""; + if (str2 == nil) str2 = @""; + + str1 = encodeLt(str1); + str2 = encodeLt(str2); + + return [str1 compare:str2 options:NSLiteralSearch]; +} + +- (NSString *)hashCapabilitiesFromQuery:(NSXMLElement *)query +{ + if (query == nil) return nil; + + NSMutableSet *set = [NSMutableSet set]; + + NSMutableString *s = [NSMutableString string]; + + NSArray *identities = [[query elementsForName:@"identity"] sortedArrayUsingFunction:sortIdentities context:NULL]; + for (NSXMLElement *identity in identities) + { + // Format as: category / type / lang / name + + NSString *category = [identity attributeStringValueForName:@"category" withDefaultValue:@""]; + NSString *type = [identity attributeStringValueForName:@"type" withDefaultValue:@""]; + NSString *lang = [identity attributeStringValueForName:@"xml:lang" withDefaultValue:@""]; + NSString *name = [identity attributeStringValueForName:@"name" withDefaultValue:@""]; + + category = encodeLt(category); + type = encodeLt(type); + lang = encodeLt(lang); + name = encodeLt(name); + + NSString *mash = [NSString stringWithFormat:@"%@/%@/%@/%@<", category, type, lang, name]; + + // Section 5.4, rule 3.3: + // + // If the response includes more than one service discovery identity with + // the same category/type/lang/name, consider the entire response to be ill-formed. + + if ([set containsObject:mash]) + { + return nil; + } + else + { + [set addObject:mash]; + } + + [s appendString:mash]; + } + + [set removeAllObjects]; + + + NSArray *features = [[query elementsForName:@"feature"] sortedArrayUsingFunction:sortFeatures context:NULL]; + for (NSXMLElement *feature in features) + { + NSString *var = [feature attributeStringValueForName:@"var" withDefaultValue:@""]; + + var = encodeLt(var); + + NSString *mash = [NSString stringWithFormat:@"%@<", var]; + + // Section 5.4, rule 3.4: + // + // If the response includes more than one service discovery feature with the + // same XML character data, consider the entire response to be ill-formed. + + if ([set containsObject:mash]) + { + return nil; + } + else + { + [set addObject:mash]; + } + + [s appendString:mash]; + } + + [set removeAllObjects]; + + NSArray *unsortedForms = [query elementsForLocalName:@"x" URI:@"jabber:x:data"]; + NSArray *forms = [unsortedForms sortedArrayUsingFunction:sortForms context:NULL]; + for (NSXMLElement *form in forms) + { + NSString *formTypeValue = extractFormTypeValue(form); + + if (formTypeValue == nil) + { + // Invalid according to section 5.4, rule 3.5 + return nil; + } + if ([formTypeValue length] == 0) + { + // Ignore according to section 5.4, rule 3.6 + continue; + } + + // Note: The formTypeValue is properly encoded and contains the trailing '<' character. + + [s appendString:formTypeValue]; + + NSArray *fields = [[form elementsForName:@"field"] sortedArrayUsingFunction:sortFormFields context:NULL]; + for (NSXMLElement *field in fields) + { + // For each field other than FORM_TYPE: + // + // 1. Append the value of the var attribute, followed by the '<' character. + // 2. Sort values by the XML character data of the element. + // 3. For each element, append the XML character data, followed by the '<' character. + + NSString *var = [field attributeStringValueForName:@"var" withDefaultValue:@""]; + + var = encodeLt(var); + + if ([var isEqualToString:@"FORM_TYPE"]) + { + continue; + } + + [s appendFormat:@"%@<", var]; + + NSArray *values = [[field elementsForName:@"value"] sortedArrayUsingFunction:sortFieldValues context:NULL]; + for (NSXMLElement *value in values) + { + NSString *str = [value stringValue]; + if (str == nil) + { + str = @""; + } + + str = encodeLt(str); + + [s appendFormat:@"%@<", str]; + } + } + } + + NSData *data = [s dataUsingEncoding:NSUTF8StringEncoding]; + NSData *hash = [data sha1Digest]; + + return [hash base64Encoded]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Key Conversions +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)keyFromHash:(NSString *)hash algorithm:(NSString *)hashAlg +{ + return [NSString stringWithFormat:@"%@-%@", hash, hashAlg]; +} + +- (BOOL)getHash:(NSString **)hashPtr algorithm:(NSString **)hashAlgPtr fromKey:(NSString *)key +{ + if (key == nil) return NO; + + NSRange range = [key rangeOfString:@"-"]; + + if (range.location == NSNotFound) + { + return NO; + } + + if (hashPtr) + { + *hashPtr = [key substringToIndex:range.location]; + } + if (hashAlgPtr) + { + *hashAlgPtr = [key substringFromIndex:(range.location + range.length)]; + } + + return YES; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Logic +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)collectMyCapabilities +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if (collectingMyCapabilities) + { + XMPPLogInfo(@"%@: %@ - Existing collection already in progress", [self class], THIS_METHOD); + return; + } + + [myCapabilitiesQuery release]; myCapabilitiesQuery = nil; + [myCapabilitiesC release]; myCapabilitiesC = nil; + + collectingMyCapabilities = YES; + + // Create new query and add standard features + // + // + // + // + // + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:XMLNS_DISCO_INFO]; + + NSXMLElement *feature1 = [NSXMLElement elementWithName:@"feature"]; + [feature1 addAttributeWithName:@"var" stringValue:XMLNS_DISCO_INFO]; + + NSXMLElement *feature2 = [NSXMLElement elementWithName:@"feature"]; + [feature2 addAttributeWithName:@"var" stringValue:XMLNS_CAPS]; + + [query addChild:feature1]; + [query addChild:feature2]; + + // Now prompt the delegates to add any additional features. + + SEL selector = @selector(xmppCapabilities:collectingMyCapabilities:); + + if ([multicastDelegate countForSelector:selector] == 0) + { + // None of the delegates implement the method. + // Use a shortcut. + + [self continueCollectMyCapabilities:query]; + } + else + { + // Query all interested delegates. + // This must be done serially to allow them to alter the element in a thread-safe manner. + + GCDMulticastDelegateEnumerator *delegateEnumerator = [multicastDelegate delegateEnumerator]; + + dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(concurrentQueue, ^{ + NSAutoreleasePool *outerPool = [[NSAutoreleasePool alloc] init]; + + // Allow delegates to modify outgoing element + + id del; + dispatch_queue_t dq; + + while ([delegateEnumerator getNextDelegate:&del delegateQueue:&dq forSelector:selector]) + { + dispatch_sync(dq, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [del xmppCapabilities:self collectingMyCapabilities:query]; + + [innerPool release]; + }); + } + + dispatch_async(moduleQueue, ^{ + NSAutoreleasePool *innerPool = [[NSAutoreleasePool alloc] init]; + + [self continueCollectMyCapabilities:query]; + + [innerPool release]; + }); + + [outerPool drain]; + }); + } +} + +- (void)continueCollectMyCapabilities:(NSXMLElement *)query +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + collectingMyCapabilities = NO; + + myCapabilitiesQuery = [query retain]; + + XMPPLogVerbose(@"%@: My capabilities:\n%@", THIS_FILE, + [query XMLStringWithOptions:(NSXMLNodeCompactEmptyElement | NSXMLNodePrettyPrint)]); + + NSString *hash = [self hashCapabilitiesFromQuery:query]; + + if (hash == nil) + { + XMPPLogWarn(@"%@: Unable to hash capabilites (in order to send in presense element)\n", + "Perhaps there are duplicate advertised features...\n%@", THIS_FILE, + [query XMLStringWithOptions:(NSXMLNodeCompactEmptyElement | NSXMLNodePrettyPrint)]); + return; + } + + NSString *hashAlg = @"sha-1"; + + // Cache the hash + + [xmppCapabilitiesStorage setCapabilities:query forHash:hash algorithm:hashAlg]; + + // Create the c element, which will be added to normal outgoing presence elements. + // + // + + myCapabilitiesC = [[NSXMLElement alloc] initWithName:@"c" xmlns:XMLNS_CAPS]; + [myCapabilitiesC addAttributeWithName:@"hash" stringValue:hashAlg]; + [myCapabilitiesC addAttributeWithName:@"node" stringValue:DISCO_NODE]; + [myCapabilitiesC addAttributeWithName:@"ver" stringValue:hash]; + + // If the collection process started when the stream was connected, + // and ended up taking so long as to not be available when the presence was sent, + // we should re-broadcast our presence now that we know what our capabilities are. + + XMPPPresence *myPresence = [xmppStream myPresence]; + if (myPresence) + { + [xmppStream sendElement:myPresence]; + } +} + +- (void)recollectMyCapabilities +{ + // This is a public method. + // It may be invoked on any thread/queue. + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self collectMyCapabilities]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)sendDiscoInfoQueryTo:(XMPPJID *)jid withNode:(NSString *)node ver:(NSString *)ver +{ + // + // + // + // + // Note: + // Some xmpp clients will return an error if we don't specify the proper query node. + // Some xmpp clients will return an error if we don't include an id attribute in the iq. + + NSXMLElement *query = [NSXMLElement elementWithName:@"query" xmlns:XMLNS_DISCO_INFO]; + + if (node && ver) + { + NSString *nodeValue = [NSString stringWithFormat:@"%@#%@", node, ver]; + + [query addAttributeWithName:@"node" stringValue:nodeValue]; + } + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:jid elementID:[xmppStream generateUUID] child:query]; + + [xmppStream sendElement:iq]; +} + +- (void)fetchCapabilitiesForJID:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ([discoRequestJidSet containsObject:jid]) + { + // We're already requesting capabilities concerning this JID + [pool drain]; + return; + } + + BOOL areCapabilitiesKnown; + BOOL haveFailedFetchingBefore; + + NSString *node = nil; + NSString *ver = nil; + NSString *hash = nil; + NSString *hashAlg = nil; + + [xmppCapabilitiesStorage getCapabilitiesKnown:&areCapabilitiesKnown + failed:&haveFailedFetchingBefore + node:&node + ver:&ver + ext:nil + hash:&hash + algorithm:&hashAlg + forJID:jid + xmppStream:xmppStream]; + + if (areCapabilitiesKnown) + { + // We already know the capabilities for this JID + [pool drain]; + return; + } + if (haveFailedFetchingBefore) + { + // We've already sent a fetch request to the JID in the past, which failed. + [pool drain]; + return; + } + + NSString *key = nil; + + if (hash && hashAlg) + { + // This jid is associated with a capabilities hash. + // + // Now, we've verified that the jid is not in the discoRequestJidSet. + // But consider the following scenario. + // + // - autoFetchCapabilities is false. + // - We receive 2 presence elements from 2 different jids, both advertising the same capabilities hash. + // - This method is called for the first jid. + // - This method is then immediately called for the second jid. + // + // Now since autoFetchCapabilities is false, the second jid will not be in the discoRequestJidSet. + // However, there is still a disco request that concerns the jid. + + key = [self keyFromHash:hash algorithm:hashAlg]; + NSMutableArray *jids = [discoRequestHashDict objectForKey:key]; + + if (jids) + { + // We're already requesting capabilities concerning this JID. + // That is, there is another JID with the same hash, and we've already sent a disco request to it. + + [jids addObject:jid]; + [discoRequestJidSet addObject:jid]; + + [pool drain]; + return; + } + + // The first object in the jids array is the index of the last jid that we've sent a disco request to. + // This is used in case the jid does not respond. + + NSNumber *requestIndexNum = [NSNumber numberWithUnsignedInteger:1]; + jids = [NSMutableArray arrayWithObjects:requestIndexNum, jid, nil]; + + [discoRequestHashDict setObject:jids forKey:key]; + [discoRequestJidSet addObject:jid]; + } + else + { + [discoRequestJidSet addObject:jid]; + } + + // Send disco#info query + + [self sendDiscoInfoQueryTo:jid withNode:node ver:ver]; + + // Setup request timeout + + if (key) + { + [self setupTimeoutForDiscoRequestFromJID:jid withHashKey:key]; + } + else + { + [self setupTimeoutForDiscoRequestFromJID:jid]; + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +/** + * Invoked when an available presence element is received with + * a capabilities child element that conforms to the XEP-0115 standard. +**/ +- (void)handlePresenceCapabilities:(NSXMLElement *)c fromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, jid); + + // + // + // + + NSString *node = [c attributeStringValueForName:@"node"]; + NSString *ver = [c attributeStringValueForName:@"ver"]; + NSString *hash = [c attributeStringValueForName:@"hash"]; + + if ((node == nil) || (ver == nil)) + { + // Invalid capabilities node! + + if (autoFetchNonHashedCapabilities) + { + [self fetchCapabilitiesForJID:jid]; + } + + return; + } + + // Note: We already checked the hash variable in the xmppStream:didReceivePresence: method below. + + // Remember: hash="sha-1" ver="ABC-Actual-Hash-DEF". + // It's a bit confusing as it was designed this way for backwards compatibility with v 1.4 and below. + + NSXMLElement *newCapabilities = nil; + + BOOL areCapabilitiesKnown = [xmppCapabilitiesStorage setCapabilitiesNode:node + ver:ver + ext:nil + hash:ver // Yes, this is correct (see above) + algorithm:hash // Ditto + forJID:jid + xmppStream:xmppStream + andGetNewCapabilities:&newCapabilities]; + if (areCapabilitiesKnown) + { + XMPPLogVerbose(@"%@: Capabilities already known for jid(%@) with hash(%@)", THIS_FILE, jid, ver); + + if (newCapabilities) + { + // This is the first time we've linked the jid with the set of capabilities. + // We didn't need to do any lookups due to hashing and caching. + + // Notify the delegate(s) + [multicastDelegate xmppCapabilities:self didDiscoverCapabilities:newCapabilities forJID:jid]; + } + + // The capabilities for this hash are already known + return; + } + + // Should we automatically fetch the capabilities? + + if (!autoFetchHashedCapabilities) + { + return; + } + + // Are we already fetching the capabilities? + + NSString *key = [self keyFromHash:ver algorithm:hash]; + NSMutableArray *jids = [discoRequestHashDict objectForKey:key]; + + if (jids) + { + XMPPLogVerbose(@"%@: We're already fetching capabilities for hash(%@)", THIS_FILE, ver); + + // Is the jid already included in this list? + // + // There are actually two ways we can answer this question. + // - Invoke containsObject on the array (jids) + // - Invoke containsObject on the set (discoRequestJidSet) + // + // This is much faster to do on a set. + + if (![discoRequestJidSet containsObject:jid]) + { + [discoRequestJidSet addObject:jid]; + [jids addObject:jid]; + } + + // We've already sent a disco request concerning this hash. + return; + } + + // We've never sent a request for this hash. + // Add the jid to the discoRequest variables. + + // Note: The first object in the jids array is the index of the last jid that we've sent a disco request to. + // This is used in case the jid does not respond. + // + // Here's the scenario: + // We receive 5 presence elements from 5 different jids, + // all advertising the same capabilities via the same hash. + // We don't want to waste bandwidth and cpu by sending a disco request to all 5 jids. + // So we send a disco request to the first jid. + // But then what happens if that jid never responds? + // Perhaps it went offline before it could get the message. + // After a period of time ellapses, we should send a request to the next jid in the list. + // So how do we know what the next jid in the list is? + // Via the requestIndexNum of course. + + NSNumber *requestIndexNum = [NSNumber numberWithUnsignedInteger:1]; + jids = [NSMutableArray arrayWithObjects:requestIndexNum, jid, nil]; + + [discoRequestHashDict setObject:jids forKey:key]; + [discoRequestJidSet addObject:jid]; + + // Send disco#info query + + [self sendDiscoInfoQueryTo:jid withNode:node ver:ver]; + + // Setup request timeout + + [self setupTimeoutForDiscoRequestFromJID:jid withHashKey:key]; +} + +/** + * Invoked when an available presence element is received with + * a capabilities child element that implements the legacy version of XEP-0115. +**/ +- (void)handleLegacyPresenceCapabilities:(NSXMLElement *)c fromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, jid); + + NSString *node = [c attributeStringValueForName:@"node"]; + NSString *ver = [c attributeStringValueForName:@"ver"]; + NSString *ext = [c attributeStringValueForName:@"ext"]; + + if ((node == nil) || (ver == nil)) + { + // Invalid capabilities node! + + if (autoFetchNonHashedCapabilities) + { + [self fetchCapabilitiesForJID:jid]; + } + + return; + } + + BOOL areCapabilitiesKnown = [xmppCapabilitiesStorage setCapabilitiesNode:node + ver:ver + ext:ext + hash:nil + algorithm:nil + forJID:jid + xmppStream:xmppStream + andGetNewCapabilities:nil]; + if (areCapabilitiesKnown) + { + XMPPLogVerbose(@"%@: Capabilities already known for jid(%@)", THIS_FILE, jid); + + // The capabilities for this jid are already known + return; + } + + // Should we automatically fetch the capabilities? + + if (!autoFetchNonHashedCapabilities) + { + return; + } + + // Are we already fetching the capabilities? + + if ([discoRequestJidSet containsObject:jid]) + { + XMPPLogVerbose(@"%@: We're already fetching capabilities for jid(%@)", THIS_FILE, jid); + + // We've already sent a disco request to this jid. + return; + } + + [discoRequestJidSet addObject:jid]; + + // Send disco#info query + + [self sendDiscoInfoQueryTo:jid withNode:node ver:ver]; + + // Setup request timeout + + [self setupTimeoutForDiscoRequestFromJID:jid]; +} + +/** + * Invoked when we receive a disco request (request for our capabilities). + * We should response with the proper disco response. +**/ +- (void)handleDiscoRequest:(XMPPIQ *)iqRequest +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + if (myCapabilitiesQuery == nil) + { + // It appears we haven't collected our list of capabilites yet. + // This will need to be done before we can add the hash to the outgoing presence element. + + [self collectMyCapabilities]; + } + else if (myCapabilitiesC) + { + NSXMLElement *queryRequest = [iqRequest childElement]; + NSString *node = [queryRequest attributeStringValueForName:@"node"]; + + // + // + // + // + // + // + + NSXMLElement *query = [[myCapabilitiesQuery copy] autorelease]; + if (node) + { + [query addAttributeWithName:@"node" stringValue:node]; + } + + XMPPIQ *iqResponse = [XMPPIQ iqWithType:@"result" + to:[iqRequest from] + elementID:[iqRequest elementID] + child:query]; + + [xmppStream sendElement:iqResponse]; + } +} + +/** + * Invoked when we receive a response to one of our previously sent disco requests. +**/ +- (void)handleDiscoResponse:(NSXMLElement *)querySubElement fromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Remember XML hiearchy memory management rules. + // The passed parameter is a subnode of the IQ, and we need to pass it asynchronously to storge / delegate(s). + NSXMLElement *query = [[querySubElement copy] autorelease]; + + NSString *hash = nil; + NSString *hashAlg = nil; + + BOOL hashResponse = [xmppCapabilitiesStorage getCapabilitiesHash:&hash + algorithm:&hashAlg + forJID:jid + xmppStream:xmppStream]; + if (hashResponse) + { + XMPPLogVerbose(@"%@: %@ - Hash response...", THIS_FILE, THIS_METHOD); + + // Standard version 1.5+ + + NSString *key = [self keyFromHash:hash algorithm:hashAlg]; + + NSString *calculatedHash = [self hashCapabilitiesFromQuery:query]; + + if ([calculatedHash isEqualToString:hash]) + { + XMPPLogVerbose(@"%@: %@ - Hash matches!", THIS_FILE, THIS_METHOD); + + // Store the capabilities (associated with the hash) + [xmppCapabilitiesStorage setCapabilities:query forHash:hash algorithm:hashAlg]; + + // Remove the jid(s) from the discoRequest variables + NSArray *jids = [discoRequestHashDict objectForKey:key]; + + NSUInteger i; + for (i = 1; i < [jids count]; i++) + { + XMPPJID *currentJid = [jids objectAtIndex:i]; + + [discoRequestJidSet removeObject:currentJid]; + + // Notify the delegate(s) + [multicastDelegate xmppCapabilities:self didDiscoverCapabilities:query forJID:currentJid]; + } + + [discoRequestHashDict removeObjectForKey:key]; + + // Cancel the request timeout + [self cancelTimeoutForDiscoRequestFromJID:jid]; + } + else + { + XMPPLogWarn(@"%@: Hash mismatch! hash(%@) != calculatedHash(%@)", THIS_FILE, hash, calculatedHash); + + // Revoke the associated hash from the jid + [xmppCapabilitiesStorage clearCapabilitiesHashAndAlgorithmForJID:jid xmppStream:xmppStream]; + + // Now set the capabilities for the jid + [xmppCapabilitiesStorage setCapabilities:query forJID:jid xmppStream:xmppStream]; + + // Notify the delegate(s) + [multicastDelegate xmppCapabilities:self didDiscoverCapabilities:query forJID:jid]; + + // We'd still like to know what the capabilities are for this hash. + // Move onto the next one in the list (if there are more, otherwise stop). + [self maybeQueryNextJidWithHashKey:key dueToHashMismatch:YES]; + } + } + else + { + XMPPLogVerbose(@"%@: %@ - Non-Hash response", THIS_FILE, THIS_METHOD); + + // Store the capabilities (associated with the jid) + [xmppCapabilitiesStorage setCapabilities:query forJID:jid xmppStream:xmppStream]; + + // Remove the jid from the discoRequest variable + [discoRequestJidSet removeObject:jid]; + + // Cancel the request timeout + [self cancelTimeoutForDiscoRequestFromJID:jid]; + + // Notify the delegate(s) + [multicastDelegate xmppCapabilities:self didDiscoverCapabilities:query forJID:jid]; + } +} + +- (void)handleDiscoErrorResponse:(NSXMLElement *)querySubElement fromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + NSString *hash = nil; + NSString *hashAlg = nil; + + BOOL hashResponse = [xmppCapabilitiesStorage getCapabilitiesHash:&hash + algorithm:&hashAlg + forJID:jid + xmppStream:xmppStream]; + if (hashResponse) + { + NSString *key = [self keyFromHash:hash algorithm:hashAlg]; + + // We'd still like to know what the capabilities are for this hash. + // Move onto the next one in the list (if there are more, otherwise stop). + [self maybeQueryNextJidWithHashKey:key dueToHashMismatch:NO]; + } + else + { + // Make a note of the failure + [xmppCapabilitiesStorage setCapabilitiesFetchFailedForJID:jid xmppStream:xmppStream]; + + // Remove the jid from the discoRequest variable + [discoRequestJidSet removeObject:jid]; + + // Cancel the request timeout + [self cancelTimeoutForDiscoRequestFromJID:jid]; + } +} + +- (void)maybeQueryNextJidWithHashKey:(NSString *)key dueToHashMismatch:(BOOL)hashMismatch +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Get the list of jids that have the same capabilities hash + + NSMutableArray *jids = [discoRequestHashDict objectForKey:key]; + if (jids == nil) + { + XMPPLogWarn(@"%@: %@ - Key doesn't exist in discoRequestHashDict", THIS_FILE, THIS_METHOD); + + return; + } + + // Get the index and jid of the fetch that just failed + + NSUInteger requestIndex = [[jids objectAtIndex:0] unsignedIntegerValue]; + XMPPJID *jid = [jids objectAtIndex:requestIndex]; + + // Release the associated timer + [self cancelTimeoutForDiscoRequestFromJID:jid]; + + if (hashMismatch) + { + // We need to remove the naughty jid from the lists. + + [discoRequestJidSet removeObject:jid]; + [jids removeObjectAtIndex:requestIndex]; + } + else + { + // We want to move onto the next jid in the list. + // Increment request index (and update object in jids array), + + requestIndex++; + [jids replaceObjectAtIndex:0 withObject:[NSNumber numberWithUnsignedInteger:requestIndex]]; + } + + // Do we have another jid that we can query? + // That is, another jid that was broadcasting the same capabilities hash. + + if (requestIndex < [jids count]) + { + XMPPJID *jid = [jids objectAtIndex:requestIndex]; + + NSString *node = nil; + NSString *ver = nil; + + [xmppCapabilitiesStorage getCapabilitiesKnown:nil + failed:nil + node:&node + ver:&ver + ext:nil + hash:nil + algorithm:nil + forJID:jid + xmppStream:xmppStream]; + + // Send disco#info query + + [self sendDiscoInfoQueryTo:jid withNode:node ver:ver]; + + // Setup request timeout + + [self setupTimeoutForDiscoRequestFromJID:jid withHashKey:key]; + } + else + { + // We've queried every single jid that was broadcasting this capabilities hash. + // Nothing left to do now but wait. + // + // If one of the jids happens to eventually respond, + // then we'll still be able to link the capabilities to every jid with the same capabilities hash. + // + // This would be handled by the xmppCapabilitiesStorage class, + // via the setCapabilitiesForJID method. + + NSUInteger i; + for (i = 1; i < [jids count]; i++) + { + XMPPJID *jid = [jids objectAtIndex:i]; + + [discoRequestJidSet removeObject:jid]; + [xmppCapabilitiesStorage setCapabilitiesFetchFailedForJID:jid xmppStream:xmppStream]; + } + + [discoRequestHashDict removeObjectForKey:key]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppStreamDidConnect:(XMPPStream *)sender +{ + // If this is the first time we've connected, start collecting our list of capabilities. + // We do this now so that the process is likely ready by the time we need to send a presence element. + + if (myCapabilitiesQuery == nil) + { + [self collectMyCapabilities]; + } +} + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence +{ + // This method is invoked on the moduleQueue. + + // XEP-0115 presence: + // + // + // + // + + NSString *type = [presence type]; + + XMPPJID *myJID = xmppStream.myJID; + if ([myJID isEqual:[presence from]]) + { + // Our own presence is being reflected back to us. + return; + } + + if ([type isEqualToString:@"unavailable"]) + { + [xmppCapabilitiesStorage clearNonPersistentCapabilitiesForJID:[presence from] xmppStream:xmppStream]; + } + else if ([type isEqualToString:@"available"]) + { + NSXMLElement *c = [presence elementForName:@"c" xmlns:XMLNS_CAPS]; + if (c == nil) + { + if (autoFetchNonHashedCapabilities) + { + [self fetchCapabilitiesForJID:[presence from]]; + } + } + else + { + NSString *hash = [c attributeStringValueForName:@"hash"]; + if (hash) + { + [self handlePresenceCapabilities:c fromJID:[presence from]]; + } + else + { + [self handleLegacyPresenceCapabilities:c fromJID:[presence from]]; + } + } + } +} + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // This method is invoked on the moduleQueue. + + // Disco Request: + // + // + // + // + // + // Disco Response: + // + // + // + // + // + // + // + + NSXMLElement *query = [iq elementForName:@"query" xmlns:XMLNS_DISCO_INFO]; + if (query == nil) + { + return NO; + } + + NSString *type = [[iq attributeStringValueForName:@"type"] lowercaseString]; + if ([type isEqualToString:@"get"]) + { + NSString *node = [query attributeStringValueForName:@"node"]; + + if (node == nil || [node hasPrefix:DISCO_NODE]) + { + [self handleDiscoRequest:iq]; + } + else + { + return NO; + } + } + else if ([type isEqualToString:@"result"]) + { + [self handleDiscoResponse:query fromJID:[iq from]]; + } + else if ([type isEqualToString:@"error"]) + { + [self handleDiscoErrorResponse:query fromJID:[iq from]]; + } + else + { + return NO; + } + + return YES; +} + +- (void)xmppStream:(XMPPStream *)sender willSendPresence:(XMPPPresence *)presence +{ + // This method is invoked on the moduleQueue. + + NSString *type = [presence type]; + + if ([type isEqualToString:@"unavailable"]) + { + [xmppCapabilitiesStorage clearAllNonPersistentCapabilitiesForXMPPStream:xmppStream]; + } + else if ([type isEqualToString:@"available"]) + { + if (myCapabilitiesQuery == nil) + { + // It appears we haven't collected our list of capabilites yet. + // This will need to be done before we can add the hash to the outgoing presence element. + + [self collectMyCapabilities]; + } + else if (myCapabilitiesC) + { + NSXMLElement *c = [[myCapabilitiesC copy] autorelease]; + + [presence addChild:c]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Timers +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setupTimeoutForDiscoRequestFromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // If the timeout occurs, we will remove the jid from the discoRequestJidSet. + // If we eventually get a response (after the timeout) we will still be able to process it. + // The timeout simply prevents the set from growing infinitely. + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(timer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self processTimeoutWithJID:jid]; + + dispatch_source_cancel(timer); + dispatch_release(timer); + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (CAPABILITIES_REQUEST_TIMEOUT * NSEC_PER_SEC)); + + dispatch_source_set_timer(timer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timer); + + // We also keep a reference to the timer in the discoTimerJidDict. + // This allows us to cancel the timer when we get a response to the disco request. + + GCDTimerWrapper *timerWrapper = [[GCDTimerWrapper alloc] initWithDispatchTimer:timer]; + + [discoTimerJidDict setObject:timerWrapper forKey:jid]; + [timerWrapper release]; +} + +- (void)setupTimeoutForDiscoRequestFromJID:(XMPPJID *)jid withHashKey:(NSString *)key +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // If the timeout occurs, we want to send a request to the next jid with the same capabilities hash. + // This list of jids is stored in the discoRequestHashDict. + // The key will allow us to fetch the jid list. + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(timer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self processTimeoutWithHashKey:key]; + + dispatch_source_cancel(timer); + dispatch_release(timer); + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (CAPABILITIES_REQUEST_TIMEOUT * NSEC_PER_SEC)); + + dispatch_source_set_timer(timer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timer); + + // We also keep a reference to the timer in the discoTimerJidDict. + // This allows us to cancel the timer when we get a response to the disco request. + + GCDTimerWrapper *timerWrapper = [[GCDTimerWrapper alloc] initWithDispatchTimer:timer]; + + [discoTimerJidDict setObject:timerWrapper forKey:jid]; + [timerWrapper release]; +} + +- (void)cancelTimeoutForDiscoRequestFromJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + GCDTimerWrapper *timerWrapper = [discoTimerJidDict objectForKey:jid]; + if (timerWrapper) + { + [timerWrapper cancel]; + [discoTimerJidDict removeObjectForKey:jid]; + } +} + +- (void)processTimeoutWithHashKey:(NSString *)key +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + [self maybeQueryNextJidWithHashKey:key dueToHashMismatch:NO]; +} + +- (void)processTimeoutWithJID:(XMPPJID *)jid +{ + // This method must be invoked on the moduleQueue + NSAssert(dispatch_get_current_queue() == moduleQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // We queried the jid for its capabilities, but it didn't answer us. + // Nothing left to do now but wait. + // + // If it happens to eventually respond, + // then we'll still be able to process the capabilities properly. + // + // But at this point we're going to consider the query to be done. + // This prevents our discoRequestJidSet from growing infinitely, + // and also opens up the possibility of sending it another query in the future. + + [discoRequestJidSet removeObject:jid]; + [xmppCapabilitiesStorage setCapabilitiesFetchFailedForJID:jid xmppStream:xmppStream]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation GCDTimerWrapper + +- (id)initWithDispatchTimer:(dispatch_source_t)aTimer +{ + if ((self = [super init])) + { + timer = aTimer; + dispatch_retain(timer); + } + return self; +} + +- (void)cancel +{ + if (timer) + { + dispatch_source_cancel(timer); + dispatch_release(timer); + timer = NULL; + } +} + +- (void)dealloc +{ + [self cancel]; + [super dealloc]; +} + +@end diff --git a/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.h b/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.h new file mode 100644 index 0000000..ceb5c5a --- /dev/null +++ b/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.h @@ -0,0 +1,80 @@ +// +// XMPPvCardAvatarModule.h +// XEP-0153 vCard-Based Avatars +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. + +/* + * NOTE: Currently this implementation only supports downloading and caching avatars. + */ + + +#import + +#if !TARGET_OS_IPHONE + #import +#endif + +#import "XMPPModule.h" +#import "XMPPvCardTempModule.h" + + +@class XMPPJID; +@class XMPPStream; + +@protocol XMPPvCardAvatarDelegate; +@protocol XMPPvCardAvatarStorage; + + +@interface XMPPvCardAvatarModule : XMPPModule +{ + XMPPvCardTempModule *_xmppvCardTempModule; + id _moduleStorage; +} + +@property(nonatomic,retain,readonly) XMPPvCardTempModule *xmppvCardTempModule; + + +- (id)initWithvCardTempModule:(XMPPvCardTempModule *)xmppvCardTempModule; +- (id)initWithvCardTempModule:(XMPPvCardTempModule *)xmppvCardTempModule dispatchQueue:(dispatch_queue_t)queue; + + +- (NSData *)photoDataForJID:(XMPPJID *)jid; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPvCardAvatarDelegate + +#if TARGET_OS_IPHONE +- (void)xmppvCardAvatarModule:(XMPPvCardAvatarModule *)vCardTempModule + didReceivePhoto:(UIImage *)photo + forJID:(XMPPJID *)jid; +#else +- (void)xmppvCardAvatarModule:(XMPPvCardAvatarModule *)vCardTempModule + didReceivePhoto:(NSImage *)photo + forJID:(XMPPJID *)jid; +#endif + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPvCardAvatarStorage + +- (NSData *)photoDataForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; +- (NSString *)photoHashForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +/** + * Clears the vCardTemp from the store. + * This is used so we can clear any cached vCardTemp's for the JID. + **/ +- (void)clearvCardTempForJID:(XMPPJID *)jid xmppStream:(XMPPStream *)stream; + +@end \ No newline at end of file diff --git a/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.m b/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.m new file mode 100644 index 0000000..1d20452 --- /dev/null +++ b/xmpp/Extensions/XEP-0153/XMPPvCardAvatarModule.m @@ -0,0 +1,257 @@ +// +// XMPPvCardAvatarModule.h +// XEP-0153 vCard-Based Avatars +// +// Created by Eric Chamberlain on 3/9/11. +// Copyright 2011 RF.com. All rights reserved. + + +// TODO: publish after upload vCard +/* + * XEP-0153 Section 4.2 rule 1 + * + * However, a client MUST advertise an image if it has just uploaded the vCard with a new avatar + * image. In this case, the client MAY choose not to redownload the vCard to verify its contents. + */ + +#import "XMPPvCardAvatarModule.h" + +#import "NSData+XMPP.h" +#import "NSXMLElement+XMPP.h" +#import "XMPPLogging.h" +#import "XMPPPresence.h" +#import "XMPPStream.h" +#import "XMPPvCardTempModule.h" + + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +NSString *const kXMPPvCardAvatarElement = @"x"; +NSString *const kXMPPvCardAvatarNS = @"vcard-temp:x:update"; +NSString *const kXMPPvCardAvatarPhotoElement = @"photo"; + + +@implementation XMPPvCardAvatarModule + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Init/dealloc +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)init +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPvCardAvatarModule.h are supported. + + return [self initWithvCardTempModule:nil dispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + // This will cause a crash - it's designed to. + // Only the init methods listed in XMPPvCardAvatarModule.h are supported. + + return [self initWithvCardTempModule:nil dispatchQueue:NULL]; +} + +- (id)initWithvCardTempModule:(XMPPvCardTempModule *)xmppvCardTempModule +{ + return [self initWithvCardTempModule:xmppvCardTempModule dispatchQueue:NULL]; +} + +- (id)initWithvCardTempModule:(XMPPvCardTempModule *)xmppvCardTempModule dispatchQueue:(dispatch_queue_t)queue +{ + NSParameterAssert(xmppvCardTempModule != nil); + + if ((self = [super initWithDispatchQueue:queue])) { + _xmppvCardTempModule = [xmppvCardTempModule retain]; + + // we don't need to call the storage configureWithParent:queue: method, + // because the vCardTempModule already did that. + _moduleStorage = [(id )xmppvCardTempModule.moduleStorage retain]; + + [_xmppvCardTempModule addDelegate:self delegateQueue:moduleQueue]; + } + return self; +} + + +- (void)dealloc { + [_xmppvCardTempModule removeDelegate:self]; + + [_moduleStorage release]; + _moduleStorage = nil; + + [_xmppvCardTempModule release]; + _xmppvCardTempModule = nil; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Public +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSData *)photoDataForJID:(XMPPJID *)jid +{ + // This is a public method, so it may be invoked on any thread/queue. + // + // The vCardTempModule is thread safe. + // The moduleStorage should be thread safe. (User may be using custom module storage class). + // The multicastDelegate is NOT thread safe. + + __block NSData *photoData; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + photoData = [[_moduleStorage photoDataForJID:jid xmppStream:xmppStream] retain]; + + if (photoData == nil) + { + [_xmppvCardTempModule fetchvCardTempForJID:jid useCache:YES]; + } + else + { + #if TARGET_OS_IPHONE + UIImage *photo = [UIImage imageWithData:photoData]; + #else + NSImage *photo = [[[NSImage alloc] initWithData:photoData] autorelease]; + #endif + + [multicastDelegate xmppvCardAvatarModule:self + didReceivePhoto:photo + forJID:jid]; + } + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + return [photoData autorelease]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStreamDelegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppStreamWillConnect:(XMPPStream *)sender { + XMPPLogTrace(); + /* + * XEP-0153 Section 4.2 rule 1 + * + * A client MUST NOT advertise an avatar image without first downloading the current vCard. + * Once it has done this, it MAY advertise an image. + */ + [_moduleStorage clearvCardTempForJID:[sender myJID] xmppStream:xmppStream]; +} + + +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender { + XMPPLogTrace(); + [_xmppvCardTempModule fetchvCardTempForJID:[sender myJID] useCache:NO]; +} + + +- (void)xmppStream:(XMPPStream *)sender willSendPresence:(XMPPPresence *)presence { + XMPPLogTrace(); + + // add our photo info to the presence stanza + NSXMLElement *photoElement = nil; + NSXMLElement *xElement = [NSXMLElement elementWithName:kXMPPvCardAvatarElement xmlns:kXMPPvCardAvatarNS]; + + NSString *photoHash = [_moduleStorage photoHashForJID:[sender myJID] xmppStream:xmppStream]; + + if (photoHash != nil) { + photoElement = [NSXMLElement elementWithName:kXMPPvCardAvatarPhotoElement stringValue:photoHash]; + } else { + photoElement = [NSXMLElement elementWithName:kXMPPvCardAvatarPhotoElement]; + } + + [xElement addChild:photoElement]; + [presence addChild:xElement]; + + // Question: If photoElement is nil, should we be adding xElement? +} + + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence { + XMPPLogTrace(); + + NSXMLElement *xElement = [presence elementForName:kXMPPvCardAvatarElement xmlns:kXMPPvCardAvatarNS]; + + if (xElement == nil) { + return; + } + + NSString *photoHash = [[xElement elementForName:kXMPPvCardAvatarPhotoElement] stringValue]; + + if (photoHash == nil || [photoHash isEqualToString:@""]) { + return; + } + + XMPPJID *jid = [presence from]; + + // check the hash + if (![photoHash isEqualToString:[_moduleStorage photoHashForJID:jid xmppStream:xmppStream]]) { + [_xmppvCardTempModule fetchvCardTempForJID:jid useCache:NO]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPvCardTempModuleDelegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppvCardTempModule:(XMPPvCardTempModule *)vCardTempModule + didReceivevCardTemp:(XMPPvCardTemp *)vCardTemp + forJID:(XMPPJID *)jid +{ + XMPPLogTrace(); + + if (vCardTemp.photo != nil) + { + #if TARGET_OS_IPHONE + UIImage *photo = [UIImage imageWithData:vCardTemp.photo]; + #else + NSImage *photo = [[[NSImage alloc] initWithData:vCardTemp.photo] autorelease]; + #endif + + if (photo != nil) + { + [multicastDelegate xmppvCardAvatarModule:self + didReceivePhoto:photo + forJID:jid]; + } + } + + /* + * XEP-0153 4.1.3 + * If the client subsequently obtains an avatar image (e.g., by updating or retrieving the vCard), + * it SHOULD then publish a new stanza with character data in the element. + */ + if ([jid isEqual:[[xmppStream myJID] bareJID]]) + { + XMPPPresence *presence = xmppStream.myPresence; + if(presence) { + [xmppStream sendElement:presence]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Getter/setter +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@synthesize xmppvCardTempModule = _xmppvCardTempModule; + + +@end diff --git a/xmpp/Extensions/XEP-0199/XMPPAutoPing.h b/xmpp/Extensions/XEP-0199/XMPPAutoPing.h new file mode 100644 index 0000000..ba49d6f --- /dev/null +++ b/xmpp/Extensions/XEP-0199/XMPPAutoPing.h @@ -0,0 +1,87 @@ +#import +#import "XMPPModule.h" +#import "XMPPPing.h" + +@class XMPPJID; + +/** + * The XMPPAutoPing module sends pings on a designated interval to the target. + * The target may simply be the server, or a specific resource. + * + * The module only sends pings as needed. + * If the xmpp stream is receiving data from the target, there's no need to send a ping. + * Only when no data has been received from the target is a ping sent. +**/ + +@interface XMPPAutoPing : XMPPModule { +@private + NSTimeInterval pingInterval; + NSTimeInterval pingTimeout; + XMPPJID *targetJID; + NSString *targetJIDStr; + + dispatch_time_t lastReceiveTime; + dispatch_source_t pingIntervalTimer; + BOOL awaitingPingResponse; + + XMPPPing *xmppPing; +} + +/** + * How often to send a ping. + * + * The internal timer fires every (pingInterval / 4) seconds. + * Upon firing it checks when data was last received from the target, + * and sends a ping if the elapsed time has exceeded the pingInterval. + * Thus the effective resolution of the timer is based on the configured interval. + * + * To temporarily disable auto-ping, set the interval to zero. + * + * The default pingInterval is 60 seconds. +**/ +@property (readwrite) NSTimeInterval pingInterval; + +/** + * How long to wait after sending a ping before timing out. + * + * The timeout is decoupled from the pingInterval to allow for longer pingIntervals, + * which avoids flooding the network, and to allow more precise control overall. + * + * After a ping is sent, if a reply is not received by this timeout, + * the delegate method is invoked. + * + * The default pingTimeout is 10 seconds. +**/ +@property (readwrite) NSTimeInterval pingTimeout; + +/** + * The target to send pings to. + * + * If the targetJID is nil, this implies the target is the xmpp server we're connected to. + * In this case, receiving any data means we've received data from the target. + * + * If the targetJID is non-nil, it must be a full JID (user@domain.tld/rsrc). + * In this case, the module will monitor the stream for data from the given JID. + * + * The default targetJID is nil. +**/ +@property (readwrite, retain) XMPPJID *targetJID; + +/** + * The last time data was received from the target. +**/ +@property (readonly) dispatch_time_t lastReceiveTime; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPAutoPingDelegate +@optional + +- (void)xmppAutoPingDidSendPing:(XMPPAutoPing *)sender; +- (void)xmppAutoPingDidReceivePong:(XMPPAutoPing *)sender; + +- (void)xmppAutoPingDidTimeout:(XMPPAutoPing *)sender; + +@end diff --git a/xmpp/Extensions/XEP-0199/XMPPAutoPing.m b/xmpp/Extensions/XEP-0199/XMPPAutoPing.m new file mode 100644 index 0000000..02dc5bc --- /dev/null +++ b/xmpp/Extensions/XEP-0199/XMPPAutoPing.m @@ -0,0 +1,406 @@ +#import "XMPPAutoPing.h" +#import "XMPPPing.h" +#import "XMPP.h" +#import "XMPPLogging.h" + +// Log levels: off, error, warn, info, verbose +// Log flags: trace +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +@interface XMPPAutoPing () +- (void)updatePingIntervalTimer; +- (void)startPingIntervalTimer; +- (void)stopPingIntervalTimer; +@end + +#pragma mark - + +@implementation XMPPAutoPing + +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super initWithDispatchQueue:queue])) + { + pingInterval = 60; + pingTimeout = 10; + + lastReceiveTime = DISPATCH_TIME_FOREVER; + + xmppPing = [[XMPPPing alloc] initWithDispatchQueue:queue]; + xmppPing.respondsToQueries = NO; + + [xmppPing addDelegate:self delegateQueue:moduleQueue]; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + [xmppPing activate:aXmppStream]; + + return YES; + } + + return NO; +} + +- (void)deactivate +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self stopPingIntervalTimer]; + + lastReceiveTime = DISPATCH_TIME_FOREVER; + awaitingPingResponse = NO; + + [xmppPing deactivate]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + [super deactivate]; +} + +- (void)dealloc +{ + [targetJID release]; + [targetJIDStr release]; + + [self stopPingIntervalTimer]; + + [xmppPing removeDelegate:self]; + [xmppPing release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSTimeInterval)pingInterval +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return pingInterval; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(moduleQueue, ^{ + result = pingInterval; + }); + return result; + } +} + +- (void)setPingInterval:(NSTimeInterval)interval +{ + dispatch_block_t block = ^{ + + if (pingInterval != interval) + { + pingInterval = interval; + + // Update the pingTimer. + // Depending on new value this may mean starting, stoping, or simply updating the timer. + + if (pingIntervalTimer) + { + if (pingInterval > 0) + { + // Remember: Only start the pinger after the xmpp stream is up and authenticated + if ([xmppStream isAuthenticated]) + [self updatePingIntervalTimer]; + } + else + { + [self stopPingIntervalTimer]; + } + } + else if (pingInterval > 0) + { + [self startPingIntervalTimer]; + } + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (NSTimeInterval)pingTimeout +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return pingTimeout; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(moduleQueue, ^{ + result = pingTimeout; + }); + return result; + } +} + +- (void)setPingTimeout:(NSTimeInterval)timeout +{ + dispatch_block_t block = ^{ + + if (pingTimeout != timeout) + { + pingTimeout = timeout; + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (XMPPJID *)targetJID +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return targetJID; + } + else + { + __block XMPPJID *result; + + dispatch_sync(moduleQueue, ^{ + result = [targetJID retain]; + }); + return [result autorelease]; + } +} + +- (void)setTargetJID:(XMPPJID *)jid +{ + dispatch_block_t block = ^{ + + if (![targetJID isEqual:jid]) + { + [targetJID release]; + targetJID = [jid retain]; + + [targetJIDStr release]; + targetJIDStr = [[targetJID full] retain]; + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (dispatch_time_t)lastReceiveTime +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return lastReceiveTime; + } + else + { + __block dispatch_time_t result; + + dispatch_sync(moduleQueue, ^{ + result = lastReceiveTime; + }); + return result; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Ping Interval +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)handlePingIntervalTimerFire +{ + if (awaitingPingResponse) return; + + BOOL sendPing = NO; + + if (lastReceiveTime == DISPATCH_TIME_FOREVER) + { + sendPing = YES; + } + else + { + dispatch_time_t now = dispatch_time(DISPATCH_TIME_NOW, 0); + NSTimeInterval elapsed = ((double)(now - lastReceiveTime) / (double)NSEC_PER_SEC); + + XMPPLogTrace2(@"%@: %@ - elapsed(%f)", [self class], THIS_METHOD, elapsed); + + sendPing = (elapsed >= pingInterval); + } + + if (sendPing) + { + awaitingPingResponse = YES; + + if (targetJID) + [xmppPing sendPingToJID:targetJID withTimeout:pingTimeout]; + else + [xmppPing sendPingToServerWithTimeout:pingTimeout]; + + [multicastDelegate xmppAutoPingDidSendPing:self]; + } +} + +- (void)updatePingIntervalTimer +{ + XMPPLogTrace(); + + NSAssert(pingIntervalTimer != NULL, @"Broken logic (1)"); + NSAssert(pingInterval > 0, @"Broken logic (2)"); + + + uint64_t interval = ((pingInterval / 4.0) * NSEC_PER_SEC); + dispatch_time_t tt; + + if (lastReceiveTime != DISPATCH_TIME_FOREVER) + tt = dispatch_time(lastReceiveTime, interval); + else + tt = dispatch_time(DISPATCH_TIME_NOW, interval); + + dispatch_source_set_timer(pingIntervalTimer, tt, interval, 0); +} + +- (void)startPingIntervalTimer +{ + XMPPLogTrace(); + + if (pingInterval <= 0) + { + // Pinger is disabled + return; + } + + BOOL newTimer = NO; + + if (pingIntervalTimer == NULL) + { + newTimer = YES; + pingIntervalTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(pingIntervalTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self handlePingIntervalTimerFire]; + + [pool drain]; + }); + } + + [self updatePingIntervalTimer]; + + if (newTimer) + { + dispatch_resume(pingIntervalTimer); + } +} + +- (void)stopPingIntervalTimer +{ + XMPPLogTrace(); + + if (pingIntervalTimer) + { + dispatch_release(pingIntervalTimer); + pingIntervalTimer = NULL; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPPing Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppPing:(XMPPPing *)sender didReceivePong:(XMPPIQ *)pong withRTT:(NSTimeInterval)rtt +{ + XMPPLogTrace(); + + awaitingPingResponse = NO; + [multicastDelegate xmppAutoPingDidReceivePong:self]; +} + +- (void)xmppPing:(XMPPPing *)sender didNotReceivePong:(NSString *)pingID dueToTimeout:(NSTimeInterval)timeout +{ + XMPPLogTrace(); + + awaitingPingResponse = NO; + [multicastDelegate xmppAutoPingDidTimeout:self]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XMPPStream Delegate +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)xmppStreamDidAuthenticate:(XMPPStream *)sender +{ + lastReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + awaitingPingResponse = NO; + + [self startPingIntervalTimer]; +} + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + if (targetJID == nil || [targetJIDStr isEqualToString:[iq fromStr]]) + { + lastReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + } + + return NO; +} + +- (void)xmppStream:(XMPPStream *)sender didReceiveMessage:(XMPPMessage *)message +{ + if (targetJID == nil || [targetJIDStr isEqualToString:[message fromStr]]) + { + lastReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + } +} + +- (void)xmppStream:(XMPPStream *)sender didReceivePresence:(XMPPPresence *)presence +{ + if (targetJID == nil || [targetJIDStr isEqualToString:[presence fromStr]]) + { + lastReceiveTime = dispatch_time(DISPATCH_TIME_NOW, 0); + } +} + +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error +{ + [self stopPingIntervalTimer]; + + lastReceiveTime = DISPATCH_TIME_FOREVER; + awaitingPingResponse = NO; +} + +@end diff --git a/xmpp/Extensions/XEP-0199/XMPPPing.h b/xmpp/Extensions/XEP-0199/XMPPPing.h new file mode 100644 index 0000000..0f441d3 --- /dev/null +++ b/xmpp/Extensions/XEP-0199/XMPPPing.h @@ -0,0 +1,52 @@ +#import +#import "XMPPModule.h" + +@class XMPPJID; +@class XMPPStream; +@class XMPPIQ; +@protocol XMPPPingDelegate; + + +@interface XMPPPing : XMPPModule +{ + BOOL respondsToQueries; + NSMutableDictionary *pingIDs; +} + +/** + * Whether or not the module should respond to incoming ping queries. + * It you create multiple instances of this module, only one instance should respond to queries. + * + * It is recommended you set this (if needed) before you activate the module. + * The default value is YES. +**/ +@property (readwrite) BOOL respondsToQueries; + +/** + * Send pings to the server or a specific JID. + * The disco module may be used to detect if the target supports ping. + * + * The returned string is the pingID (the elementID of the query that was sent). + * In other words: + * + * SEND: + * RECV: + * + * This may be helpful if you are sending multiple simultaneous pings to the same target. +**/ +- (NSString *)sendPingToServer; +- (NSString *)sendPingToServerWithTimeout:(NSTimeInterval)timeout; +- (NSString *)sendPingToJID:(XMPPJID *)jid; +- (NSString *)sendPingToJID:(XMPPJID *)jid withTimeout:(NSTimeInterval)timeout; + +@end + +@protocol XMPPPingDelegate +@optional + +- (void)xmppPing:(XMPPPing *)sender didReceivePong:(XMPPIQ *)pong withRTT:(NSTimeInterval)rtt; +- (void)xmppPing:(XMPPPing *)sender didNotReceivePong:(NSString *)pingID dueToTimeout:(NSTimeInterval)timeout; + +// Note: If the xmpp stream is disconnected, no delegate methods will be called, and outstanding pings are forgotten. + +@end diff --git a/xmpp/Extensions/XEP-0199/XMPPPing.m b/xmpp/Extensions/XEP-0199/XMPPPing.m new file mode 100644 index 0000000..03bc709 --- /dev/null +++ b/xmpp/Extensions/XEP-0199/XMPPPing.m @@ -0,0 +1,403 @@ +#import "XMPPPing.h" +#import "XMPP.h" + +#define DEFAULT_TIMEOUT 30.0 // seconds + +#define INTEGRATE_WITH_CAPABILITIES 1 + +#if INTEGRATE_WITH_CAPABILITIES + #import "XMPPCapabilities.h" +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPPingInfo : NSObject +{ + NSDate *timeSent; + NSTimeInterval timeout; + dispatch_source_t timer; +} + ++ (XMPPPingInfo *)pingInfoWithTimeout:(NSTimeInterval)timeout timer:(dispatch_source_t)timer; + +@property (nonatomic, readonly) NSDate *timeSent; +@property (nonatomic, readonly) NSTimeInterval timeout; +@property (nonatomic, readonly) dispatch_source_t timer; + +- (NSTimeInterval)rtt; + +- (void)cancelTimer; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPPing + +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super initWithDispatchQueue:queue])) + { + pingIDs = [[NSMutableDictionary alloc] initWithCapacity:5]; + respondsToQueries = YES; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + #if INTEGRATE_WITH_CAPABILITIES + [xmppStream autoAddDelegate:self delegateQueue:moduleQueue toModulesOfClass:[XMPPCapabilities class]]; + #endif + + return YES; + } + + return NO; +} + +- (void)deactivate +{ +#if INTEGRATE_WITH_CAPABILITIES + [xmppStream removeAutoDelegate:self delegateQueue:moduleQueue fromModulesOfClass:[XMPPCapabilities class]]; +#endif + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + for (XMPPPingInfo *pingInfo in [pingIDs objectEnumerator]) + { + [pingInfo cancelTimer]; + } + + [pingIDs removeAllObjects]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + [super deactivate]; +} + +- (void)dealloc +{ + [pingIDs release]; + [super dealloc]; +} + +- (BOOL)respondsToQueries +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return respondsToQueries; + } + else + { + __block BOOL result; + + dispatch_sync(moduleQueue, ^{ + result = respondsToQueries; + }); + return result; + } +} + +- (void)setRespondsToQueries:(BOOL)flag +{ + dispatch_block_t block = ^{ + + if (respondsToQueries != flag) + { + respondsToQueries = flag; + + #if INTEGRATE_WITH_CAPABILITIES + // Capabilities may have changed, need to notify others. + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPPresence *presence = xmppStream.myPresence; + if (presence) + { + [xmppStream sendElement:presence]; + } + + [pool drain]; + #endif + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)removePingID:(NSString *)pingID +{ + // This method is invoked on the moduleQueue. + + XMPPPingInfo *pingInfo = [pingIDs objectForKey:pingID]; + if (pingInfo) + { + [pingInfo retain]; + [pingIDs removeObjectForKey:pingID]; + + [multicastDelegate xmppPing:self didNotReceivePong:pingID dueToTimeout:[pingInfo timeout]]; + + [pingInfo cancelTimer]; + [pingInfo release]; + } +} + +- (NSString *)generatePingIDWithTimeout:(NSTimeInterval)timeout +{ + // This method may be invoked on any thread/queue. + + // Generate unique ID for Ping packet + // It's important the ID be unique as the ID is the only thing that distinguishes a pong packet + + NSString *pingID = [xmppStream generateUUID]; + + dispatch_async(moduleQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // In case we never get a response, we want to remove the ping ID eventually, + // or we risk an ever increasing pingIDs array. + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(timer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self removePingID:pingID]; + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(timer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timer); + + // Add ping ID to list so we'll recognize it when we get a response + [pingIDs setObject:[XMPPPingInfo pingInfoWithTimeout:timeout timer:timer] + forKey:pingID]; + + dispatch_release(timer); + [pool release]; + }); + + return pingID; +} + +- (NSString *)sendPingToServer +{ + // This is a public method. + // It may be invoked on any thread/queue. + + return [self sendPingToServerWithTimeout:DEFAULT_TIMEOUT]; +} + +- (NSString *)sendPingToServerWithTimeout:(NSTimeInterval)timeout +{ + // This is a public method. + // It may be invoked on any thread/queue. + + NSString *pingID = [self generatePingIDWithTimeout:timeout]; + + // Send ping packet + // + // + // + // + + NSXMLElement *ping = [NSXMLElement elementWithName:@"ping" xmlns:@"urn:xmpp:ping"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:nil elementID:pingID child:ping]; + + [xmppStream sendElement:iq]; + + return pingID; +} + +- (NSString *)sendPingToJID:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + return [self sendPingToJID:jid withTimeout:DEFAULT_TIMEOUT]; +} + +- (NSString *)sendPingToJID:(XMPPJID *)jid withTimeout:(NSTimeInterval)timeout +{ + // This is a public method. + // It may be invoked on any thread/queue. + + NSString *pingID = [self generatePingIDWithTimeout:timeout]; + + // Send ping element + // + // + // + // + + NSXMLElement *ping = [NSXMLElement elementWithName:@"ping" xmlns:@"urn:xmpp:ping"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:jid elementID:pingID child:ping]; + + [xmppStream sendElement:iq]; + + return pingID; +} + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // This method is invoked on the moduleQueue. + + NSString *type = [[iq attributeForName:@"type"] stringValue]; + + if ([type isEqualToString:@"result"] || [type isEqualToString:@"error"]) + { + // Example: + // + // + + NSString *pingID = [iq elementID]; + + XMPPPingInfo *pingInfo = [pingIDs objectForKey:pingID]; + if (pingInfo) + { + [pingInfo retain]; + [pingIDs removeObjectForKey:pingID]; + + [multicastDelegate xmppPing:self didReceivePong:iq withRTT:[pingInfo rtt]]; + + [pingInfo cancelTimer]; + [pingInfo release]; + } + } + else if (respondsToQueries && [type isEqualToString:@"get"]) + { + // Example: + // + // + // + // + + NSXMLElement *ping = [iq elementForName:@"ping" xmlns:@"urn:xmpp:ping"]; + if (ping) + { + XMPPIQ *pong = [XMPPIQ iqWithType:@"result" to:[iq from] elementID:[iq elementID]]; + + [sender sendElement:pong]; + + return YES; + } + } + + return NO; +} + +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error +{ + for (XMPPPingInfo *pingInfo in [pingIDs objectEnumerator]) + { + [pingInfo cancelTimer]; + } + + [pingIDs removeAllObjects]; +} + +#if INTEGRATE_WITH_CAPABILITIES +/** + * If an XMPPCapabilites instance is used we want to advertise our support for ping. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender collectingMyCapabilities:(NSXMLElement *)query +{ + // This method is invoked on the moduleQueue. + + if (respondsToQueries) + { + // + // ... + // + // ... + // + + NSXMLElement *feature = [NSXMLElement elementWithName:@"feature"]; + [feature addAttributeWithName:@"var" stringValue:@"urn:xmpp:ping"]; + + [query addChild:feature]; + } +} +#endif + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPPingInfo + +@synthesize timeSent; +@synthesize timeout; +@synthesize timer; + +- (id)initWithTimeout:(NSTimeInterval)to timer:(dispatch_source_t)aTimer +{ + if ((self = [super init])) + { + timeSent = [[NSDate alloc] init]; + timeout = to; + + timer = aTimer; + dispatch_retain(timer); + } + return self; +} + +- (NSTimeInterval)rtt +{ + return [timeSent timeIntervalSinceNow] * -1.0; +} + +- (void)cancelTimer +{ + if (timer) + { + dispatch_source_cancel(timer); + dispatch_release(timer); + timer = NULL; + } +} + +- (void)dealloc +{ + [self cancelTimer]; + [timeSent release]; + [super dealloc]; +} + + ++ (XMPPPingInfo *)pingInfoWithTimeout:(NSTimeInterval)timeout timer:(dispatch_source_t)timer +{ + return [[[XMPPPingInfo alloc] initWithTimeout:timeout timer:timer] autorelease]; +} + +@end diff --git a/xmpp/Extensions/XEP-0202/XMPPTime.h b/xmpp/Extensions/XEP-0202/XMPPTime.h new file mode 100644 index 0000000..961af99 --- /dev/null +++ b/xmpp/Extensions/XEP-0202/XMPPTime.h @@ -0,0 +1,94 @@ +#import +#import "XMPPModule.h" + +#if TARGET_OS_IPHONE + #import "DDXML.h" +#endif + +@class XMPPJID; +@class XMPPStream; +@class XMPPIQ; +@protocol XMPPTimeDelegate; + + +@interface XMPPTime : XMPPModule +{ + BOOL respondsToQueries; + NSMutableDictionary *queryIDs; +} + +/** + * Whether or not the module should respond to incoming time queries. + * It you create multiple instances of this module, only one instance should respond to queries. + * + * It is recommended you set this (if needed) before you activate the module. + * The default value is YES. +**/ +@property (readwrite) BOOL respondsToQueries; + +/** + * Send query to the server or a specific JID. + * The disco module may be used to detect if the target supports this XEP. + * + * The returned string is the queryID (the elementID of the query that was sent). + * In other words: + * + * SEND: + * RECV: + * + * This may be helpful if you are sending multiple simultaneous queries to the same target. +**/ +- (NSString *)sendQueryToServer; +- (NSString *)sendQueryToServerWithTimeout:(NSTimeInterval)timeout; +- (NSString *)sendQueryToJID:(XMPPJID *)jid; +- (NSString *)sendQueryToJID:(XMPPJID *)jid withTimeout:(NSTimeInterval)timeout; + +/** + * Extracts the utc date from the given response/time element, + * and returns an NSDate representation of the time in the local time zone. + * Since the returned date is in the local time zone, it is suitable for presentation. +**/ ++ (NSDate *)dateFromResponse:(XMPPIQ *)iq; + +/** + * Extracts the time zone offset from the given response/time element. +**/ ++ (NSTimeZone *)timeZoneOffsetFromResponse:(XMPPIQ *)iq; + +/** + * Given the returned time response from a remote party, and the approximate round trip time, + * calculates the difference between our clock and the remote party's clock. + * + * This is NOT a reference to the difference in time zones. + * Time zone differences generally shouldn't matter as xmpp standards mandate the use of UTC. + * + * Rather this is the difference between our UTC time, and the remote party's UTC time. + * If the two clocks are not synchronized, then the result represents the approximate difference. + * + * If our clock is earlier than the remote clock, then the result will be negative. + * If our clock is ahead of the remote clock, then the result will be positive. + * + * If you later receive a timestamp from the remote party, you could add the diff. + * For example: + * + * myTime = [givenTimeFromRemoteParty dateByAddingTimeInterval:diff]; +**/ ++ (NSTimeInterval)approximateTimeDifferenceFromResponse:(XMPPIQ *)iq andRTT:(NSTimeInterval)rtt; + +/** + * Creates and returns a time element. +**/ ++ (NSXMLElement *)timeElement; ++ (NSXMLElement *)timeElementFromDate:(NSDate *)date; + +@end + +@protocol XMPPTimeDelegate +@optional + +- (void)xmppTime:(XMPPTime *)sender didReceiveResponse:(XMPPIQ *)iq withRTT:(NSTimeInterval)rtt; +- (void)xmppTime:(XMPPTime *)sender didNotReceiveResponse:(NSString *)queryID dueToTimeout:(NSTimeInterval)timeout; + +// Note: If the xmpp stream is disconnected, no delegate methods will be called, and outstanding queries are forgotten. + +@end diff --git a/xmpp/Extensions/XEP-0202/XMPPTime.m b/xmpp/Extensions/XEP-0202/XMPPTime.m new file mode 100644 index 0000000..7a7adae --- /dev/null +++ b/xmpp/Extensions/XEP-0202/XMPPTime.m @@ -0,0 +1,595 @@ +#import "XMPPTime.h" +#import "XMPP.h" +#import "XMPPDateTimeProfiles.h" + +#define INTEGRATE_WITH_CAPABILITIES 1 + +#if INTEGRATE_WITH_CAPABILITIES + #import "XMPPCapabilities.h" +#endif + +#define DEFAULT_TIMEOUT 30.0 // seconds + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPTimeQueryInfo : NSObject +{ + NSDate *timeSent; + NSTimeInterval timeout; + dispatch_source_t timer; +} + ++ (XMPPTimeQueryInfo *)queryInfoWithTimeout:(NSTimeInterval)timeout timer:(dispatch_source_t)timer; + +@property (nonatomic, readonly) NSDate *timeSent; +@property (nonatomic, readonly) NSTimeInterval timeout; +@property (nonatomic, readonly) dispatch_source_t timer; + +- (NSTimeInterval)rtt; + +- (void)cancelTimer; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPTime + +- (id)init +{ + return [self initWithDispatchQueue:NULL]; +} + +- (id)initWithDispatchQueue:(dispatch_queue_t)queue +{ + if ((self = [super initWithDispatchQueue:queue])) + { + queryIDs = [[NSMutableDictionary alloc] initWithCapacity:5]; + respondsToQueries = YES; + } + return self; +} + +- (BOOL)activate:(XMPPStream *)aXmppStream +{ + if ([super activate:aXmppStream]) + { + #if INTEGRATE_WITH_CAPABILITIES + [xmppStream autoAddDelegate:self delegateQueue:moduleQueue toModulesOfClass:[XMPPCapabilities class]]; + #endif + + return YES; + } + + return NO; +} + +- (void)deactivate +{ +#if INTEGRATE_WITH_CAPABILITIES + [xmppStream removeAutoDelegate:self delegateQueue:moduleQueue fromModulesOfClass:[XMPPCapabilities class]]; +#endif + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + for (XMPPTimeQueryInfo *queryInfo in [queryIDs objectEnumerator]) + { + [queryInfo cancelTimer]; + } + + [queryIDs removeAllObjects]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_sync(moduleQueue, block); + + [super deactivate]; +} + +- (void)dealloc +{ + [queryIDs release]; + [super dealloc]; +} + +- (BOOL)respondsToQueries +{ + if (dispatch_get_current_queue() == moduleQueue) + { + return respondsToQueries; + } + else + { + __block BOOL result; + + dispatch_sync(moduleQueue, ^{ + result = respondsToQueries; + }); + return result; + } +} + +- (void)setRespondsToQueries:(BOOL)flag +{ + dispatch_block_t block = ^{ + + if (respondsToQueries != flag) + { + respondsToQueries = flag; + + #if INTEGRATE_WITH_CAPABILITIES + // Capabilities may have changed, need to notify others. + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPPresence *presence = xmppStream.myPresence; + if (presence) + { + [xmppStream sendElement:presence]; + } + + [pool drain]; + #endif + } + }; + + if (dispatch_get_current_queue() == moduleQueue) + block(); + else + dispatch_async(moduleQueue, block); +} + +- (void)removeQueryID:(NSString *)queryID +{ + // This method is invoked on the moduleQueue. + + XMPPTimeQueryInfo *queryInfo = [queryIDs objectForKey:queryID]; + if (queryInfo) + { + [queryInfo retain]; + [queryIDs removeObjectForKey:queryID]; + + [multicastDelegate xmppTime:self didNotReceiveResponse:queryID dueToTimeout:[queryInfo timeout]]; + + [queryInfo cancelTimer]; + [queryInfo release]; + } +} + +- (NSString *)generateQueryIDWithTimeout:(NSTimeInterval)timeout +{ + // This method may be invoked on any thread/queue. + + // Generate unique ID for query. + // It's important the ID be unique as the ID is the + // only thing that distinguishes multiple queries from each other. + + NSString *queryID = [xmppStream generateUUID]; + + dispatch_async(moduleQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // In case we never get a response, we want to remove the query ID eventually, + // or we risk an ever increasing queryIDs array. + + dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, moduleQueue); + + dispatch_source_set_event_handler(timer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self removeQueryID:queryID]; + + [pool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(timer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timer); + + // Add query ID to list so we'll recognize it when we get a response + [queryIDs setObject:[XMPPTimeQueryInfo queryInfoWithTimeout:timeout timer:timer] + forKey:queryID]; + + [pool drain]; + }); + + return queryID; +} + +- (NSString *)sendQueryToServer +{ + // This is a public method. + // It may be invoked on any thread/queue. + + return [self sendQueryToServerWithTimeout:DEFAULT_TIMEOUT]; +} + +- (NSString *)sendQueryToServerWithTimeout:(NSTimeInterval)timeout +{ + // This is a public method. + // It may be invoked on any thread/queue. + + NSString *queryID = [self generateQueryIDWithTimeout:timeout]; + + // Send ping packet + // + // + // + // + // Note: Sometimes the to attribute is required. (ejabberd) + + NSXMLElement *time = [NSXMLElement elementWithName:@"time" xmlns:@"urn:xmpp:time"]; + XMPPJID *domainJID = [[xmppStream myJID] domainJID]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:domainJID elementID:queryID child:time]; + + [xmppStream sendElement:iq]; + + return queryID; +} + +- (NSString *)sendQueryToJID:(XMPPJID *)jid +{ + // This is a public method. + // It may be invoked on any thread/queue. + + return [self sendQueryToJID:jid withTimeout:DEFAULT_TIMEOUT]; +} + +- (NSString *)sendQueryToJID:(XMPPJID *)jid withTimeout:(NSTimeInterval)timeout +{ + // This is a public method. + // It may be invoked on any thread/queue. + + NSString *queryID = [self generateQueryIDWithTimeout:timeout]; + + // Send ping element + // + // + // + + NSXMLElement *time = [NSXMLElement elementWithName:@"time" xmlns:@"urn:xmpp:time"]; + + XMPPIQ *iq = [XMPPIQ iqWithType:@"get" to:jid elementID:queryID child:time]; + + [xmppStream sendElement:iq]; + + return queryID; +} + +- (BOOL)xmppStream:(XMPPStream *)sender didReceiveIQ:(XMPPIQ *)iq +{ + // This method is invoked on the moduleQueue. + + NSString *type = [iq type]; + + if ([type isEqualToString:@"result"] || [type isEqualToString:@"error"]) + { + // Examples: + // + // + // + // + // + // + // + + NSString *queryID = [iq elementID]; + + XMPPTimeQueryInfo *queryInfo = [queryIDs objectForKey:queryID]; + if (queryInfo) + { + [queryInfo retain]; + [queryIDs removeObjectForKey:queryID]; + + [multicastDelegate xmppTime:self didReceiveResponse:iq withRTT:[queryInfo rtt]]; + + [queryInfo cancelTimer]; + [queryInfo release]; + } + } + else if (respondsToQueries && [type isEqualToString:@"get"]) + { + // Example: + // + // + // + + NSXMLElement *time = [iq elementForName:@"time" xmlns:@"urn:xmpp:time"]; + if (time) + { + NSXMLElement *time = [[self class] timeElement]; + + XMPPIQ *response = [XMPPIQ iqWithType:@"result" to:[iq from] elementID:[iq elementID]]; + [response addChild:time]; + + [sender sendElement:response]; + + return YES; + } + } + + return NO; +} + +- (void)xmppStreamDidDisconnect:(XMPPStream *)sender withError:(NSError *)error +{ + for (XMPPTimeQueryInfo *queryInfo in [queryIDs objectEnumerator]) + { + [queryInfo cancelTimer]; + } + + [queryIDs removeAllObjects]; +} + +#if INTEGRATE_WITH_CAPABILITIES +/** + * If an XMPPCapabilites instance is used we want to advertise our support for XEP-0202. +**/ +- (void)xmppCapabilities:(XMPPCapabilities *)sender collectingMyCapabilities:(NSXMLElement *)query +{ + // This method is invoked on the moduleQueue. + + if (respondsToQueries) + { + // + // ... + // + // ... + // + + NSXMLElement *feature = [NSXMLElement elementWithName:@"feature"]; + [feature addAttributeWithName:@"var" stringValue:@"urn:xmpp:time"]; + + [query addChild:feature]; + } +} +#endif + ++ (NSDate *)dateFromResponse:(XMPPIQ *)iq +{ + // + // + // + + NSXMLElement *time = [iq elementForName:@"time" xmlns:@"urn:xmpp:time"]; + if (time == nil) return nil; + + NSString *utc = [[time elementForName:@"utc"] stringValue]; + if (utc == nil) return nil; + + // Note: + // + // NSDate is a very simple class, but can be confusing at times. + // NSDate simply stores an NSTimeInterval internally, + // which is just a double representing the number of seconds since the reference date. + // Since it's a double, it can yield sub-millisecond precision. + // + // In addition to this, it stores the values in UTC. + // However, if you print the value using NSLog via "%@", + // it will automatically print the date in the local timezone: + // + // NSDate *refDate = [NSDate dateWithTimeIntervalSinceReferenceDate:0.0]; + // + // NSLog(@"%f", [refDate timeIntervalSinceReferenceDate]); // Prints: 0.0 + // NSLog(@"%@", refDate); // Prints: 2000-12-31 19:00:00 -05:00 + // NSLog(@"%@", [utcDateFormatter stringFromDate:refDate]); // Prints: 2001-01-01 00:00:00 +00:00 + // + // Now the value we've received from XMPPDateTimeProfiles is correct. + // If we print it out using a utcDateFormatter we would see it is correct. + // If we printed it out generically using NSLog, then we would see it converted into our local time zone. + + return [XMPPDateTimeProfiles parseDateTime:utc]; +} + ++ (NSTimeZone *)timeZoneOffsetFromResponse:(XMPPIQ *)iq +{ + // + // + // + + NSXMLElement *time = [iq elementForName:@"time" xmlns:@"urn:xmpp:time"]; + if (time == nil) return 0; + + NSString *tzo = [[time elementForName:@"tzo"] stringValue]; + if (tzo == nil) return 0; + + return [XMPPDateTimeProfiles parseTimeZoneOffset:tzo]; +} + ++ (NSTimeInterval)approximateTimeDifferenceFromResponse:(XMPPIQ *)iq andRTT:(NSTimeInterval)rtt +{ + // First things first, get the current date and time + + NSDate *localDate = [NSDate date]; + + // Then worry about the calculations + + NSXMLElement *time = [iq elementForName:@"time" xmlns:@"urn:xmpp:time"]; + if (time == nil) return 0.0; + + NSString *utc = [[time elementForName:@"utc"] stringValue]; + if (utc == nil) return 0.0; + + NSDate *remoteDate = [XMPPDateTimeProfiles parseDateTime:utc]; + if (remoteDate == nil) return 0.0; + + NSTimeInterval localTI = [localDate timeIntervalSinceReferenceDate]; + NSTimeInterval remoteTI = [remoteDate timeIntervalSinceReferenceDate] - (rtt / 2.0); + + // Did the response contain millisecond precision? + // This is an important consideration. + // Imagine if both computers are perfectly synced, + // but the remote response doesn't contain milliseconds. + // This could possibly cause us to think the difference is close to a full second. + // + // DateTime examples (from XMPPDateTimeProfiles documentation): + // + // 1969-07-21T02:56:15 + // 1969-07-21T02:56:15Z + // 1969-07-20T21:56:15-05:00 + // 1969-07-21T02:56:15.123 + // 1969-07-21T02:56:15.123Z + // 1969-07-20T21:56:15.123-05:00 + + BOOL hasMilliseconds = ([utc length] > 19) && ([utc characterAtIndex:19] == '.'); + + if (hasMilliseconds) + { + return remoteTI - localTI; + } + else + { + // No milliseconds. What to do? + // + // We could simply truncate the milliseconds from our time... + // But this could make things much worse. + // For example: + // + // local = 14:22:36.750 + // remote = 14:22:37 + // + // If we truncate the result now we calculate a diff of 1.000 (a full second). + // Considering the remote's milliseconds could have been anything from 000 to 999, + // this means our calculations are: + // + // perfect : 0.1% chance + // diff too big : 75.0% chance + // diff too small : 24.9% chance + // + // Perhaps a better solution would give us a more even spread. + // We can do this by calculating the range: + // + // 37.000 - 36.750 = 0.25 + // 37.999 - 36.750 = 1.249 + // + // So a better guess of the diff is 0.750 (3/4 of a second): + // + // perfect : 0.1% chance + // diff too big : 50.0% chance + // diff too small : 49.9% chance + + NSTimeInterval diff1 = localTI - (remoteTI + 0.000); + NSTimeInterval diff2 = localTI - (remoteTI + 0.999); + + return ((diff1 + diff2) / 2.0); + } +} + ++ (NSXMLElement *)timeElement +{ + return [self timeElementFromDate:[NSDate date]]; +} + ++ (NSXMLElement *)timeElementFromDate:(NSDate *)date +{ + // + + NSDateFormatter *df = [[NSDateFormatter alloc] init]; + [df setFormatterBehavior:NSDateFormatterBehavior10_4]; // Use unicode patterns (as opposed to 10_3) + [df setDateFormat:@"yyyy-MM-dd'T'HH:mm:ss'Z'"]; + [df setTimeZone:[NSTimeZone timeZoneForSecondsFromGMT:0]]; + + NSString *utcValue = [df stringFromDate:date]; + + [df release]; + + NSInteger tzoInSeconds = [[NSTimeZone systemTimeZone] secondsFromGMTForDate:date]; + + NSInteger tzoH = tzoInSeconds / (60 * 60); + NSInteger tzoS = tzoInSeconds % (60 * 60); + + NSString *tzoValue = [NSString stringWithFormat:@"%+03li:%02li", (long)tzoH, (long)tzoS]; + + NSXMLElement *tzo = [NSXMLElement elementWithName:@"tzo" stringValue:tzoValue]; + NSXMLElement *utc = [NSXMLElement elementWithName:@"utc" stringValue:utcValue]; + + NSXMLElement *time = [NSXMLElement elementWithName:@"time" xmlns:@"urn:xmpp:time"]; + [time addChild:tzo]; + [time addChild:utc]; + + return time; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPTimeQueryInfo + +@synthesize timeSent; +@synthesize timeout; +@synthesize timer; + +- (id)initWithTimeout:(NSTimeInterval)to timer:(dispatch_source_t)aTimer +{ + if ((self = [super init])) + { + timeSent = [[NSDate alloc] init]; + timeout = to; + + timer = aTimer; + dispatch_retain(timer); + } + return self; +} + +- (NSTimeInterval)rtt +{ + return [timeSent timeIntervalSinceNow] * -1.0; +} + +- (void)cancelTimer +{ + if (timer) + { + dispatch_source_cancel(timer); + dispatch_release(timer); + timer = NULL; + } +} + +- (void)dealloc +{ + [self cancelTimer]; + [timeSent release]; + [super dealloc]; +} + ++ (XMPPTimeQueryInfo *)queryInfoWithTimeout:(NSTimeInterval)timeout timer:(dispatch_source_t)timer +{ + return [[[XMPPTimeQueryInfo alloc] initWithTimeout:timeout timer:timer] autorelease]; +} + +@end diff --git a/xmpp/Extensions/XEP-0203/XMPPElement+Delay.h b/xmpp/Extensions/XEP-0203/XMPPElement+Delay.h new file mode 100644 index 0000000..834d959 --- /dev/null +++ b/xmpp/Extensions/XEP-0203/XMPPElement+Delay.h @@ -0,0 +1,10 @@ +#import +#import "XMPPElement.h" + + +@interface XMPPElement (XEP0203) + +- (BOOL)wasDelayed; +- (NSDate *)delayedDeliveryDate; + +@end diff --git a/xmpp/Extensions/XEP-0203/XMPPElement+Delay.m b/xmpp/Extensions/XEP-0203/XMPPElement+Delay.m new file mode 100644 index 0000000..f93e7d5 --- /dev/null +++ b/xmpp/Extensions/XEP-0203/XMPPElement+Delay.m @@ -0,0 +1,81 @@ +#import "XMPPElement+Delay.h" +#import "XMPPDateTimeProfiles.h" +#import "NSXMLElement+XMPP.h" + + +@implementation XMPPElement (XEP0203) + +- (BOOL)wasDelayed +{ + NSXMLElement *delay; + + delay = [self elementForName:@"delay" xmlns:@"urn:xmpp:delay"]; + if (delay) + { + return YES; + } + + delay = [self elementForName:@"delay" xmlns:@"jabber:x:delay"]; + if (delay) + { + return YES; + } + + return NO; +} + +- (NSDate *)delayedDeliveryDate +{ + NSXMLElement *delay; + + // From XEP-0203 (Delayed Delivery) + // + // + // + // The format [of the stamp attribute] MUST adhere to the dateTime format + // specified in XEP-0082 and MUST be expressed in UTC. + + delay = [self elementForName:@"delay" xmlns:@"urn:xmpp:delay"]; + if (delay) + { + NSString *stampValue = [delay attributeStringValueForName:@"stamp"]; + + // There are other considerations concerning XEP-0082. + // For example, it may optionally contain milliseconds. + // And it may possibly express UTC as "+00:00" instead of "Z". + // + // Thankfully there is already an implementation that takes into account all these possibilities. + + return [XMPPDateTimeProfiles parseDateTime:stampValue]; + } + + // From XEP-0091 (Legacy Delayed Delivery) + // + // + + delay = [self elementForName:@"delay" xmlns:@"jabber:x:delay"]; + if (delay) + { + NSDate *stamp; + + NSString *stampValue = [delay attributeStringValueForName:@"stamp"]; + + NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init]; + [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; + [dateFormatter setDateFormat:@"yyyyMMdd'T'HH:mm:ss"]; + [dateFormatter setTimeZone:[NSTimeZone timeZoneWithAbbreviation:@"GMT"]]; + + stamp = [dateFormatter dateFromString:stampValue]; + + [dateFormatter release]; + return stamp; + } + + return nil; +} + +@end diff --git a/xmpp/Utilities/DDList.h b/xmpp/Utilities/DDList.h new file mode 100644 index 0000000..c489a79 --- /dev/null +++ b/xmpp/Utilities/DDList.h @@ -0,0 +1,58 @@ +#import + +@class DDListEnumerator; + +struct DDListNode { + void * element; + struct DDListNode * prev; + struct DDListNode * next; +}; +typedef struct DDListNode DDListNode; + + +/** + * The DDList class is designed as a simple list class. + * It can store objective-c objects as well as non-objective-c pointers. + * It does not retain objective-c objects as it treats all elements as simple pointers. + * + * Example usages: + * - Storing a list of delegates, where there is a desire to not retain the individual delegates. + * - Storing a list of dispatch timers, which are not NSObjects, and cannot be stored in NSCollection classes. + * + * This class is NOT thread-safe. + * It is designed to be used within a thread-safe context (e.g. within a single dispatch_queue). +**/ +@interface DDList : NSObject +{ + DDListNode *list; +} + +- (void)add:(void *)element; +- (void)remove:(void *)element; +- (void)removeAll:(void *)element; +- (void)removeAllElements; + +- (NSUInteger)count; + +/** + * The enumerators return a snapshot of the list that can be enumerated. + * The list can later be altered (elements added/removed) without affecting enumerator snapshots. +**/ +- (DDListEnumerator *)listEnumerator; +- (DDListEnumerator *)reverseListEnumerator; + +@end + +@interface DDListEnumerator : NSObject +{ + NSUInteger numElements; + NSUInteger currentElementIndex; + void **elements; +} + +- (NSUInteger)numTotal; +- (NSUInteger)numLeft; + +- (void *)nextElement; + +@end diff --git a/xmpp/Utilities/DDList.m b/xmpp/Utilities/DDList.m new file mode 100644 index 0000000..94f96ba --- /dev/null +++ b/xmpp/Utilities/DDList.m @@ -0,0 +1,252 @@ +#import "DDList.h" + + +@interface DDListEnumerator (PrivateAPI) + +- (id)initWithList:(DDListNode *)list reverse:(BOOL)reverse; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDList + +- (id)init +{ + if ((self = [super init])) + { + list = NULL; + } + return self; +} + +- (void)add:(void *)element +{ + if(element == NULL) return; + + DDListNode *node = malloc(sizeof(DDListNode)); + + node->element = element; + + // Remember: The list is a linked list of DDListNode objects. + // Each node object is allocated and placed in the list. + // It is not deallocated until it is later removed from the linked list. + + if (list == NULL) + { + node->prev = NULL; + node->next = NULL; + } + else + { + node->prev = NULL; + node->next = list; + node->next->prev = node; + } + + list = node; +} + +- (void)remove:(void *)element allInstances:(BOOL)allInstances +{ + if(element == NULL) return; + + DDListNode *node = list; + while (node != NULL) + { + if (element == node->element) + { + // Remove the node from the list. + // This is done by editing the pointers of the node's neighbors to skip it. + // + // In other words: + // node->prev->next = node->next + // node->next->prev = node->prev + // + // We also want to properly update our list pointer, + // which always points to the "first" element in the list. (Most recently added.) + + if (node->prev != NULL) + node->prev->next = node->next; + else + list = node->next; + + if (node->next != NULL) + node->next->prev = node->prev; + + free(node); + + if (!allInstances) break; + } + else + { + node = node->next; + } + } +} + +- (void)remove:(void *)element +{ + [self remove:element allInstances:NO]; +} + +- (void)removeAll:(void *)element +{ + [self remove:element allInstances:YES]; +} + +- (void)removeAllElements +{ + DDListNode *node = list; + while (node != NULL) + { + DDListNode *next = node->next; + + free(node); + node = next; + } + + list = NULL; +} + +- (NSUInteger)count +{ + NSUInteger count = 0; + + DDListNode *node; + for (node = list; node != NULL; node = node->next) + { + count++; + } + + return count; +} + +- (DDListEnumerator *)listEnumerator +{ + return [[[DDListEnumerator alloc] initWithList:list reverse:NO] autorelease]; +} + +- (DDListEnumerator *)reverseListEnumerator +{ + return [[[DDListEnumerator alloc] initWithList:list reverse:YES] autorelease]; +} + +- (void)dealloc +{ + [self removeAllElements]; + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDListEnumerator + +- (id)initWithList:(DDListNode *)aList reverse:(BOOL)reverse +{ + if ((self = [super init])) + { + numElements = 0; + currentElementIndex = 0; + + // First get a count of the number of elements in the given list. + // Also, get a reference to the last node in the list. + + DDListNode *node = aList; + + if (node != NULL) + { + numElements++; + + while (node->next != NULL) + { + numElements++; + node = node->next; + } + } + + // At this point: + // + // aList -> points to the first element in the list + // node -> points to the last element in the list + + // Recall that new elements are added to the beginning of the linked list. + // The last element in the list is the first element that was added. + + if (numElements > 0) + { + elements = malloc(numElements * sizeof(void *)); + + if (reverse) + { + NSUInteger i = 0; + + while (aList != NULL) + { + elements[i] = aList->element; + + i++; + aList = aList->next; + } + } + else + { + NSUInteger i = 0; + + while (node != NULL) + { + elements[i] = node->element; + + i++; + node = node->prev; + } + } + } + } + return self; +} + +- (NSUInteger)numTotal +{ + return numElements; +} + +- (NSUInteger)numLeft +{ + if (currentElementIndex < numElements) + return numElements - currentElementIndex; + else + return 0; +} + +- (void *)nextElement +{ + if (currentElementIndex < numElements) + { + void *element = elements[currentElementIndex]; + currentElementIndex++; + + return element; + } + else + { + return NULL; + } +} + +- (void)dealloc +{ + if (elements) + { + free(elements); + } + [super dealloc]; +} + +@end diff --git a/xmpp/Utilities/GCDMulticastDelegate.h b/xmpp/Utilities/GCDMulticastDelegate.h new file mode 100644 index 0000000..90f1db4 --- /dev/null +++ b/xmpp/Utilities/GCDMulticastDelegate.h @@ -0,0 +1,70 @@ +#import + +@class GCDMulticastDelegateEnumerator; + +struct GCDMulticastDelegateListNode { + id delegate; + dispatch_queue_t delegateQueue; + struct GCDMulticastDelegateListNode * prev; + struct GCDMulticastDelegateListNode * next; + int32_t retainCount; +}; +typedef struct GCDMulticastDelegateListNode GCDMulticastDelegateListNode; + +/** + * This class provides multicast delegate functionality. + * That is, it provides a means for managing a list of delegates, + * and any method invocations to an instance of the class are automatically forwarded to all delegates. + * + * For example: + * + * // Make this method call on every added delegate (there may be several) + * [multicastDelegate cog:self didFindThing:thing]; + * + * This allows multiple delegates to be added to an xmpp stream or any xmpp module, + * which in turn makes development easier as there can be proper separation of logically different code sections. + * + * In addition, this makes module development easier, + * as multiple delegates can be handled in the same manner as the traditional single delegate paradigm. + * + * This class also provides proper support for GCD queues. + * So each delegate specifies which queue they would like their delegate invocations to be dispatched onto. + * + * All delegate dispatching is done asynchronously (which is a critically important architectural design). +**/ + +@interface GCDMulticastDelegate : NSObject +{ + GCDMulticastDelegateListNode *delegateList; +} + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)removeDelegate:(id)delegate; + +- (void)removeAllDelegates; + +- (NSUInteger)count; +- (NSUInteger)countOfClass:(Class)aClass; +- (NSUInteger)countForSelector:(SEL)aSelector; + +- (GCDMulticastDelegateEnumerator *)delegateEnumerator; + +@end + +@interface GCDMulticastDelegateEnumerator : NSObject +{ + NSUInteger numDelegates; + NSUInteger currentDelegateIndex; + GCDMulticastDelegateListNode **delegates; +} + +- (NSUInteger)count; +- (NSUInteger)countOfClass:(Class)aClass; +- (NSUInteger)countForSelector:(SEL)aSelector; + +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr; +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr ofClass:(Class)aClass; +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr forSelector:(SEL)aSelector; + +@end diff --git a/xmpp/Utilities/GCDMulticastDelegate.m b/xmpp/Utilities/GCDMulticastDelegate.m new file mode 100644 index 0000000..d9d8de2 --- /dev/null +++ b/xmpp/Utilities/GCDMulticastDelegate.m @@ -0,0 +1,577 @@ +#import "GCDMulticastDelegate.h" +#import + +/** + * How does this class work? + * + * In theory, this class is very straight-forward. + * It provides a way for multiple delegates to be called, each on its own delegate queue. + * + * In other words, any delegate method call to this class + * will get forwarded (dispatch_async'd) to each added delegate. + * + * Important note concerning thread-safety: + * + * This class is designed to be used from within a single dispatch queue. + * In other words, it is NOT thread-safe, and should only be used from within the external dedicated dispatch_queue. +**/ + +@interface GCDMulticastDelegate (PrivateAPI) + +- (NSInvocation *)duplicateInvocation:(NSInvocation *)origInvocation; + +@end + +@interface GCDMulticastDelegateEnumerator (PrivateAPI) + +- (id)initWithDelegateList:(GCDMulticastDelegateListNode *)delegateList; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +static void GCDMulticastDelegateListNodeRetain(GCDMulticastDelegateListNode *node) +{ + OSAtomicIncrement32Barrier(&node->retainCount); +} + +static void GCDMulticastDelegateListNodeRelease(GCDMulticastDelegateListNode *node) +{ + int32_t newRetainCount = OSAtomicDecrement32Barrier(&node->retainCount); + if (newRetainCount == 0) + { + free(node); + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation GCDMulticastDelegate + +- (id)init +{ + if ((self = [super init])) + { + delegateList = NULL; + } + return self; +} + +- (void)addDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + if (delegate == nil) return; + if (delegateQueue == NULL) return; + + GCDMulticastDelegateListNode *node = malloc(sizeof(GCDMulticastDelegateListNode)); + + node->delegate = delegate; + node->delegateQueue = delegateQueue; + node->retainCount = 1; + + dispatch_retain(delegateQueue); + + // Remember: The delegateList is a linked list of MulticastDelegateListNode objects. + // Each node object is allocated and placed in the list. + // It is not deallocated until it is later removed from the linked list. + + if (delegateList == NULL) + { + node->prev = NULL; + node->next = NULL; + } + else + { + node->prev = NULL; + node->next = delegateList; + node->next->prev = node; + } + + delegateList = node; +} + +- (void)removeDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue +{ + if (delegate == nil) return; + + GCDMulticastDelegateListNode *node = delegateList; + while (node != NULL) + { + if (delegate == node->delegate) + { + if ((delegateQueue == NULL) || (delegateQueue == node->delegateQueue)) + { + // Remove the node from the list. + // This is done by editing the pointers of the node's neighbors to skip it. + // + // In other words: + // node->prev->next = node->next + // node->next->prev = node->prev + // + // We also want to properly update our delegateList pointer, + // which always points to the "first" element in the list. (Most recently added.) + + if(node->prev != NULL) + node->prev->next = node->next; + else + delegateList = node->next; + + if(node->next != NULL) + node->next->prev = node->prev; + + node->prev = NULL; + node->next = NULL; + + dispatch_release(node->delegateQueue); + + node->delegate = nil; + node->delegateQueue = NULL; + + GCDMulticastDelegateListNodeRelease(node); + + break; + } + } + else + { + node = node->next; + } + } +} + +- (void)removeDelegate:(id)delegate +{ + [self removeDelegate:delegate delegateQueue:NULL]; +} + +- (void)removeAllDelegates +{ + GCDMulticastDelegateListNode *node = delegateList; + + while (node != NULL) + { + GCDMulticastDelegateListNode *next = node->next; + + node->prev = NULL; + node->next = NULL; + + dispatch_release(node->delegateQueue); + + node->delegate = nil; + node->delegateQueue = NULL; + + GCDMulticastDelegateListNodeRelease(node); + + node = next; + } + + delegateList = NULL; +} + +- (NSUInteger)count +{ + NSUInteger count = 0; + + GCDMulticastDelegateListNode *node; + for (node = delegateList; node != NULL; node = node->next) + { + count++; + } + + return count; +} + +- (NSUInteger)countOfClass:(Class)aClass +{ + NSUInteger count = 0; + + GCDMulticastDelegateListNode *node; + for (node = delegateList; node != NULL; node = node->next) + { + if ([node->delegate isKindOfClass:aClass]) + { + count++; + } + } + + return count; +} + +- (NSUInteger)countForSelector:(SEL)aSelector +{ + NSUInteger count = 0; + + GCDMulticastDelegateListNode *node; + for (node = delegateList; node != NULL; node = node->next) + { + if ([node->delegate respondsToSelector:aSelector]) + { + count++; + } + } + + return count; +} + +- (GCDMulticastDelegateEnumerator *)delegateEnumerator +{ + return [[[GCDMulticastDelegateEnumerator alloc] initWithDelegateList:delegateList] autorelease]; +} + +- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector +{ + GCDMulticastDelegateListNode *node; + for (node = delegateList; node != NULL; node = node->next) + { + NSMethodSignature *result = [node->delegate methodSignatureForSelector:aSelector]; + + if (result != nil) + { + return result; + } + } + + // This causes a crash... + // return [super methodSignatureForSelector:aSelector]; + + // This also causes a crash... + // return nil; + + return [[self class] instanceMethodSignatureForSelector:@selector(doNothing)]; +} + +- (void)forwardInvocation:(NSInvocation *)origInvocation +{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // All delegates MUST be invoked ASYNCHRONOUSLY. + + GCDMulticastDelegateListNode *node = delegateList; + + if (node != NULL) + { + // Recall that new delegates are added to the beginning of the linked list. + // The last delegate in the list is the first delegate that was added, so it will be the first that's invoked. + // We're going to be moving backwards through the linked list as we invoke the delegates. + // + // Loop through the linked list so we can get a reference to the last delegate in the list. + + while (node->next != NULL) + { + node = node->next; + } + + SEL selector = [origInvocation selector]; + + while (node != NULL) + { + id delegate = node->delegate; + + if ([delegate respondsToSelector:selector]) + { + NSInvocation *dupInvocation = [self duplicateInvocation:origInvocation]; + + dispatch_async(node->delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [dupInvocation invokeWithTarget:delegate]; + + [pool drain]; + }); + } + + node = node->prev; + } + } + + [pool release]; +} + +- (void)doesNotRecognizeSelector:(SEL)aSelector +{ + // Prevent NSInvalidArgumentException +} + +- (void)doNothing {} + +- (void)dealloc +{ + [self removeAllDelegates]; + [super dealloc]; +} + +- (NSInvocation *)duplicateInvocation:(NSInvocation *)origInvocation +{ + NSMethodSignature *methodSignature = [origInvocation methodSignature]; + + NSInvocation *dupInvocation = [NSInvocation invocationWithMethodSignature:methodSignature]; + [dupInvocation setSelector:[origInvocation selector]]; + + NSUInteger i, count = [methodSignature numberOfArguments]; + for (i = 2; i < count; i++) + { + const char *type = [methodSignature getArgumentTypeAtIndex:i]; + + if (*type == *@encode(BOOL)) + { + BOOL value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(char) || *type == *@encode(unsigned char)) + { + char value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(short) || *type == *@encode(unsigned short)) + { + short value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(int) || *type == *@encode(unsigned int)) + { + int value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(long) || *type == *@encode(unsigned long)) + { + long value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(long long) || *type == *@encode(unsigned long long)) + { + long long value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(double)) + { + double value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == *@encode(float)) + { + float value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else if (*type == '@') + { + id value; + [origInvocation getArgument:&value atIndex:i]; + [dupInvocation setArgument:&value atIndex:i]; + } + else + { + NSString *selectorStr = NSStringFromSelector([origInvocation selector]); + + NSString *format = @"Argument %lu to method %@ - Type(%c) not supported"; + NSString *reason = [NSString stringWithFormat:format, (unsigned long)(i - 2), selectorStr, *type]; + + [[NSException exceptionWithName:NSInvalidArgumentException reason:reason userInfo:nil] raise]; + } + } + + [dupInvocation retainArguments]; + + return dupInvocation; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation GCDMulticastDelegateEnumerator + +- (id)initWithDelegateList:(GCDMulticastDelegateListNode *)delegateList +{ + if ((self = [super init])) + { + numDelegates = 0; + currentDelegateIndex = 0; + + // The delegate enumerator will provide a snapshot of the current delegate list. + // + // So, technically, delegates could be added/removed from the list while we're enumerating. + + GCDMulticastDelegateListNode *node = delegateList; + + // First we loop through the linked list so we can: + // + // - Get a count of the number of delegates + // - Get a reference to the last delegate in the list + // + // Recall that new delegates are added to the beginning of the linked list. + // The last delegate in the list is the first delegate that was added, so it will be the first that's invoked. + // We're going to be moving backwards through the linked list as we add the delegates to our array. + + if (node != NULL) + { + numDelegates++; + + while (node->next != NULL) + { + numDelegates++; + node = node->next; + } + + // Note: The node variable is now pointing to the last node in the list. + } + + // We're now going to create an array of all the nodes. + // + // Note: We're creating an array of pointers. + // Each pointer points to the dynamically allocated struct. + // We also retain each node, to prevent it from disappearing while we're enumerating the list. + + size_t ptrSize = sizeof(node); + + delegates = malloc(ptrSize * numDelegates); + + // Remember that delegates is a pointer to an array of pointers. + // It's going to look something like this in memory: + // + // delegates ---> |ptr1|ptr2|ptr3|...| + // + // So delegates points to ptr1. + // And due to pointer arithmetic, delegates+1 points to ptr2. + + NSUInteger i; + for (i = 0; i < numDelegates; i++) + { + memcpy(delegates + i, &node, ptrSize); + GCDMulticastDelegateListNodeRetain(node); + + node = node->prev; + } + } + return self; +} + +- (NSUInteger)count +{ + return numDelegates; +} + +- (NSUInteger)countOfClass:(Class)aClass +{ + NSUInteger count = 0; + NSUInteger index = 0; + + while (index < numDelegates) + { + GCDMulticastDelegateListNode *node = *(delegates + index); + + if ([node->delegate isKindOfClass:aClass]) + { + count++; + } + + index++; + } + + return count; +} + +- (NSUInteger)countForSelector:(SEL)aSelector +{ + NSUInteger count = 0; + NSUInteger index = 0; + + while (index < numDelegates) + { + GCDMulticastDelegateListNode *node = *(delegates + index); + + if ([node->delegate respondsToSelector:aSelector]) + { + count++; + } + + index++; + } + + return count; +} + +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr +{ + while (currentDelegateIndex < numDelegates) + { + GCDMulticastDelegateListNode *node = *(delegates + currentDelegateIndex); + currentDelegateIndex++; + + if (node->delegate) + { + if (delPtr) *delPtr = node->delegate; + if (dqPtr) *dqPtr = node->delegateQueue; + + return YES; + } + } + + return NO; +} + +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr ofClass:(Class)aClass +{ + while (currentDelegateIndex < numDelegates) + { + GCDMulticastDelegateListNode *node = *(delegates + currentDelegateIndex); + currentDelegateIndex++; + + if ([node->delegate isKindOfClass:aClass]) + { + if (delPtr) *delPtr = node->delegate; + if (dqPtr) *dqPtr = node->delegateQueue; + + return YES; + } + } + + return NO; +} + +- (BOOL)getNextDelegate:(id *)delPtr delegateQueue:(dispatch_queue_t *)dqPtr forSelector:(SEL)aSelector +{ + while (currentDelegateIndex < numDelegates) + { + GCDMulticastDelegateListNode *node = *(delegates + currentDelegateIndex); + currentDelegateIndex++; + + if ([node->delegate respondsToSelector:aSelector]) + { + if (delPtr) *delPtr = node->delegate; + if (dqPtr) *dqPtr = node->delegateQueue; + + return YES; + } + } + + return NO; +} + +- (void)dealloc +{ + NSUInteger i; + for (i = 0; i < numDelegates; i++) + { + GCDMulticastDelegateListNode *node = *(delegates + i); + GCDMulticastDelegateListNodeRelease(node); + } + + free(delegates); + + [super dealloc]; +} + +@end diff --git a/xmpp/Utilities/LibIDN.h b/xmpp/Utilities/LibIDN.h new file mode 100644 index 0000000..e7f5c5d --- /dev/null +++ b/xmpp/Utilities/LibIDN.h @@ -0,0 +1,32 @@ +#import + + +@interface LibIDN : NSObject + +/** + * Preps a node identifier for use in a JID. + * If the given node is invalid, this method returns nil. + * + * See the XMPP RFC (3920) for details. + * + * Note: The prep properly converts the string to lowercase, as per the RFC. +**/ ++ (NSString *)prepNode:(NSString *)node; + +/** + * Preps a domain name for use in a JID. + * If the given domain is invalid, this method returns nil. + * + * See the XMPP RFC (3920) for details. +**/ ++ (NSString *)prepDomain:(NSString *)domain; + +/** + * Preps a resource identifier for use in a JID. + * If the given node is invalid, this method returns nil. + * + * See the XMPP RFC (3920) for details. + **/ ++ (NSString *)prepResource:(NSString *)resource; + +@end diff --git a/xmpp/Utilities/LibIDN.m b/xmpp/Utilities/LibIDN.m new file mode 100644 index 0000000..8d0b132 --- /dev/null +++ b/xmpp/Utilities/LibIDN.m @@ -0,0 +1,52 @@ +#import "LibIDN.h" +#import "stringprep.h" + + +@implementation LibIDN + ++ (NSString *)prepNode:(NSString *)node +{ + if(node == nil) return nil; + + // Each allowable portion of a JID MUST NOT be more than 1023 bytes in length. + // We make the buffer just big enough to hold a null-terminated string of this length. + char buf[1024]; + + strncpy(buf, [node UTF8String], sizeof(buf)); + + if(stringprep_xmpp_nodeprep(buf, sizeof(buf)) != 0) return nil; + + return [NSString stringWithUTF8String:buf]; +} + ++ (NSString *)prepDomain:(NSString *)domain +{ + if(domain == nil) return nil; + + // Each allowable portion of a JID MUST NOT be more than 1023 bytes in length. + // We make the buffer just big enough to hold a null-terminated string of this length. + char buf[1024]; + + strncpy(buf, [domain UTF8String], sizeof(buf)); + + if(stringprep_nameprep(buf, sizeof(buf)) != 0) return nil; + + return [NSString stringWithUTF8String:buf]; +} + ++ (NSString *)prepResource:(NSString *)resource +{ + if(resource == nil) return nil; + + // Each allowable portion of a JID MUST NOT be more than 1023 bytes in length. + // We make the buffer just big enough to hold a null-terminated string of this length. + char buf[1024]; + + strncpy(buf, [resource UTF8String], sizeof(buf)); + + if(stringprep_xmpp_resourceprep(buf, sizeof(buf)) != 0) return nil; + + return [NSString stringWithUTF8String:buf]; +} + +@end diff --git a/xmpp/Utilities/RFImageToDataTransformer.h b/xmpp/Utilities/RFImageToDataTransformer.h new file mode 100644 index 0000000..579ab4b --- /dev/null +++ b/xmpp/Utilities/RFImageToDataTransformer.h @@ -0,0 +1,19 @@ + +/* + File: RFImageToDataTransformer.h + Abstract: A value transformer, which transforms a UIImage or NSImage object into an NSData object. + + Based on Apple's UIImageToDataTransformer + + Copyright (C) 2010 Apple Inc. All Rights Reserved. + Copyright (C) 2011 RF.com All Rights Reserved. + */ + +#import + + +@interface RFImageToDataTransformer : NSValueTransformer { + +} + +@end diff --git a/xmpp/Utilities/RFImageToDataTransformer.m b/xmpp/Utilities/RFImageToDataTransformer.m new file mode 100644 index 0000000..c43c0b5 --- /dev/null +++ b/xmpp/Utilities/RFImageToDataTransformer.m @@ -0,0 +1,48 @@ + +/* + File: RFImageToDataTransformer.m + Abstract: A value transformer, which transforms a UIImage or NSImage object into an NSData object. + + Based on Apple's UIImageToDataTransformer + + Copyright (C) 2010 Apple Inc. All Rights Reserved. + Copyright (C) 2011 RF.com All Rights Reserved. + */ + +#import "RFImageToDataTransformer.h" + +#if TARGET_OS_IPHONE +#import +#else + +#endif + + +@implementation RFImageToDataTransformer + ++ (BOOL)allowsReverseTransformation { + return YES; +} + ++ (Class)transformedValueClass { + return [NSData class]; +} + +- (id)transformedValue:(id)value { +#if TARGET_OS_IPHONE + return UIImagePNGRepresentation(value); +#else + return [(NSImage *)value TIFFRepresentation]; +#endif +} + +- (id)reverseTransformedValue:(id)value { +#if TARGET_OS_IPHONE + return [[[UIImage alloc] initWithData:value] autorelease]; +#else + return [[[NSImage alloc] initWithData:value] autorelease]; +#endif +} + +@end + diff --git a/xmpp/Utilities/XMPPSRVResolver.h b/xmpp/Utilities/XMPPSRVResolver.h new file mode 100644 index 0000000..0a36e32 --- /dev/null +++ b/xmpp/Utilities/XMPPSRVResolver.h @@ -0,0 +1,85 @@ +// +// XMPPSRVResolver.h +// +// Originally created by Eric Chamberlain on 6/15/10. +// Based on SRVResolver by Apple, Inc. +// + +#import +#import + +extern NSString *const XMPPSRVResolverErrorDomain; + + +@interface XMPPSRVResolver : NSObject +{ + id delegate; + dispatch_queue_t delegateQueue; + + dispatch_queue_t resolverQueue; + + NSString *srvName; + NSTimeInterval timeout; + + BOOL resolveInProgress; + + NSMutableArray *results; + DNSServiceRef sdRef; + + int sdFd; + dispatch_source_t sdReadSource; + dispatch_source_t timeoutTimer; +} + +/** + * The delegate & delegateQueue are mandatory. + * The resolverQueue is optional. If NULL, it will automatically create it's own internal queue. +**/ +- (id)initWithdDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq resolverQueue:(dispatch_queue_t)rq; + +@property (readonly) NSString *srvName; +@property (readonly) NSTimeInterval timeout; + +- (void)startWithSRVName:(NSString *)aSRVName timeout:(NSTimeInterval)aTimeout; +- (void)stop; + ++ (NSString *)srvNameFromXMPPDomain:(NSString *)xmppDomain; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol XMPPSRVResolverDelegate + +- (void)srvResolver:(XMPPSRVResolver *)sender didResolveRecords:(NSArray *)records; +- (void)srvResolver:(XMPPSRVResolver *)sender didNotResolveDueToError:(NSError *)error; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPSRVRecord : NSObject +{ + UInt16 priority; + UInt16 weight; + UInt16 port; + NSString *target; + + NSUInteger sum; + NSUInteger srvResultsIndex; +} + ++ (XMPPSRVRecord *)recordWithPriority:(UInt16)priority weight:(UInt16)weight port:(UInt16)port target:(NSString *)target; + +- (id)initWithPriority:(UInt16)priority weight:(UInt16)weight port:(UInt16)port target:(NSString *)target; + +@property (nonatomic, readonly) UInt16 priority; +@property (nonatomic, readonly) UInt16 weight; +@property (nonatomic, readonly) UInt16 port; +@property (nonatomic, readonly) NSString *target; + +@end diff --git a/xmpp/Utilities/XMPPSRVResolver.m b/xmpp/Utilities/XMPPSRVResolver.m new file mode 100644 index 0000000..b0c5696 --- /dev/null +++ b/xmpp/Utilities/XMPPSRVResolver.m @@ -0,0 +1,692 @@ +// +// XMPPSRVResolver.m +// +// Originally created by Eric Chamberlain on 6/15/10. +// Based on SRVResolver by Apple, Inc. +// + +#import "XMPPSRVResolver.h" +#import "XMPPLogging.h" + +#include +#include + +NSString *const XMPPSRVResolverErrorDomain = @"XMPPSRVResolverErrorDomain"; + +// Log levels: off, error, warn, info, verbose +#if DEBUG + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; // | XMPP_LOG_FLAG_TRACE; +#else + static const int xmppLogLevel = XMPP_LOG_LEVEL_WARN; +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface XMPPSRVRecord () + +@property(nonatomic, assign) NSUInteger srvResultsIndex; +@property(nonatomic, assign) NSUInteger sum; + +- (NSComparisonResult)compareByPriority:(XMPPSRVRecord *)aRecord; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPSRVResolver + +- (id)initWithdDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq resolverQueue:(dispatch_queue_t)rq +{ + NSParameterAssert(aDelegate != nil); + NSParameterAssert(dq != NULL); + + if ((self = [super init])) + { + XMPPLogTrace(); + + delegate = aDelegate; + delegateQueue = dq; + dispatch_retain(delegateQueue); + + if (rq) + { + resolverQueue = rq; + dispatch_retain(resolverQueue); + } + else + { + resolverQueue = dispatch_queue_create("XMPPSRVResolver", NULL); + } + + results = [[NSMutableArray alloc] initWithCapacity:2]; + } + return self; +} + +- (void)dealloc +{ + XMPPLogTrace(); + + [self stop]; + + if (resolverQueue) + dispatch_release(resolverQueue); + + [srvName release]; + [results release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@dynamic srvName; +@dynamic timeout; + +- (NSString *)srvName +{ + __block NSString *result; + + dispatch_block_t block = ^{ + result = [srvName copy]; + }; + + if (dispatch_get_current_queue() == resolverQueue) + block(); + else + dispatch_sync(resolverQueue, block); + + return [result autorelease]; +} + +- (NSTimeInterval)timeout +{ + __block NSTimeInterval result; + + dispatch_block_t block = ^{ + result = timeout; + }; + + if (dispatch_get_current_queue() == resolverQueue) + block(); + else + dispatch_sync(resolverQueue, block); + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Private Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)sortResults +{ + NSAssert(dispatch_get_current_queue() == resolverQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + // Sort results + NSMutableArray *sortedResults = [NSMutableArray arrayWithCapacity:[results count]]; + + // Sort the list by priority (lowest number first) + [results sortUsingSelector:@selector(compareByPriority:)]; + + /* From RFC 2782 + * + * For each distinct priority level + * While there are still elements left at this priority level + * + * Select an element as specified above, in the + * description of Weight in "The format of the SRV + * RR" Section, and move it to the tail of the new + * list. + * + * The following algorithm SHOULD be used to order + * the SRV RRs of the same priority: + */ + + NSUInteger srvResultsCount; + + while ([results count] > 0) + { + srvResultsCount = [results count]; + + if (srvResultsCount == 1) + { + XMPPSRVRecord *srvRecord = [results objectAtIndex:0]; + + [sortedResults addObject:srvRecord]; + [results removeObjectAtIndex:0]; + } + else // (srvResultsCount > 1) + { + // more than two records so we need to sort + + /* To select a target to be contacted next, arrange all SRV RRs + * (that have not been ordered yet) in any order, except that all + * those with weight 0 are placed at the beginning of the list. + * + * Compute the sum of the weights of those RRs, and with each RR + * associate the running sum in the selected order. + */ + + NSUInteger runningSum = 0; + NSMutableArray *samePriorityRecords = [NSMutableArray arrayWithCapacity:srvResultsCount]; + + XMPPSRVRecord *srvRecord = [results objectAtIndex:0]; + + NSUInteger initialPriority = srvRecord.priority; + NSUInteger index = 0; + + do + { + if (srvRecord.weight == 0) + { + // add to front of array + [samePriorityRecords insertObject:srvRecord atIndex:0]; + + srvRecord.srvResultsIndex = index; + srvRecord.sum = 0; + } + else + { + // add to end of array and update the running sum + [samePriorityRecords addObject:srvRecord]; + + runningSum += srvRecord.weight; + + srvRecord.srvResultsIndex = index; + srvRecord.sum = runningSum; + } + + if (++index < srvResultsCount) + { + srvRecord = [results objectAtIndex:index]; + } + else + { + srvRecord = nil; + } + + } while(srvRecord && (srvRecord.priority == initialPriority)); + + /* Then choose a uniform random number between 0 and the sum computed + * (inclusive), and select the RR whose running sum value is the + * first in the selected order which is greater than or equal to + * the random number selected. + */ + + NSUInteger randomIndex = arc4random() % (runningSum + 1); + + for (srvRecord in samePriorityRecords) + { + if (srvRecord.sum >= randomIndex) + { + /* The target host specified in the + * selected SRV RR is the next one to be contacted by the client. + * Remove this SRV RR from the set of the unordered SRV RRs and + * apply the described algorithm to the unordered SRV RRs to select + * the next target host. Continue the ordering process until there + * are no unordered SRV RRs. This process is repeated for each + * Priority. + */ + + [sortedResults addObject:srvRecord]; + [results removeObjectAtIndex:srvRecord.srvResultsIndex]; + + break; + } + } + } + } + + [results release]; + results = [sortedResults retain]; + + XMPPLogVerbose(@"%@: Sorted results:\n%@", THIS_FILE, results); +} + +- (void)succeed +{ + NSAssert(dispatch_get_current_queue() == resolverQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace(); + + [self sortResults]; + + id theDelegate = delegate; + NSArray *records = [results copy]; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + SEL selector = @selector(srvResolver:didResolveRecords:); + + if ([theDelegate respondsToSelector:selector]) + { + [theDelegate srvResolver:self didResolveRecords:records]; + } + else + { + XMPPLogWarn(@"%@: delegate doesn't implement %@", THIS_FILE, NSStringFromSelector(selector)); + } + + [pool drain]; + }); + + [records release]; + [self stop]; +} + +- (void)failWithError:(NSError *)error +{ + NSAssert(dispatch_get_current_queue() == resolverQueue, @"Invoked on incorrect queue"); + + XMPPLogTrace2(@"%@: %@ %@", THIS_FILE, THIS_METHOD, error); + + id theDelegate = delegate; + + if (delegateQueue != NULL) { + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + SEL selector = @selector(srvResolver:didNotResolveDueToError:); + + if ([theDelegate respondsToSelector:selector]) + { + [theDelegate srvResolver:self didNotResolveDueToError:error]; + } + else + { + XMPPLogWarn(@"%@: delegate doesn't implement %@", THIS_FILE, NSStringFromSelector(selector)); + } + + [pool drain]; + }); + } + + [self stop]; +} + +- (void)failWithDNSError:(DNSServiceErrorType)sdErr +{ + XMPPLogTrace2(@"%@: %@ %i", THIS_FILE, THIS_METHOD, (int)sdErr); + + [self failWithError:[NSError errorWithDomain:XMPPSRVResolverErrorDomain code:sdErr userInfo:nil]]; +} + +- (XMPPSRVRecord *)processRecord:(const void *)rdata length:(uint16_t)rdlen +{ + XMPPLogTrace(); + + // Note: This method is almost entirely from Apple's sample code. + // + // Otherwise there would be a lot more comments and explanation... + + if (rdata == NULL) + { + XMPPLogWarn(@"%@: %@ - rdata == NULL", THIS_FILE, THIS_METHOD); + return nil; + } + + // Rather than write a whole bunch of icky parsing code, I just synthesise + // a resource record and use . + + XMPPSRVRecord *result = nil; + + NSMutableData * rrData; + dns_resource_record_t * rr; + uint8_t u8; // 1 byte + uint16_t u16; // 2 bytes + uint32_t u32; // 4 bytes + + rrData = [NSMutableData dataWithCapacity:(1 + 2 + 2 + 4 + 2 + rdlen)]; + + u8 = 0; + [rrData appendBytes:&u8 length:sizeof(u8)]; + u16 = htons(kDNSServiceType_SRV); + [rrData appendBytes:&u16 length:sizeof(u16)]; + u16 = htons(kDNSServiceClass_IN); + [rrData appendBytes:&u16 length:sizeof(u16)]; + u32 = htonl(666); + [rrData appendBytes:&u32 length:sizeof(u32)]; + u16 = htons(rdlen); + [rrData appendBytes:&u16 length:sizeof(u16)]; + [rrData appendBytes:rdata length:rdlen]; + + // Parse the record. + + rr = dns_parse_resource_record([rrData bytes], (uint32_t) [rrData length]); + if (rr != NULL) + { + NSString *target; + + target = [NSString stringWithCString:rr->data.SRV->target encoding:NSASCIIStringEncoding]; + if (target != nil) + { + UInt16 priority = rr->data.SRV->priority; + UInt16 weight = rr->data.SRV->weight; + UInt16 port = rr->data.SRV->port; + + result = [XMPPSRVRecord recordWithPriority:priority weight:weight port:port target:target]; + } + + dns_free_resource_record(rr); + } + + return result; +} + +static void QueryRecordCallback(DNSServiceRef sdRef, + DNSServiceFlags flags, + uint32_t interfaceIndex, + DNSServiceErrorType errorCode, + const char * fullname, + uint16_t rrtype, + uint16_t rrclass, + uint16_t rdlen, + const void * rdata, + uint32_t ttl, + void * context) +{ + // Called when we get a response to our query. + // It does some preliminary work, but the bulk of the interesting stuff + // is done in the processRecord:length: method. + + XMPPSRVResolver *resolver = (XMPPSRVResolver *)context; + + NSCAssert(dispatch_get_current_queue() == resolver->resolverQueue, @"Invoked on incorrect queue"); + + XMPPLogCTrace(); + + if (!(flags & kDNSServiceFlagsAdd)) + { + // If the kDNSServiceFlagsAdd flag is not set, the domain information is not valid. + return; + } + + if (errorCode == kDNSServiceErr_NoError && + rrtype == kDNSServiceType_SRV) + { + XMPPSRVRecord *record = [resolver processRecord:rdata length:rdlen]; + if (record) + { + [resolver->results addObject:record]; + } + + if ( ! (flags & kDNSServiceFlagsMoreComing) ) + { + [resolver succeed]; + } + } + else + { + [resolver failWithDNSError:errorCode]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Public Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)startWithSRVName:(NSString *)aSRVName timeout:(NSTimeInterval)aTimeout +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (resolveInProgress) + { + [pool drain]; + return; + } + + XMPPLogTrace2(@"%@: startWithSRVName:%@ timeout:%f", THIS_FILE, aSRVName, aTimeout); + + // Save parameters + + [srvName release]; + srvName = [aSRVName copy]; + + timeout = aTimeout; + + // Check parameters + + const char *srvNameCStr = [srvName cStringUsingEncoding:NSASCIIStringEncoding]; + if (srvNameCStr == NULL) + { + [self failWithDNSError:kDNSServiceErr_BadParam]; + + [pool drain]; + return; + + } + + // Create DNS Service + + DNSServiceErrorType sdErr; + sdErr = DNSServiceQueryRecord(&sdRef, // Pointer to unitialized DNSServiceRef + kDNSServiceFlagsReturnIntermediates, // Flags + kDNSServiceInterfaceIndexAny, // Interface index + srvNameCStr, // Full domain name + kDNSServiceType_SRV, // rrtype + kDNSServiceClass_IN, // rrclass + QueryRecordCallback, // Callback method + self); // Context pointer + + if (sdErr != kDNSServiceErr_NoError) + { + [self failWithDNSError:sdErr]; + + [pool drain]; + return; + } + + // Extract unix socket (so we can poll for events) + + sdFd = DNSServiceRefSockFD(sdRef); + if (sdFd < 0) + { + // Todo... + } + + // Create GCD read source for sd file descriptor + + sdReadSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, sdFd, 0, resolverQueue); + + dispatch_source_set_event_handler(sdReadSource, ^{ + NSAutoreleasePool *handlerPool = [[NSAutoreleasePool alloc] init]; + + XMPPLogVerbose(@"%@: sdReadSource_eventHandler", THIS_FILE); + + // There is data to be read on the socket (or an error occurred). + // + // Invoking DNSServiceProcessResult will invoke our QueryRecordCallback, + // the callback we set when we created the sdRef. + + DNSServiceErrorType sdErr = DNSServiceProcessResult(sdRef); + if (sdErr != kDNSServiceErr_NoError) + { + [self failWithDNSError:sdErr]; + } + + [handlerPool drain]; + }); + + dispatch_source_t theSdReadSource = sdReadSource; + DNSServiceRef theSdRef = sdRef; + + dispatch_source_set_cancel_handler(sdReadSource, ^{ + NSAutoreleasePool *handlerPool = [[NSAutoreleasePool alloc] init]; + + XMPPLogVerbose(@"%@: sdReadSource_cancelHandler", THIS_FILE); + + dispatch_release(theSdReadSource); + DNSServiceRefDeallocate(theSdRef); + + [handlerPool drain]; + }); + + dispatch_resume(sdReadSource); + + // Create timer (if requested timeout > 0) + + if (timeout > 0.0) + { + timeoutTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, resolverQueue); + + dispatch_source_set_event_handler(timeoutTimer, ^{ + NSAutoreleasePool *handlerPool = [[NSAutoreleasePool alloc] init]; + + NSString *errMsg = @"Operation timed out"; + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + NSError *err = [NSError errorWithDomain:XMPPSRVResolverErrorDomain code:0 userInfo:userInfo]; + + [self failWithError:err]; + + [handlerPool drain]; + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(timeoutTimer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(timeoutTimer); + } + + resolveInProgress = YES; + [pool drain]; + }; + + if (dispatch_get_current_queue() == resolverQueue) + block(); + else + dispatch_async(resolverQueue, block); +} + +- (void)stop +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + XMPPLogTrace(); + + delegate = nil; + if (delegateQueue) + { + dispatch_release(delegateQueue); + delegateQueue = NULL; + } + + [results removeAllObjects]; + + if (sdReadSource) + { + // Cancel the readSource. + // It will be released from within the cancel handler. + dispatch_source_cancel(sdReadSource); + sdReadSource = NULL; + sdFd = -1; + + // The sdRef will be deallocated from within the cancel handler too. + sdRef = NULL; + } + + if (timeoutTimer) + { + dispatch_source_cancel(timeoutTimer); + dispatch_release(timeoutTimer); + timeoutTimer = NULL; + } + + resolveInProgress = NO; + [pool drain]; + }; + + if (dispatch_get_current_queue() == resolverQueue) + block(); + else + dispatch_sync(resolverQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utility Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSString *)srvNameFromXMPPDomain:(NSString *)xmppDomain +{ + if (xmppDomain == nil) + return nil; + else + return [NSString stringWithFormat:@"_xmpp-client._tcp.%@", xmppDomain]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation XMPPSRVRecord + +@synthesize priority; +@synthesize weight; +@synthesize port; +@synthesize target; + +@synthesize sum; +@synthesize srvResultsIndex; + + ++ (XMPPSRVRecord *)recordWithPriority:(UInt16)p1 weight:(UInt16)w port:(UInt16)p2 target:(NSString *)t +{ + return [[[XMPPSRVRecord alloc] initWithPriority:p1 weight:w port:p2 target:t] autorelease]; +} + +- (id)initWithPriority:(UInt16)p1 weight:(UInt16)w port:(UInt16)p2 target:(NSString *)t +{ + if ((self = [super init])) + { + priority = p1; + weight = w; + port = p2; + target = [t copy]; + + sum = 0; + srvResultsIndex = 0; + } + return self; +} + +- (void)dealloc +{ + [target release]; + [super dealloc]; +} + +- (NSString *)description +{ + return [NSString stringWithFormat:@"<%@:%p target(%@) port(%hu) priority(%hu) weight(%hu)>", + NSStringFromClass([self class]), self, target, port, priority, weight]; +} + +- (NSComparisonResult)compareByPriority:(XMPPSRVRecord *)aRecord +{ + UInt16 mPriority = self.priority; + UInt16 aPriority = aRecord.priority; + + if (mPriority < aPriority) + return NSOrderedAscending; + + if (mPriority > aPriority) + return NSOrderedDescending; + + return NSOrderedSame; +} + +@end diff --git a/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.h b/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.h new file mode 100644 index 0000000..5747d9f --- /dev/null +++ b/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.h @@ -0,0 +1,928 @@ +// +// GCDAsyncSocket.h +// +// This class is in the public domain. +// Originally created by Robbie Hanson in Q3 2010. +// Updated and maintained by Deusty LLC and the Mac development community. +// +// http://code.google.com/p/cocoaasyncsocket/ +// + +#import +#import +#import + +@class GCDAsyncReadPacket; +@class GCDAsyncWritePacket; + +extern NSString *const GCDAsyncSocketException; +extern NSString *const GCDAsyncSocketErrorDomain; + +#if !TARGET_OS_IPHONE +extern NSString *const GCDAsyncSocketSSLCipherSuites; +extern NSString *const GCDAsyncSocketSSLDiffieHellmanParameters; +#endif + +enum GCDAsyncSocketError +{ + GCDAsyncSocketNoError = 0, // Never used + GCDAsyncSocketBadConfigError, // Invalid configuration + GCDAsyncSocketBadParamError, // Invalid parameter was passed + GCDAsyncSocketConnectTimeoutError, // A connect operation timed out + GCDAsyncSocketReadTimeoutError, // A read operation timed out + GCDAsyncSocketWriteTimeoutError, // A write operation timed out + GCDAsyncSocketReadMaxedOutError, // Reached set maxLength without completing + GCDAsyncSocketClosedError, // The remote peer closed the connection + GCDAsyncSocketOtherError, // Description provided in userInfo +}; +typedef enum GCDAsyncSocketError GCDAsyncSocketError; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface GCDAsyncSocket : NSObject +{ + UInt16 flags; + UInt16 config; + + id delegate; + dispatch_queue_t delegateQueue; + + int socket4FD; + int socket6FD; + int connectIndex; + NSData * connectInterface4; + NSData * connectInterface6; + + dispatch_queue_t socketQueue; + + dispatch_source_t accept4Source; + dispatch_source_t accept6Source; + dispatch_source_t connectTimer; + dispatch_source_t readSource; + dispatch_source_t writeSource; + dispatch_source_t readTimer; + dispatch_source_t writeTimer; + + NSMutableArray *readQueue; + NSMutableArray *writeQueue; + + GCDAsyncReadPacket *currentRead; + GCDAsyncWritePacket *currentWrite; + + unsigned long socketFDBytesAvailable; + + NSMutableData *partialReadBuffer; + +#if TARGET_OS_IPHONE + CFStreamClientContext streamContext; + CFReadStreamRef readStream; + CFWriteStreamRef writeStream; +#else + SSLContextRef sslContext; + NSMutableData *sslReadBuffer; + size_t sslWriteCachedLength; +#endif + + id userData; +} + +/** + * GCDAsyncSocket uses the standard delegate paradigm, + * but executes all delegate callbacks on a given delegate dispatch queue. + * This allows for maximum concurrency, while at the same time providing easy thread safety. + * + * You MUST set a delegate AND delegate dispatch queue before attempting to + * use the socket, or you will get an error. + * + * The socket queue is optional. + * If you pass NULL, GCDAsyncSocket will automatically create it's own socket queue. + * If you choose to provide a socket queue, the socket queue must not be a concurrent queue. + * + * The delegate queue and socket queue can optionally be the same. +**/ +- (id)init; +- (id)initWithSocketQueue:(dispatch_queue_t)sq; +- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq; +- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq socketQueue:(dispatch_queue_t)sq; + +#pragma mark Configuration + +- (id)delegate; +- (void)setDelegate:(id)delegate; +- (void)synchronouslySetDelegate:(id)delegate; + +- (dispatch_queue_t)delegateQueue; +- (void)setDelegateQueue:(dispatch_queue_t)delegateQueue; +- (void)synchronouslySetDelegateQueue:(dispatch_queue_t)delegateQueue; + +- (void)getDelegate:(id *)delegatePtr delegateQueue:(dispatch_queue_t *)delegateQueuePtr; +- (void)setDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; +- (void)synchronouslySetDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue; + +/** + * Traditionally sockets are not closed until the conversation is over. + * However, it is technically possible for the remote enpoint to close its write stream. + * Our socket would then be notified that there is no more data to be read, + * but our socket would still be writeable and the remote endpoint could continue to receive our data. + * + * The argument for this confusing functionality stems from the idea that a client could shut down its + * write stream after sending a request to the server, thus notifying the server there are to be no further requests. + * In practice, however, this technique did little to help server developers. + * + * To make matters worse, from a TCP perspective there is no way to tell the difference from a read stream close + * and a full socket close. They both result in the TCP stack receiving a FIN packet. The only way to tell + * is by continuing to write to the socket. If it was only a read stream close, then writes will continue to work. + * Otherwise an error will be occur shortly (when the remote end sends us a RST packet). + * + * In addition to the technical challenges and confusion, many high level socket/stream API's provide + * no support for dealing with the problem. If the read stream is closed, the API immediately declares the + * socket to be closed, and shuts down the write stream as well. In fact, this is what Apple's CFStream API does. + * It might sound like poor design at first, but in fact it simplifies development. + * + * The vast majority of the time if the read stream is closed it's because the remote endpoint closed its socket. + * Thus it actually makes sense to close the socket at this point. + * And in fact this is what most networking developers want and expect to happen. + * However, if you are writing a server that interacts with a plethora of clients, + * you might encounter a client that uses the discouraged technique of shutting down its write stream. + * If this is the case, you can set this property to NO, + * and make use of the socketDidCloseReadStream delegate method. + * + * The default value is YES. +**/ +- (BOOL)autoDisconnectOnClosedReadStream; +- (void)setAutoDisconnectOnClosedReadStream:(BOOL)flag; + +/** + * By default, both IPv4 and IPv6 are enabled. + * + * For accepting incoming connections, this means GCDAsyncSocket automatically supports both protocols, + * and can simulataneously accept incoming connections on either protocol. + * + * For outgoing connections, this means GCDAsyncSocket can connect to remote hosts running either protocol. + * If a DNS lookup returns only IPv4 results, GCDAsyncSocket will automatically use IPv4. + * If a DNS lookup returns only IPv6 results, GCDAsyncSocket will automatically use IPv6. + * If a DNS lookup returns both IPv4 and IPv6 results, the preferred protocol will be chosen. + * By default, the preferred protocol is IPv4, but may be configured as desired. +**/ +- (BOOL)isIPv4Enabled; +- (void)setIPv4Enabled:(BOOL)flag; + +- (BOOL)isIPv6Enabled; +- (void)setIPv6Enabled:(BOOL)flag; + +- (BOOL)isIPv4PreferredOverIPv6; +- (void)setPreferIPv4OverIPv6:(BOOL)flag; + +/** + * User data allows you to associate arbitrary information with the socket. + * This data is not used internally by socket in any way. +**/ +- (id)userData; +- (void)setUserData:(id)arbitraryUserData; + +#pragma mark Accepting + +/** + * Tells the socket to begin listening and accepting connections on the given port. + * When a connection is accepted, a new instance of GCDAsyncSocket will be spawned to handle it, + * and the socket:didAcceptNewSocket: delegate method will be invoked. + * + * The socket will listen on all available interfaces (e.g. wifi, ethernet, etc) +**/ +- (BOOL)acceptOnPort:(UInt16)port error:(NSError **)errPtr; + +/** + * This method is the same as acceptOnPort:error: with the + * additional option of specifying which interface to listen on. + * + * For example, you could specify that the socket should only accept connections over ethernet, + * and not other interfaces such as wifi. + * + * The interface may be specified by name (e.g. "en1" or "lo0") or by IP address (e.g. "192.168.4.34"). + * You may also use the special strings "localhost" or "loopback" to specify that + * the socket only accept connections from the local machine. + * + * You can see the list of interfaces via the command line utility "ifconfig", + * or programmatically via the getifaddrs() function. + * + * To accept connections on any interface pass nil, or simply use the acceptOnPort:error: method. +**/ +- (BOOL)acceptOnInterface:(NSString *)interface port:(UInt16)port error:(NSError **)errPtr; + +#pragma mark Connecting + +/** + * Connects to the given host and port. + * + * This method invokes connectToHost:onPort:viaInterface:withTimeout:error: + * and uses the default interface, and no timeout. +**/ +- (BOOL)connectToHost:(NSString *)host onPort:(UInt16)port error:(NSError **)errPtr; + +/** + * Connects to the given host and port with an optional timeout. + * + * This method invokes connectToHost:onPort:viaInterface:withTimeout:error: and uses the default interface. +**/ +- (BOOL)connectToHost:(NSString *)host + onPort:(UInt16)port + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr; + +/** + * Connects to the given host & port, via the optional interface, with an optional timeout. + * + * The host may be a domain name (e.g. "deusty.com") or an IP address string (e.g. "192.168.0.2"). + * The interface may be a name (e.g. "en1" or "lo0") or the corresponding IP address (e.g. "192.168.4.35"). + * The interface may also be used to specify the local port (see below). + * + * To not time out use a negative time interval. + * + * This method will return NO if an error is detected, and set the error pointer (if one was given). + * Possible errors would be a nil host, invalid interface, or socket is already connected. + * + * If no errors are detected, this method will start a background connect operation and immediately return YES. + * The delegate callbacks are used to notify you when the socket connects, or if the host was unreachable. + * + * Since this class supports queued reads and writes, you can immediately start reading and/or writing. + * All read/write operations will be queued, and upon socket connection, + * the operations will be dequeued and processed in order. + * + * The interface may optionally contain a port number at the end of the string, separated by a colon. + * This allows you to specify the local port that should be used for the outgoing connection. (read paragraph to end) + * To specify both interface and local port: "en1:8082" or "192.168.4.35:2424". + * To specify only local port: ":8082". + * Please note this is an advanced feature, and is somewhat hidden on purpose. + * You should understand that 99.999% of the time you should NOT specify the local port for an outgoing connection. + * If you think you need to, there is a very good chance you have a fundamental misunderstanding somewhere. + * Local ports do NOT need to match remote ports. In fact, they almost never do. + * This feature is here for networking professionals using very advanced techniques. +**/ +- (BOOL)connectToHost:(NSString *)host + onPort:(UInt16)port + viaInterface:(NSString *)interface + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr; + +/** + * Connects to the given address, specified as a sockaddr structure wrapped in a NSData object. + * For example, a NSData object returned from NSNetservice's addresses method. + * + * If you have an existing struct sockaddr you can convert it to a NSData object like so: + * struct sockaddr sa -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len]; + * struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len]; + * + * This method invokes connectToAdd +**/ +- (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr; + +/** + * This method is the same as connectToAddress:error: with an additional timeout option. + * To not time out use a negative time interval, or simply use the connectToAddress:error: method. +**/ +- (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr; + +/** + * Connects to the given address, using the specified interface and timeout. + * + * The address is specified as a sockaddr structure wrapped in a NSData object. + * For example, a NSData object returned from NSNetservice's addresses method. + * + * If you have an existing struct sockaddr you can convert it to a NSData object like so: + * struct sockaddr sa -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len]; + * struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len]; + * + * The interface may be a name (e.g. "en1" or "lo0") or the corresponding IP address (e.g. "192.168.4.35"). + * The interface may also be used to specify the local port (see below). + * + * The timeout is optional. To not time out use a negative time interval. + * + * This method will return NO if an error is detected, and set the error pointer (if one was given). + * Possible errors would be a nil host, invalid interface, or socket is already connected. + * + * If no errors are detected, this method will start a background connect operation and immediately return YES. + * The delegate callbacks are used to notify you when the socket connects, or if the host was unreachable. + * + * Since this class supports queued reads and writes, you can immediately start reading and/or writing. + * All read/write operations will be queued, and upon socket connection, + * the operations will be dequeued and processed in order. + * + * The interface may optionally contain a port number at the end of the string, separated by a colon. + * This allows you to specify the local port that should be used for the outgoing connection. (read paragraph to end) + * To specify both interface and local port: "en1:8082" or "192.168.4.35:2424". + * To specify only local port: ":8082". + * Please note this is an advanced feature, and is somewhat hidden on purpose. + * You should understand that 99.999% of the time you should NOT specify the local port for an outgoing connection. + * If you think you need to, there is a very good chance you have a fundamental misunderstanding somewhere. + * Local ports do NOT need to match remote ports. In fact, they almost never do. + * This feature is here for networking professionals using very advanced techniques. +**/ +- (BOOL)connectToAddress:(NSData *)remoteAddr + viaInterface:(NSString *)interface + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr; + +#pragma mark Disconnecting + +/** + * Disconnects immediately (synchronously). Any pending reads or writes are dropped. + * If the socket is not already disconnected, the socketDidDisconnect delegate method + * will be called immediately, before this method returns. + * + * Please note the recommended way of releasing an AsyncSocket instance (e.g. in a dealloc method) + * [asyncSocket setDelegate:nil]; + * [asyncSocket disconnect]; + * [asyncSocket release]; +**/ +- (void)disconnect; + +/** + * Disconnects after all pending reads have completed. + * After calling this, the read and write methods will do nothing. + * The socket will disconnect even if there are still pending writes. +**/ +- (void)disconnectAfterReading; + +/** + * Disconnects after all pending writes have completed. + * After calling this, the read and write methods will do nothing. + * The socket will disconnect even if there are still pending reads. +**/ +- (void)disconnectAfterWriting; + +/** + * Disconnects after all pending reads and writes have completed. + * After calling this, the read and write methods will do nothing. +**/ +- (void)disconnectAfterReadingAndWriting; + +#pragma mark Diagnostics + +/** + * Returns whether the socket is disconnected or connected. + * + * A disconnected socket may be recycled. + * That is, it can used again for connecting or listening. + * + * If a socket is in the process of connecting, it may be neither disconnected nor connected. +**/ +- (BOOL)isDisconnected; +- (BOOL)isConnected; + +/** + * Returns the local or remote host and port to which this socket is connected, or nil and 0 if not connected. + * The host will be an IP address. +**/ +- (NSString *)connectedHost; +- (UInt16)connectedPort; + +- (NSString *)localHost; +- (UInt16)localPort; + +/** + * Returns the local or remote address to which this socket is connected, + * specified as a sockaddr structure wrapped in a NSData object. + * + * See also the connectedHost, connectedPort, localHost and localPort methods. +**/ +- (NSData *)connectedAddress; +- (NSData *)localAddress; + +/** + * Returns whether the socket is IPv4 or IPv6. + * An accepting socket may be both. +**/ +- (BOOL)isIPv4; +- (BOOL)isIPv6; + +/** + * Returns whether or not the socket has been secured via SSL/TLS. + * + * See also the startTLS method. +**/ +- (BOOL)isSecure; + +#pragma mark Reading + +// The readData and writeData methods won't block (they are asynchronous). +// +// When a read is complete the socket:didReadData:withTag: delegate method is dispatched on the delegateQueue. +// When a write is complete the socket:didWriteDataWithTag: delegate method is dispatched on the delegateQueue. +// +// You may optionally set a timeout for any read/write operation. (To not timeout, use a negative time interval.) +// If a read/write opertion times out, the corresponding "socket:shouldTimeout..." delegate method +// is called to optionally allow you to extend the timeout. +// Upon a timeout, the "socket:willDisconnectWithError:" method is called, followed by "socketDidDisconnect". +// +// The tag is for your convenience. +// You can use it as an array index, step number, state id, pointer, etc. + +/** + * Reads the first available bytes that become available on the socket. + * + * If the timeout value is negative, the read operation will not use a timeout. +**/ +- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag; + +/** + * Reads the first available bytes that become available on the socket. + * The bytes will be appended to the given byte buffer starting at the given offset. + * The given buffer will automatically be increased in size if needed. + * + * If the timeout value is negative, the read operation will not use a timeout. + * If the buffer if nil, the socket will create a buffer for you. + * + * If the bufferOffset is greater than the length of the given buffer, + * the method will do nothing, and the delegate will not be called. + * + * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it. + * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer. + * That is, it will reference the bytes that were appended to the given buffer. +**/ +- (void)readDataWithTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag; + +/** + * Reads the first available bytes that become available on the socket. + * The bytes will be appended to the given byte buffer starting at the given offset. + * The given buffer will automatically be increased in size if needed. + * A maximum of length bytes will be read. + * + * If the timeout value is negative, the read operation will not use a timeout. + * If the buffer if nil, a buffer will automatically be created for you. + * If maxLength is zero, no length restriction is enforced. + * + * If the bufferOffset is greater than the length of the given buffer, + * the method will do nothing, and the delegate will not be called. + * + * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it. + * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer. + * That is, it will reference the bytes that were appended to the given buffer. +**/ +- (void)readDataWithTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + maxLength:(NSUInteger)length + tag:(long)tag; + +/** + * Reads the given number of bytes. + * + * If the timeout value is negative, the read operation will not use a timeout. + * + * If the length is 0, this method does nothing and the delegate is not called. +**/ +- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag; + +/** + * Reads the given number of bytes. + * The bytes will be appended to the given byte buffer starting at the given offset. + * The given buffer will automatically be increased in size if needed. + * + * If the timeout value is negative, the read operation will not use a timeout. + * If the buffer if nil, a buffer will automatically be created for you. + * + * If the length is 0, this method does nothing and the delegate is not called. + * If the bufferOffset is greater than the length of the given buffer, + * the method will do nothing, and the delegate will not be called. + * + * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it. + * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer. + * That is, it will reference the bytes that were appended to the given buffer. +**/ +- (void)readDataToLength:(NSUInteger)length + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag; + +/** + * Reads bytes until (and including) the passed "data" parameter, which acts as a separator. + * + * If the timeout value is negative, the read operation will not use a timeout. + * + * If you pass nil or zero-length data as the "data" parameter, + * the method will do nothing, and the delegate will not be called. + * + * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter. + * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for + * a character, the read will prematurely end. +**/ +- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag; + +/** + * Reads bytes until (and including) the passed "data" parameter, which acts as a separator. + * The bytes will be appended to the given byte buffer starting at the given offset. + * The given buffer will automatically be increased in size if needed. + * + * If the timeout value is negative, the read operation will not use a timeout. + * If the buffer if nil, a buffer will automatically be created for you. + * + * If the bufferOffset is greater than the length of the given buffer, + * the method will do nothing, and the delegate will not be called. + * + * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it. + * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer. + * That is, it will reference the bytes that were appended to the given buffer. + * + * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter. + * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for + * a character, the read will prematurely end. +**/ +- (void)readDataToData:(NSData *)data + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag; + +/** + * Reads bytes until (and including) the passed "data" parameter, which acts as a separator. + * + * If the timeout value is negative, the read operation will not use a timeout. + * + * If maxLength is zero, no length restriction is enforced. + * Otherwise if maxLength bytes are read without completing the read, + * it is treated similarly to a timeout - the socket is closed with a GCDAsyncSocketReadMaxedOutError. + * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end. + * + * If you pass nil or zero-length data as the "data" parameter, + * the method will do nothing, and the delegate will not be called. + * If you pass a maxLength parameter that is less than the length of the data parameter, + * the method will do nothing, and the delegate will not be called. + * + * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter. + * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for + * a character, the read will prematurely end. +**/ +- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(NSUInteger)length tag:(long)tag; + +/** + * Reads bytes until (and including) the passed "data" parameter, which acts as a separator. + * The bytes will be appended to the given byte buffer starting at the given offset. + * The given buffer will automatically be increased in size if needed. + * + * If the timeout value is negative, the read operation will not use a timeout. + * If the buffer if nil, a buffer will automatically be created for you. + * + * If maxLength is zero, no length restriction is enforced. + * Otherwise if maxLength bytes are read without completing the read, + * it is treated similarly to a timeout - the socket is closed with a GCDAsyncSocketReadMaxedOutError. + * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end. + * + * If you pass a maxLength parameter that is less than the length of the data parameter, + * the method will do nothing, and the delegate will not be called. + * If the bufferOffset is greater than the length of the given buffer, + * the method will do nothing, and the delegate will not be called. + * + * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it. + * After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer. + * That is, it will reference the bytes that were appended to the given buffer. + * + * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter. + * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for + * a character, the read will prematurely end. +**/ +- (void)readDataToData:(NSData *)data + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + maxLength:(NSUInteger)length + tag:(long)tag; + +#pragma mark Writing + +/** + * Writes data to the socket, and calls the delegate when finished. + * + * If you pass in nil or zero-length data, this method does nothing and the delegate will not be called. + * If the timeout value is negative, the write operation will not use a timeout. +**/ +- (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag; + +#pragma mark Security + +/** + * Secures the connection using SSL/TLS. + * + * This method may be called at any time, and the TLS handshake will occur after all pending reads and writes + * are finished. This allows one the option of sending a protocol dependent StartTLS message, and queuing + * the upgrade to TLS at the same time, without having to wait for the write to finish. + * Any reads or writes scheduled after this method is called will occur over the secured connection. + * + * The possible keys and values for the TLS settings are well documented. + * Some possible keys are: + * - kCFStreamSSLLevel + * - kCFStreamSSLAllowsExpiredCertificates + * - kCFStreamSSLAllowsExpiredRoots + * - kCFStreamSSLAllowsAnyRoot + * - kCFStreamSSLValidatesCertificateChain + * - kCFStreamSSLPeerName + * - kCFStreamSSLCertificates + * - kCFStreamSSLIsServer + * + * Please refer to Apple's documentation for associated values, as well as other possible keys. + * + * If you pass in nil or an empty dictionary, the default settings will be used. + * + * The default settings will check to make sure the remote party's certificate is signed by a + * trusted 3rd party certificate agency (e.g. verisign) and that the certificate is not expired. + * However it will not verify the name on the certificate unless you + * give it a name to verify against via the kCFStreamSSLPeerName key. + * The security implications of this are important to understand. + * Imagine you are attempting to create a secure connection to MySecureServer.com, + * but your socket gets directed to MaliciousServer.com because of a hacked DNS server. + * If you simply use the default settings, and MaliciousServer.com has a valid certificate, + * the default settings will not detect any problems since the certificate is valid. + * To properly secure your connection in this particular scenario you + * should set the kCFStreamSSLPeerName property to "MySecureServer.com". + * If you do not know the peer name of the remote host in advance (for example, you're not sure + * if it will be "domain.com" or "www.domain.com"), then you can use the default settings to validate the + * certificate, and then use the X509Certificate class to verify the issuer after the socket has been secured. + * The X509Certificate class is part of the CocoaAsyncSocket open source project. + **/ +- (void)startTLS:(NSDictionary *)tlsSettings; + +#pragma mark Advanced + +/** + * It's not thread-safe to access certain variables from outside the socket's internal queue. + * + * For example, the socket file descriptor. + * File descriptors are simply integers which reference an index in the per-process file table. + * However, when one requests a new file descriptor (by opening a file or socket), + * the file descriptor returned is guaranteed to be the lowest numbered unused descriptor. + * So if we're not careful, the following could be possible: + * + * - Thread A invokes a method which returns the socket's file descriptor. + * - The socket is closed via the socket's internal queue on thread B. + * - Thread C opens a file, and subsequently receives the file descriptor that was previously the socket's FD. + * - Thread A is now accessing/altering the file instead of the socket. + * + * In addition to this, other variables are not actually objects, + * and thus cannot be retained/released or even autoreleased. + * An example is the sslContext, of type SSLContextRef, which is actually a malloc'd struct. + * + * Although there are internal variables that make it difficult to maintain thread-safety, + * it is important to provide access to these variables + * to ensure this class can be used in a wide array of environments. + * This method helps to accomplish this by invoking the current block on the socket's internal queue. + * The methods below can be invoked from within the block to access + * those generally thread-unsafe internal variables in a thread-safe manner. + * The given block will be invoked synchronously on the socket's internal queue. + * + * If you save references to any protected variables and use them outside the block, you do so at your own peril. +**/ +- (void)performBlock:(dispatch_block_t)block; + +/** + * These methods are only available from within the context of a performBlock: invocation. + * See the documentation for the performBlock: method above. + * + * Provides access to the socket's file descriptor(s). + * If the socket is a server socket (is accepting incoming connections), + * it might actually have multiple internal socket file descriptors - one for IPv4 and one for IPv6. +**/ +- (int)socketFD; +- (int)socket4FD; +- (int)socket6FD; + +#if TARGET_OS_IPHONE + +/** + * These methods are only available from within the context of a performBlock: invocation. + * See the documentation for the performBlock: method above. + * + * Provides access to the socket's internal read/write streams. + * These streams are normally only created if startTLS has been invoked to start SSL/TLS (see note below), + * but if these methods are invoked, the read/write streams will be created automatically so that you may use them. + * + * See also: (BOOL)enableBackgroundingOnSocket + * + * Note: Apple has decided to keep the SecureTransport framework private is iOS. + * This means the only supplied way to do SSL/TLS is via CFStream or some other API layered on top of it. + * Thus, in order to provide SSL/TLS support on iOS we are forced to rely on CFStream, + * instead of the preferred and faster and more powerful SecureTransport. +**/ +- (CFReadStreamRef)readStream; +- (CFWriteStreamRef)writeStream; + +/** + * This method is only available from within the context of a performBlock: invocation. + * See the documentation for the performBlock: method above. + * + * Configures the socket to allow it to operate when the iOS application has been backgrounded. + * In other words, this method creates a read & write stream, and invokes: + * + * CFReadStreamSetProperty(readStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP); + * CFWriteStreamSetProperty(writeStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP); + * + * Returns YES if successful, NO otherwise. + * + * Note: Apple does not officially support backgrounding server sockets. + * That is, if your socket is accepting incoming connections, Apple does not officially support + * allowing iOS applications to accept incoming connections while an app is backgrounded. + * + * Example usage: + * + * - (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port + * { + * [asyncSocket performBlock:^{ + * [asyncSocket enableBackgroundingOnSocket]; + * }]; + * } +**/ +- (BOOL)enableBackgroundingOnSocket; + +/** + * This method is only available from within the context of a performBlock: invocation. + * See the documentation for the performBlock: method above. + * + * This method should be used in place of the usual enableBackgroundingOnSocket method if + * you later plan on securing the socket with SSL/TLS via the startTLS method. + * + * This is due to a bug in iOS. Description of the bug: + * + * First of all, Apple has decided to keep the SecureTransport framework private in iOS. + * This removes the preferred, faster, and more powerful way of doing SSL/TLS. + * The only option they have given us on iOS is to use CFStream. + * + * In addition to this, Apple does not allow us to enable SSL/TLS on a stream after it has been opened. + * This effectively breaks many newer protocols which negotiate upgrades to TLS in-band (such as XMPP). + * + * And on top of that, if we flag a socket for backgrounding, that flag doesn't take effect until + * after we have opened the socket. And if we try to flag the socket for backgrounding after we've opened + * the socket, the flagging fails. + * + * So the order of operations matters, and the ONLY order that works is this: + * + * - Create read and write stream + * - Mark streams for backgrounding + * - Setup SSL on streams + * - Open streams + * + * So the caveat is that this method will mark the socket for backgrounding, + * but it will not open the read and write streams. (Because if it did, later attempts to start TLS would fail.) + * Thus the socket will not actually support backgrounding until after the startTLS method has been called. +**/ +- (BOOL)enableBackgroundingOnSocketWithCaveat; + +#else + +/** + * This method is only available from within the context of a performBlock: invocation. + * See the documentation for the performBlock: method above. + * + * Provides access to the socket's SSLContext, if SSL/TLS has been started on the socket. +**/ +- (SSLContextRef)sslContext; + +#endif + +#pragma mark Utilities + +/** + * Extracting host and port information from raw address data. +**/ ++ (NSString *)hostFromAddress:(NSData *)address; ++ (UInt16)portFromAddress:(NSData *)address; ++ (BOOL)getHost:(NSString **)hostPtr port:(UInt16 *)portPtr fromAddress:(NSData *)address; + +/** + * A few common line separators, for use with the readDataToData:... methods. +**/ ++ (NSData *)CRLFData; // 0x0D0A ++ (NSData *)CRData; // 0x0D ++ (NSData *)LFData; // 0x0A ++ (NSData *)ZeroData; // 0x00 + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol GCDAsyncSocketDelegate +@optional + +/** + * This method is called immediately prior to socket:didAcceptNewSocket:. + * It optionally allows a listening socket to specify the socketQueue for a new accepted socket. + * If this method is not implemented, or returns NULL, the new accepted socket will create its own default queue. + * + * Since you cannot autorelease a dispatch_queue, + * this method uses the "new" prefix in its name to specify that the returned queue has been retained. + * + * Thus you could do something like this in the implementation: + * return dispatch_queue_create("MyQueue", NULL); + * + * If you are placing multiple sockets on the same queue, + * then care should be taken to increment the retain count each time this method is invoked. + * + * For example, your implementation might look something like this: + * dispatch_retain(myExistingQueue); + * return myExistingQueue; +**/ +- (dispatch_queue_t)newSocketQueueForConnectionFromAddress:(NSData *)address onSocket:(GCDAsyncSocket *)sock; + +/** + * Called when a socket accepts a connection. + * Another socket is automatically spawned to handle it. + * + * You must retain the newSocket if you wish to handle the connection. + * Otherwise the newSocket instance will be released and the spawned connection will be closed. + * + * By default the new socket will have the same delegate and delegateQueue. + * You may, of course, change this at any time. +**/ +- (void)socket:(GCDAsyncSocket *)sock didAcceptNewSocket:(GCDAsyncSocket *)newSocket; + +/** + * Called when a socket connects and is ready for reading and writing. + * The host parameter will be an IP address, not a DNS name. +**/ +- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port; + +/** + * Called when a socket has completed reading the requested data into memory. + * Not called if there is an error. +**/ +- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag; + +/** + * Called when a socket has read in data, but has not yet completed the read. + * This would occur if using readToData: or readToLength: methods. + * It may be used to for things such as updating progress bars. +**/ +- (void)socket:(GCDAsyncSocket *)sock didReadPartialDataOfLength:(NSUInteger)partialLength tag:(long)tag; + +/** + * Called when a socket has completed writing the requested data. Not called if there is an error. +**/ +- (void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag; + +/** + * Called when a socket has written some data, but has not yet completed the entire write. + * It may be used to for things such as updating progress bars. +**/ +- (void)socket:(GCDAsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag; + +/** + * Called if a read operation has reached its timeout without completing. + * This method allows you to optionally extend the timeout. + * If you return a positive time interval (> 0) the read's timeout will be extended by the given amount. + * If you don't implement this method, or return a non-positive time interval (<= 0) the read will timeout as usual. + * + * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method. + * The length parameter is the number of bytes that have been read so far for the read operation. + * + * Note that this method may be called multiple times for a single read if you return positive numbers. +**/ +- (NSTimeInterval)socket:(GCDAsyncSocket *)sock shouldTimeoutReadWithTag:(long)tag + elapsed:(NSTimeInterval)elapsed + bytesDone:(NSUInteger)length; + +/** + * Called if a write operation has reached its timeout without completing. + * This method allows you to optionally extend the timeout. + * If you return a positive time interval (> 0) the write's timeout will be extended by the given amount. + * If you don't implement this method, or return a non-positive time interval (<= 0) the write will timeout as usual. + * + * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method. + * The length parameter is the number of bytes that have been written so far for the write operation. + * + * Note that this method may be called multiple times for a single write if you return positive numbers. +**/ +- (NSTimeInterval)socket:(GCDAsyncSocket *)sock shouldTimeoutWriteWithTag:(long)tag + elapsed:(NSTimeInterval)elapsed + bytesDone:(NSUInteger)length; + +/** + * Conditionally called if the read stream closes, but the write stream may still be writeable. + * + * This delegate method is only called if autoDisconnectOnClosedReadStream has been set to NO. + * See the discussion on the autoDisconnectOnClosedReadStream method for more information. +**/ +- (void)socketDidCloseReadStream:(GCDAsyncSocket *)sock; + +/** + * Called when a socket disconnects with or without error. + * + * If you call the disconnect method, and the socket wasn't already disconnected, + * this delegate method will be called before the disconnect method returns. +**/ +- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)err; + +/** + * Called after the socket has successfully completed SSL/TLS negotiation. + * This method is not called unless you use the provided startTLS method. + * + * If a SSL/TLS negotiation fails (invalid certificate, etc) then the socket will immediately close, + * and the socketDidDisconnect:withError: delegate method will be called with the specific SSL error code. +**/ +- (void)socketDidSecure:(GCDAsyncSocket *)sock; + +@end diff --git a/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.m b/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.m new file mode 100644 index 0000000..ca1e010 --- /dev/null +++ b/xmpp/Vendor/CocoaAsyncSocket/GCDAsyncSocket.m @@ -0,0 +1,6492 @@ +// +// GCDAsyncSocket.m +// +// This class is in the public domain. +// Originally created by Robbie Hanson in Q4 2010. +// Updated and maintained by Deusty LLC and the Mac development community. +// +// http://code.google.com/p/cocoaasyncsocket/ +// + +#import "GCDAsyncSocket.h" + +#if TARGET_OS_IPHONE + #import +#endif + +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import + + +#if 0 + +// Logging Enabled - See log level below + +// Logging uses the CocoaLumberjack framework (which is also GCD based). +// http://code.google.com/p/cocoalumberjack/ +// +// It allows us to do a lot of logging without significantly slowing down the code. +#import "DDLog.h" + +#define LogAsync YES +#define LogContext 65535 + +#define LogObjc(flg, frmt, ...) LOG_OBJC_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__) +#define LogC(flg, frmt, ...) LOG_C_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__) + +#define LogError(frmt, ...) LogObjc(LOG_FLAG_ERROR, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogWarn(frmt, ...) LogObjc(LOG_FLAG_WARN, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogInfo(frmt, ...) LogObjc(LOG_FLAG_INFO, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogVerbose(frmt, ...) LogObjc(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) + +#define LogCError(frmt, ...) LogC(LOG_FLAG_ERROR, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogCWarn(frmt, ...) LogC(LOG_FLAG_WARN, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogCInfo(frmt, ...) LogC(LOG_FLAG_INFO, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) +#define LogCVerbose(frmt, ...) LogC(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__) + +#define LogTrace() LogObjc(LOG_FLAG_VERBOSE, @"%@: %@", THIS_FILE, THIS_METHOD) +#define LogCTrace() LogC(LOG_FLAG_VERBOSE, @"%@: %s", THIS_FILE, __FUNCTION__) + +// Log levels : off, error, warn, info, verbose +static const int logLevel = LOG_LEVEL_VERBOSE; + +#else + +// Logging Disabled + +#define LogError(frmt, ...) {} +#define LogWarn(frmt, ...) {} +#define LogInfo(frmt, ...) {} +#define LogVerbose(frmt, ...) {} + +#define LogCError(frmt, ...) {} +#define LogCWarn(frmt, ...) {} +#define LogCInfo(frmt, ...) {} +#define LogCVerbose(frmt, ...) {} + +#define LogTrace() {} +#define LogCTrace(frmt, ...) {} + +#endif + +/** + * Seeing a return statements within an inner block + * can sometimes be mistaken for a return point of the enclosing method. + * This makes inline blocks a bit easier to read. +**/ +#define return_from_block return + +/** + * A socket file descriptor is really just an integer. + * It represents the index of the socket within the kernel. + * This makes invalid file descriptor comparisons easier to read. +**/ +#define SOCKET_NULL -1 + + +NSString *const GCDAsyncSocketException = @"GCDAsyncSocketException"; +NSString *const GCDAsyncSocketErrorDomain = @"GCDAsyncSocketErrorDomain"; + +#if !TARGET_OS_IPHONE +NSString *const GCDAsyncSocketSSLCipherSuites = @"GCDAsyncSocketSSLCipherSuites"; +NSString *const GCDAsyncSocketSSLDiffieHellmanParameters = @"GCDAsyncSocketSSLDiffieHellmanParameters"; +#endif + +enum GCDAsyncSocketFlags +{ + kSocketStarted = 1 << 0, // If set, socket has been started (accepting/connecting) + kConnected = 1 << 1, // If set, the socket is connected + kForbidReadsWrites = 1 << 2, // If set, no new reads or writes are allowed + kReadsPaused = 1 << 3, // If set, reads are paused due to possible timeout + kWritesPaused = 1 << 4, // If set, writes are paused due to possible timeout + kDisconnectAfterReads = 1 << 5, // If set, disconnect after no more reads are queued + kDisconnectAfterWrites = 1 << 6, // If set, disconnect after no more writes are queued + kSocketCanAcceptBytes = 1 << 7, // If set, we know socket can accept bytes. If unset, it's unknown. + kReadSourceSuspended = 1 << 8, // If set, the read source is suspended + kWriteSourceSuspended = 1 << 9, // If set, the write source is suspended + kQueuedTLS = 1 << 10, // If set, we've queued an upgrade to TLS + kStartingReadTLS = 1 << 11, // If set, we're waiting for TLS negotiation to complete + kStartingWriteTLS = 1 << 12, // If set, we're waiting for TLS negotiation to complete + kSocketSecure = 1 << 13, // If set, socket is using secure communication via SSL/TLS +#if TARGET_OS_IPHONE + kAddedHandshakeListener = 1 << 14, // If set, rw streams have been added to handshake listener thread + kSecureSocketHasBytesAvailable = 1 << 15, // If set, CFReadStream has notified us of bytes available +#endif +}; + +enum GCDAsyncSocketConfig +{ + kIPv4Disabled = 1 << 0, // If set, IPv4 is disabled + kIPv6Disabled = 1 << 1, // If set, IPv6 is disabled + kPreferIPv6 = 1 << 2, // If set, IPv6 is preferred over IPv4 + kAllowHalfDuplexConnection = 1 << 3, // If set, the socket will stay open even if the read stream closes +}; + +#if TARGET_OS_IPHONE + static NSThread *sslHandshakeThread; +#endif + +@interface GCDAsyncSocket (Private) + +// Accepting +- (BOOL)doAccept:(int)socketFD; + +// Connecting +- (void)startConnectTimeout:(NSTimeInterval)timeout; +- (void)endConnectTimeout; +- (void)doConnectTimeout; +- (void)lookup:(int)aConnectIndex host:(NSString *)host port:(UInt16)port; +- (void)lookup:(int)aConnectIndex didSucceedWithAddress4:(NSData *)address4 address6:(NSData *)address6; +- (void)lookup:(int)aConnectIndex didFail:(NSError *)error; +- (BOOL)connectWithAddress4:(NSData *)address4 address6:(NSData *)address6 error:(NSError **)errPtr; +- (void)didConnect:(int)aConnectIndex; +- (void)didNotConnect:(int)aConnectIndex error:(NSError *)error; + +// Disconnect +- (void)closeWithError:(NSError *)error; +- (void)close; +- (void)maybeClose; + +// Errors +- (NSError *)badConfigError:(NSString *)msg; +- (NSError *)badParamError:(NSString *)msg; +- (NSError *)gaiError:(int)gai_error; +- (NSError *)errnoError; +- (NSError *)errnoErrorWithReason:(NSString *)reason; +- (NSError *)connectTimeoutError; +- (NSError *)otherError:(NSString *)msg; + +// Diagnostics +- (NSString *)connectedHost4; +- (NSString *)connectedHost6; +- (UInt16)connectedPort4; +- (UInt16)connectedPort6; +- (NSString *)localHost4; +- (NSString *)localHost6; +- (UInt16)localPort4; +- (UInt16)localPort6; +- (NSString *)connectedHostFromSocket4:(int)socketFD; +- (NSString *)connectedHostFromSocket6:(int)socketFD; +- (UInt16)connectedPortFromSocket4:(int)socketFD; +- (UInt16)connectedPortFromSocket6:(int)socketFD; +- (NSString *)localHostFromSocket4:(int)socketFD; +- (NSString *)localHostFromSocket6:(int)socketFD; +- (UInt16)localPortFromSocket4:(int)socketFD; +- (UInt16)localPortFromSocket6:(int)socketFD; + +// Utilities +- (void)getInterfaceAddress4:(NSData **)addr4Ptr + address6:(NSData **)addr6Ptr + fromDescription:(NSString *)interfaceDescription + port:(UInt16)port; +- (void)setupReadAndWriteSourcesForNewlyConnectedSocket:(int)socketFD; +- (void)suspendReadSource; +- (void)resumeReadSource; +- (void)suspendWriteSource; +- (void)resumeWriteSource; + +// Reading +- (void)maybeDequeueRead; +- (void)doReadData; +- (void)doReadEOF; +- (void)completeCurrentRead; +- (void)endCurrentRead; +- (void)setupReadTimerWithTimeout:(NSTimeInterval)timeout; +- (void)doReadTimeout; +- (void)doReadTimeoutWithExtension:(NSTimeInterval)timeoutExtension; + +// Writing +- (void)maybeDequeueWrite; +- (void)doWriteData; +- (void)completeCurrentWrite; +- (void)endCurrentWrite; +- (void)setupWriteTimerWithTimeout:(NSTimeInterval)timeout; +- (void)doWriteTimeout; +- (void)doWriteTimeoutWithExtension:(NSTimeInterval)timeoutExtension; + +// Security +- (void)maybeStartTLS; +#if !TARGET_OS_IPHONE +- (void)continueSSLHandshake; +#endif + +// Class Methods ++ (NSString *)hostFromAddress4:(struct sockaddr_in *)pSockaddr4; ++ (NSString *)hostFromAddress6:(struct sockaddr_in6 *)pSockaddr6; ++ (UInt16)portFromAddress4:(struct sockaddr_in *)pSockaddr4; ++ (UInt16)portFromAddress6:(struct sockaddr_in6 *)pSockaddr6; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The GCDAsyncReadPacket encompasses the instructions for any given read. + * The content of a read packet allows the code to determine if we're: + * - reading to a certain length + * - reading to a certain separator + * - or simply reading the first chunk of available data +**/ +@interface GCDAsyncReadPacket : NSObject +{ + @public + NSMutableData *buffer; + NSUInteger startOffset; + NSUInteger bytesDone; + NSUInteger maxLength; + NSTimeInterval timeout; + NSUInteger readLength; + NSData *term; + BOOL bufferOwner; + NSUInteger originalBufferLength; + long tag; +} +- (id)initWithData:(NSMutableData *)d + startOffset:(NSUInteger)s + maxLength:(NSUInteger)m + timeout:(NSTimeInterval)t + readLength:(NSUInteger)l + terminator:(NSData *)e + tag:(long)i; + +- (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead; + +- (NSUInteger)optimalReadLengthWithDefault:(NSUInteger)defaultValue shouldPreBuffer:(BOOL *)shouldPreBufferPtr; + +- (NSUInteger)readLengthForNonTermWithHint:(NSUInteger)bytesAvailable; +- (NSUInteger)readLengthForTermWithHint:(NSUInteger)bytesAvailable shouldPreBuffer:(BOOL *)shouldPreBufferPtr; +- (NSUInteger)readLengthForTermWithPreBuffer:(NSData *)preBuffer found:(BOOL *)foundPtr; + +- (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes; + +@end + +@implementation GCDAsyncReadPacket + +- (id)initWithData:(NSMutableData *)d + startOffset:(NSUInteger)s + maxLength:(NSUInteger)m + timeout:(NSTimeInterval)t + readLength:(NSUInteger)l + terminator:(NSData *)e + tag:(long)i +{ + if((self = [super init])) + { + bytesDone = 0; + maxLength = m; + timeout = t; + readLength = l; + term = [e copy]; + tag = i; + + if (d) + { + buffer = [d retain]; + startOffset = s; + bufferOwner = NO; + originalBufferLength = [d length]; + } + else + { + if (readLength > 0) + buffer = [[NSMutableData alloc] initWithLength:readLength]; + else + buffer = [[NSMutableData alloc] initWithLength:0]; + + startOffset = 0; + bufferOwner = YES; + originalBufferLength = 0; + } + } + return self; +} + +/** + * Increases the length of the buffer (if needed) to ensure a read of the given size will fit. +**/ +- (void)ensureCapacityForAdditionalDataOfLength:(NSUInteger)bytesToRead +{ + NSUInteger buffSize = [buffer length]; + NSUInteger buffUsed = startOffset + bytesDone; + + NSUInteger buffSpace = buffSize - buffUsed; + + if (bytesToRead > buffSpace) + { + NSUInteger buffInc = bytesToRead - buffSpace; + + [buffer increaseLengthBy:buffInc]; + } +} + +/** + * This method is used when we do NOT know how much data is available to be read from the socket. + * This method returns the default value unless it exceeds the specified readLength or maxLength. + * + * Furthermore, the shouldPreBuffer decision is based upon the packet type, + * and whether the returned value would fit in the current buffer without requiring a resize of the buffer. +**/ +- (NSUInteger)optimalReadLengthWithDefault:(NSUInteger)defaultValue shouldPreBuffer:(BOOL *)shouldPreBufferPtr +{ + NSUInteger result; + + if (readLength > 0) + { + // Read a specific length of data + + result = MIN(defaultValue, (readLength - bytesDone)); + + // There is no need to prebuffer since we know exactly how much data we need to read. + // Even if the buffer isn't currently big enough to fit this amount of data, + // it would have to be resized eventually anyway. + + if (shouldPreBufferPtr) + *shouldPreBufferPtr = NO; + } + else + { + // Either reading until we find a specified terminator, + // or we're simply reading all available data. + // + // In other words, one of: + // + // - readDataToData packet + // - readDataWithTimeout packet + + if (maxLength > 0) + result = MIN(defaultValue, (maxLength - bytesDone)); + else + result = defaultValue; + + // Since we don't know the size of the read in advance, + // the shouldPreBuffer decision is based upon whether the returned value would fit + // in the current buffer without requiring a resize of the buffer. + // + // This is because, in all likelyhood, the amount read from the socket will be less than the default value. + // Thus we should avoid over-allocating the read buffer when we can simply use the pre-buffer instead. + + if (shouldPreBufferPtr) + { + NSUInteger buffSize = [buffer length]; + NSUInteger buffUsed = startOffset + bytesDone; + + NSUInteger buffSpace = buffSize - buffUsed; + + if (buffSpace >= result) + *shouldPreBufferPtr = NO; + else + *shouldPreBufferPtr = YES; + } + } + + return result; +} + +/** + * For read packets without a set terminator, returns the amount of data + * that can be read without exceeding the readLength or maxLength. + * + * The given parameter indicates the number of bytes estimated to be available on the socket, + * which is taken into consideration during the calculation. + * + * The given hint MUST be greater than zero. +**/ +- (NSUInteger)readLengthForNonTermWithHint:(NSUInteger)bytesAvailable +{ + NSAssert(term == nil, @"This method does not apply to term reads"); + NSAssert(bytesAvailable > 0, @"Invalid parameter: bytesAvailable"); + + if (readLength > 0) + { + // Read a specific length of data + + return MIN(bytesAvailable, (readLength - bytesDone)); + + // No need to avoid resizing the buffer. + // If the user provided their own buffer, + // and told us to read a certain length of data that exceeds the size of the buffer, + // then it is clear that our code will resize the buffer during the read operation. + // + // This method does not actually do any resizing. + // The resizing will happen elsewhere if needed. + } + else + { + // Read all available data + + NSUInteger result = bytesAvailable; + + if (maxLength > 0) + { + result = MIN(result, (maxLength - bytesDone)); + } + + // No need to avoid resizing the buffer. + // If the user provided their own buffer, + // and told us to read all available data without giving us a maxLength, + // then it is clear that our code might resize the buffer during the read operation. + // + // This method does not actually do any resizing. + // The resizing will happen elsewhere if needed. + + return result; + } +} + +/** + * For read packets with a set terminator, returns the amount of data + * that can be read without exceeding the maxLength. + * + * The given parameter indicates the number of bytes estimated to be available on the socket, + * which is taken into consideration during the calculation. + * + * To optimize memory allocations, mem copies, and mem moves + * the shouldPreBuffer boolean value will indicate if the data should be read into a prebuffer first, + * or if the data can be read directly into the read packet's buffer. +**/ +- (NSUInteger)readLengthForTermWithHint:(NSUInteger)bytesAvailable shouldPreBuffer:(BOOL *)shouldPreBufferPtr +{ + NSAssert(term != nil, @"This method does not apply to non-term reads"); + NSAssert(bytesAvailable > 0, @"Invalid parameter: bytesAvailable"); + + + NSUInteger result = bytesAvailable; + + if (maxLength > 0) + { + result = MIN(result, (maxLength - bytesDone)); + } + + // Should the data be read into the read packet's buffer, or into a pre-buffer first? + // + // One would imagine the preferred option is the faster one. + // So which one is faster? + // + // Reading directly into the packet's buffer requires: + // 1. Possibly resizing packet buffer (malloc/realloc) + // 2. Filling buffer (read) + // 3. Searching for term (memcmp) + // 4. Possibly copying overflow into prebuffer (malloc/realloc, memcpy) + // + // Reading into prebuffer first: + // 1. Possibly resizing prebuffer (malloc/realloc) + // 2. Filling buffer (read) + // 3. Searching for term (memcmp) + // 4. Copying underflow into packet buffer (malloc/realloc, memcpy) + // 5. Removing underflow from prebuffer (memmove) + // + // Comparing the performance of the two we can see that reading + // data into the prebuffer first is slower due to the extra memove. + // + // However: + // The implementation of NSMutableData is open source via core foundation's CFMutableData. + // Decreasing the length of a mutable data object doesn't cause a realloc. + // In other words, the capacity of a mutable data object can grow, but doesn't shrink. + // + // This means the prebuffer will rarely need a realloc. + // The packet buffer, on the other hand, may often need a realloc. + // This is especially true if we are the buffer owner. + // Furthermore, if we are constantly realloc'ing the packet buffer, + // and then moving the overflow into the prebuffer, + // then we're consistently over-allocating memory for each term read. + // And now we get into a bit of a tradeoff between speed and memory utilization. + // + // The end result is that the two perform very similarly. + // And we can answer the original question very simply by another means. + // + // If we can read all the data directly into the packet's buffer without resizing it first, + // then we do so. Otherwise we use the prebuffer. + + if (shouldPreBufferPtr) + { + NSUInteger buffSize = [buffer length]; + NSUInteger buffUsed = startOffset + bytesDone; + + if ((buffSize - buffUsed) >= result) + *shouldPreBufferPtr = NO; + else + *shouldPreBufferPtr = YES; + } + + return result; +} + +/** + * For read packets with a set terminator, + * returns the amount of data that can be read from the given preBuffer, + * without going over a terminator or the maxLength. + * + * It is assumed the terminator has not already been read. +**/ +- (NSUInteger)readLengthForTermWithPreBuffer:(NSData *)preBuffer found:(BOOL *)foundPtr +{ + NSAssert(term != nil, @"This method does not apply to non-term reads"); + NSAssert([preBuffer length] > 0, @"Invoked with empty pre buffer!"); + + // We know that the terminator, as a whole, doesn't exist in our own buffer. + // But it is possible that a portion of it exists in our buffer. + // So we're going to look for the terminator starting with a portion of our own buffer. + // + // Example: + // + // term length = 3 bytes + // bytesDone = 5 bytes + // preBuffer length = 5 bytes + // + // If we append the preBuffer to our buffer, + // it would look like this: + // + // --------------------- + // |B|B|B|B|B|P|P|P|P|P| + // --------------------- + // + // So we start our search here: + // + // --------------------- + // |B|B|B|B|B|P|P|P|P|P| + // -------^-^-^--------- + // + // And move forwards... + // + // --------------------- + // |B|B|B|B|B|P|P|P|P|P| + // ---------^-^-^------- + // + // Until we find the terminator or reach the end. + // + // --------------------- + // |B|B|B|B|B|P|P|P|P|P| + // ---------------^-^-^- + + BOOL found = NO; + + NSUInteger termLength = [term length]; + NSUInteger preBufferLength = [preBuffer length]; + + if ((bytesDone + preBufferLength) < termLength) + { + // Not enough data for a full term sequence yet + return preBufferLength; + } + + NSUInteger maxPreBufferLength; + if (maxLength > 0) { + maxPreBufferLength = MIN(preBufferLength, (maxLength - bytesDone)); + + // Note: maxLength >= termLength + } + else { + maxPreBufferLength = preBufferLength; + } + + uint8_t seq[termLength]; + const void *termBuf = [term bytes]; + + NSUInteger bufLen = MIN(bytesDone, (termLength - 1)); + UInt8 *buf = (UInt8 *)[buffer mutableBytes] + startOffset + bytesDone - bufLen; + + NSUInteger preLen = termLength - bufLen; + const UInt8 *pre = [preBuffer bytes]; + + NSUInteger loopCount = bufLen + maxPreBufferLength - termLength + 1; // Plus one. See example above. + + NSUInteger result = preBufferLength; + + NSUInteger i; + for (i = 0; i < loopCount; i++) + { + if (bufLen > 0) + { + // Combining bytes from buffer and preBuffer + + memcpy(seq, buf, bufLen); + memcpy(seq + bufLen, pre, preLen); + + if (memcmp(seq, termBuf, termLength) == 0) + { + result = preLen; + found = YES; + break; + } + + buf++; + bufLen--; + preLen++; + } + else + { + // Comparing directly from preBuffer + + if (memcmp(pre, termBuf, termLength) == 0) + { + NSUInteger preOffset = pre - (const UInt8 *)[preBuffer bytes]; // pointer arithmetic + + result = preOffset + termLength; + found = YES; + break; + } + + pre++; + } + } + + // There is no need to avoid resizing the buffer in this particular situation. + + if (foundPtr) *foundPtr = found; + return result; +} + +/** + * For read packets with a set terminator, scans the packet buffer for the term. + * It is assumed the terminator had not been fully read prior to the new bytes. + * + * If the term is found, the number of excess bytes after the term are returned. + * If the term is not found, this method will return -1. + * + * Note: A return value of zero means the term was found at the very end. + * + * Prerequisites: + * The given number of bytes have been added to the end of our buffer. + * Our bytesDone variable has NOT been changed due to the prebuffered bytes. +**/ +- (NSInteger)searchForTermAfterPreBuffering:(ssize_t)numBytes +{ + NSAssert(term != nil, @"This method does not apply to non-term reads"); + + // The implementation of this method is very similar to the above method. + // See the above method for a discussion of the algorithm used here. + + UInt8 *buff = [buffer mutableBytes]; + NSUInteger buffLength = bytesDone + numBytes; + + const void *termBuff = [term bytes]; + NSUInteger termLength = [term length]; + + // Note: We are dealing with unsigned integers, + // so make sure the math doesn't go below zero. + + NSUInteger i = ((buffLength - numBytes) >= termLength) ? (buffLength - numBytes - termLength + 1) : 0; + + while (i + termLength <= buffLength) + { + UInt8 *subBuffer = buff + startOffset + i; + + if (memcmp(subBuffer, termBuff, termLength) == 0) + { + return buffLength - (i + termLength); + } + + i++; + } + + return -1; +} + +- (void)dealloc +{ + [buffer release]; + [term release]; + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The GCDAsyncWritePacket encompasses the instructions for any given write. +**/ +@interface GCDAsyncWritePacket : NSObject +{ + @public + NSData *buffer; + NSUInteger bytesDone; + long tag; + NSTimeInterval timeout; +} +- (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i; +@end + +@implementation GCDAsyncWritePacket + +- (id)initWithData:(NSData *)d timeout:(NSTimeInterval)t tag:(long)i +{ + if((self = [super init])) + { + buffer = [d retain]; + bytesDone = 0; + timeout = t; + tag = i; + } + return self; +} + +- (void)dealloc +{ + [buffer release]; + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The GCDAsyncSpecialPacket encompasses special instructions for interruptions in the read/write queues. + * This class my be altered to support more than just TLS in the future. +**/ +@interface GCDAsyncSpecialPacket : NSObject +{ + @public + NSDictionary *tlsSettings; +} +- (id)initWithTLSSettings:(NSDictionary *)settings; +@end + +@implementation GCDAsyncSpecialPacket + +- (id)initWithTLSSettings:(NSDictionary *)settings +{ + if((self = [super init])) + { + tlsSettings = [settings copy]; + } + return self; +} + +- (void)dealloc +{ + [tlsSettings release]; + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation GCDAsyncSocket + +- (id)init +{ + return [self initWithDelegate:nil delegateQueue:NULL socketQueue:NULL]; +} + +- (id)initWithSocketQueue:(dispatch_queue_t)sq +{ + return [self initWithDelegate:nil delegateQueue:NULL socketQueue:sq]; +} + +- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq +{ + return [self initWithDelegate:aDelegate delegateQueue:dq socketQueue:NULL]; +} + +- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq socketQueue:(dispatch_queue_t)sq +{ + if((self = [super init])) + { + delegate = aDelegate; + + if (dq) + { + dispatch_retain(dq); + delegateQueue = dq; + } + + socket4FD = SOCKET_NULL; + socket6FD = SOCKET_NULL; + connectIndex = 0; + + if (sq) + { + NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), + @"The given socketQueue parameter must not be a concurrent queue."); + NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), + @"The given socketQueue parameter must not be a concurrent queue."); + NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), + @"The given socketQueue parameter must not be a concurrent queue."); + + dispatch_retain(sq); + socketQueue = sq; + } + else + { + socketQueue = dispatch_queue_create("GCDAsyncSocket", NULL); + } + + readQueue = [[NSMutableArray alloc] initWithCapacity:5]; + currentRead = nil; + + writeQueue = [[NSMutableArray alloc] initWithCapacity:5]; + currentWrite = nil; + + partialReadBuffer = [[NSMutableData alloc] init]; + } + return self; +} + +- (void)dealloc +{ + LogInfo(@"%@ - %@ (start)", THIS_METHOD, self); + + if (dispatch_get_current_queue() == socketQueue) + { + [self closeWithError:nil]; + } + else + { + dispatch_sync(socketQueue, ^{ + [self closeWithError:nil]; + }); + } + + delegate = nil; + if (delegateQueue) + dispatch_release(delegateQueue); + delegateQueue = NULL; + + dispatch_release(socketQueue); + socketQueue = NULL; + + [readQueue release]; + [writeQueue release]; + + [partialReadBuffer release]; + +#if !TARGET_OS_IPHONE + [sslReadBuffer release]; +#endif + + [userData release]; + + LogInfo(@"%@ - %@ (finish)", THIS_METHOD, self); + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)delegate +{ + if (dispatch_get_current_queue() == socketQueue) + { + return delegate; + } + else + { + __block id result; + + dispatch_sync(socketQueue, ^{ + result = delegate; + }); + + return result; + } +} + +- (void)setDelegate:(id)newDelegate synchronously:(BOOL)synchronously +{ + dispatch_block_t block = ^{ + delegate = newDelegate; + }; + + if (dispatch_get_current_queue() == socketQueue) { + block(); + } + else { + if (synchronously) + dispatch_sync(socketQueue, block); + else + dispatch_async(socketQueue, block); + } +} + +- (void)setDelegate:(id)newDelegate +{ + [self setDelegate:newDelegate synchronously:NO]; +} + +- (void)synchronouslySetDelegate:(id)newDelegate +{ + [self setDelegate:newDelegate synchronously:YES]; +} + +- (dispatch_queue_t)delegateQueue +{ + if (dispatch_get_current_queue() == socketQueue) + { + return delegateQueue; + } + else + { + __block dispatch_queue_t result; + + dispatch_sync(socketQueue, ^{ + result = delegateQueue; + }); + + return result; + } +} + +- (void)setDelegateQueue:(dispatch_queue_t)newDelegateQueue synchronously:(BOOL)synchronously +{ + dispatch_block_t block = ^{ + + if (delegateQueue) + dispatch_release(delegateQueue); + + if (newDelegateQueue) + dispatch_retain(newDelegateQueue); + + delegateQueue = newDelegateQueue; + }; + + if (dispatch_get_current_queue() == socketQueue) { + block(); + } + else { + if (synchronously) + dispatch_sync(socketQueue, block); + else + dispatch_async(socketQueue, block); + } +} + +- (void)setDelegateQueue:(dispatch_queue_t)newDelegateQueue +{ + [self setDelegateQueue:newDelegateQueue synchronously:NO]; +} + +- (void)synchronouslySetDelegateQueue:(dispatch_queue_t)newDelegateQueue +{ + [self setDelegateQueue:newDelegateQueue synchronously:YES]; +} + +- (void)getDelegate:(id *)delegatePtr delegateQueue:(dispatch_queue_t *)delegateQueuePtr +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (delegatePtr) *delegatePtr = delegate; + if (delegateQueuePtr) *delegateQueuePtr = delegateQueue; + } + else + { + __block id dPtr = NULL; + __block dispatch_queue_t dqPtr = NULL; + + dispatch_sync(socketQueue, ^{ + dPtr = delegate; + dqPtr = delegateQueue; + }); + + if (delegatePtr) *delegatePtr = dPtr; + if (delegateQueuePtr) *delegateQueuePtr = dqPtr; + } +} + +- (void)setDelegate:(id)newDelegate delegateQueue:(dispatch_queue_t)newDelegateQueue synchronously:(BOOL)synchronously +{ + dispatch_block_t block = ^{ + + delegate = newDelegate; + + if (delegateQueue) + dispatch_release(delegateQueue); + + if (newDelegateQueue) + dispatch_retain(newDelegateQueue); + + delegateQueue = newDelegateQueue; + }; + + if (dispatch_get_current_queue() == socketQueue) { + block(); + } + else { + if (synchronously) + dispatch_sync(socketQueue, block); + else + dispatch_async(socketQueue, block); + } +} + +- (void)setDelegate:(id)newDelegate delegateQueue:(dispatch_queue_t)newDelegateQueue +{ + [self setDelegate:newDelegate delegateQueue:newDelegateQueue synchronously:NO]; +} + +- (void)synchronouslySetDelegate:(id)newDelegate delegateQueue:(dispatch_queue_t)newDelegateQueue +{ + [self setDelegate:newDelegate delegateQueue:newDelegateQueue synchronously:YES]; +} + +- (BOOL)autoDisconnectOnClosedReadStream +{ + // Note: YES means kAllowHalfDuplexConnection is OFF + + if (dispatch_get_current_queue() == socketQueue) + { + return ((config & kAllowHalfDuplexConnection) == 0); + } + else + { + __block BOOL result; + + dispatch_sync(socketQueue, ^{ + result = ((config & kAllowHalfDuplexConnection) == 0); + }); + + return result; + } +} + +- (void)setAutoDisconnectOnClosedReadStream:(BOOL)flag +{ + // Note: YES means kAllowHalfDuplexConnection is OFF + + dispatch_block_t block = ^{ + + if (flag) + config &= ~kAllowHalfDuplexConnection; + else + config |= kAllowHalfDuplexConnection; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_async(socketQueue, block); +} + +- (BOOL)isIPv4Enabled +{ + // Note: YES means kIPv4Disabled is OFF + + if (dispatch_get_current_queue() == socketQueue) + { + return ((config & kIPv4Disabled) == 0); + } + else + { + __block BOOL result; + + dispatch_sync(socketQueue, ^{ + result = ((config & kIPv4Disabled) == 0); + }); + + return result; + } +} + +- (void)setIPv4Enabled:(BOOL)flag +{ + // Note: YES means kIPv4Disabled is OFF + + dispatch_block_t block = ^{ + + if (flag) + config &= ~kIPv4Disabled; + else + config |= kIPv4Disabled; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_async(socketQueue, block); +} + +- (BOOL)isIPv6Enabled +{ + // Note: YES means kIPv6Disabled is OFF + + if (dispatch_get_current_queue() == socketQueue) + { + return ((config & kIPv6Disabled) == 0); + } + else + { + __block BOOL result; + + dispatch_sync(socketQueue, ^{ + result = ((config & kIPv6Disabled) == 0); + }); + + return result; + } +} + +- (void)setIPv6Enabled:(BOOL)flag +{ + // Note: YES means kIPv6Disabled is OFF + + dispatch_block_t block = ^{ + + if (flag) + config &= ~kIPv6Disabled; + else + config |= kIPv6Disabled; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_async(socketQueue, block); +} + +- (BOOL)isIPv4PreferredOverIPv6 +{ + // Note: YES means kPreferIPv6 is OFF + + if (dispatch_get_current_queue() == socketQueue) + { + return ((config & kPreferIPv6) == 0); + } + else + { + __block BOOL result; + + dispatch_sync(socketQueue, ^{ + result = ((config & kPreferIPv6) == 0); + }); + + return result; + } +} + +- (void)setPreferIPv4OverIPv6:(BOOL)flag +{ + // Note: YES means kPreferIPv6 is OFF + + dispatch_block_t block = ^{ + + if (flag) + config &= ~kPreferIPv6; + else + config |= kPreferIPv6; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_async(socketQueue, block); +} + +- (id)userData +{ + __block id result; + + dispatch_block_t block = ^{ + + result = [userData retain]; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + return [result autorelease]; +} + +- (void)setUserData:(id)arbitraryUserData +{ + dispatch_block_t block = ^{ + + if (userData != arbitraryUserData) + { + [userData release]; + userData = [arbitraryUserData retain]; + } + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_async(socketQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Accepting +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)acceptOnPort:(UInt16)port error:(NSError **)errPtr +{ + return [self acceptOnInterface:nil port:port error:errPtr]; +} + +- (BOOL)acceptOnInterface:(NSString *)interface port:(UInt16)port error:(NSError **)errPtr +{ + LogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + // CreateSocket Block + // This block will be invoked within the dispatch block below. + + int(^createSocket)(int, NSData*) = ^int (int domain, NSData *interfaceAddr) { + + int socketFD = socket(domain, SOCK_STREAM, 0); + + if (socketFD == SOCKET_NULL) + { + NSString *reason = @"Error in socket() function"; + err = [[self errnoErrorWithReason:reason] retain]; + + return SOCKET_NULL; + } + + int status; + + // Set socket options + + status = fcntl(socketFD, F_SETFL, O_NONBLOCK); + if (status == -1) + { + NSString *reason = @"Error enabling non-blocking IO on socket (fcntl)"; + err = [[self errnoErrorWithReason:reason] retain]; + + close(socketFD); + return SOCKET_NULL; + } + + int reuseOn = 1; + status = setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn)); + if (status == -1) + { + NSString *reason = @"Error enabling address reuse (setsockopt)"; + err = [[self errnoErrorWithReason:reason] retain]; + + close(socketFD); + return SOCKET_NULL; + } + + // Bind socket + + status = bind(socketFD, (struct sockaddr *)[interfaceAddr bytes], (socklen_t)[interfaceAddr length]); + if (status == -1) + { + NSString *reason = @"Error in bind() function"; + err = [[self errnoErrorWithReason:reason] retain]; + + close(socketFD); + return SOCKET_NULL; + } + + // Listen + + status = listen(socketFD, 1024); + if (status == -1) + { + NSString *reason = @"Error in listen() function"; + err = [[self errnoErrorWithReason:reason] retain]; + + close(socketFD); + return SOCKET_NULL; + } + + return socketFD; + }; + + // Create dispatch block and run on socketQueue + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (delegate == nil) // Must have delegate set + { + result = NO; + + NSString *msg = @"Attempting to accept without a delegate. Set a delegate first."; + err = [[self badConfigError:msg] retain]; + + [pool drain]; + return_from_block; + } + + if (delegateQueue == NULL) // Must have delegate queue set + { + result = NO; + + NSString *msg = @"Attempting to accept without a delegate queue. Set a delegate queue first."; + err = [[self badConfigError:msg] retain]; + + [pool drain]; + return_from_block; + } + + BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO; + BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO; + + if (isIPv4Disabled && isIPv6Disabled) // Must have IPv4 or IPv6 enabled + { + result = NO; + + NSString *msg = @"Both IPv4 and IPv6 have been disabled. Must enable at least one protocol first."; + err = [[self badConfigError:msg] retain]; + + [pool drain]; + return_from_block; + } + + if (![self isDisconnected]) // Must be disconnected + { + result = NO; + + NSString *msg = @"Attempting to accept while connected or accepting connections. Disconnect first."; + err = [[self badConfigError:msg] retain]; + + [pool drain]; + return_from_block; + } + + // Clear queues (spurious read/write requests post disconnect) + [readQueue removeAllObjects]; + [writeQueue removeAllObjects]; + + // Resolve interface from description + + NSData *interface4 = nil; + NSData *interface6 = nil; + + [self getInterfaceAddress4:&interface4 address6:&interface6 fromDescription:interface port:port]; + + if ((interface4 == nil) && (interface6 == nil)) + { + result = NO; + + NSString *msg = @"Unknown interface. Specify valid interface by name (e.g. \"en1\") or IP address."; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + if (isIPv4Disabled && (interface6 == nil)) + { + result = NO; + + NSString *msg = @"IPv4 has been disabled and specified interface doesn't support IPv6."; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + if (isIPv6Disabled && (interface4 == nil)) + { + result = NO; + + NSString *msg = @"IPv6 has been disabled and specified interface doesn't support IPv4."; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + BOOL enableIPv4 = !isIPv4Disabled && (interface4 != nil); + BOOL enableIPv6 = !isIPv6Disabled && (interface6 != nil); + + // Create sockets, configure, bind, and listen + + if (enableIPv4) + { + LogVerbose(@"Creating IPv4 socket"); + socket4FD = createSocket(AF_INET, interface4); + + if (socket4FD == SOCKET_NULL) + { + result = NO; + + [pool drain]; + return_from_block; + } + } + + if (enableIPv6) + { + LogVerbose(@"Creating IPv6 socket"); + + if (enableIPv4 && (port == 0)) + { + // No specific port was specified, so we allowed the OS to pick an available port for us. + // Now we need to make sure the IPv6 socket listens on the same port as the IPv4 socket. + + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)[interface6 bytes]; + addr6->sin6_port = htons([self localPort4]); + } + + socket6FD = createSocket(AF_INET6, interface6); + + if (socket6FD == SOCKET_NULL) + { + result = NO; + + if (socket4FD != SOCKET_NULL) + { + close(socket4FD); + } + + [pool drain]; + return_from_block; + } + } + + // Create accept sources + + if (enableIPv4) + { + accept4Source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socket4FD, 0, socketQueue); + + int socketFD = socket4FD; + dispatch_source_t acceptSource = accept4Source; + + dispatch_source_set_event_handler(accept4Source, ^{ + NSAutoreleasePool *eventPool = [[NSAutoreleasePool alloc] init]; + + LogVerbose(@"event4Block"); + + unsigned long i = 0; + unsigned long numPendingConnections = dispatch_source_get_data(acceptSource); + + LogVerbose(@"numPendingConnections: %lu", numPendingConnections); + + while ([self doAccept:socketFD] && (++i < numPendingConnections)); + + [eventPool drain]; + }); + + dispatch_source_set_cancel_handler(accept4Source, ^{ + + LogVerbose(@"dispatch_release(accept4Source)"); + dispatch_release(acceptSource); + + LogVerbose(@"close(socket4FD)"); + close(socketFD); + }); + + LogVerbose(@"dispatch_resume(accept4Source)"); + dispatch_resume(accept4Source); + } + + if (enableIPv6) + { + accept6Source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socket6FD, 0, socketQueue); + + int socketFD = socket6FD; + dispatch_source_t acceptSource = accept6Source; + + dispatch_source_set_event_handler(accept6Source, ^{ + NSAutoreleasePool *eventPool = [[NSAutoreleasePool alloc] init]; + + LogVerbose(@"event6Block"); + + unsigned long i = 0; + unsigned long numPendingConnections = dispatch_source_get_data(acceptSource); + + LogVerbose(@"numPendingConnections: %lu", numPendingConnections); + + while ([self doAccept:socketFD] && (++i < numPendingConnections)); + + [eventPool drain]; + }); + + dispatch_source_set_cancel_handler(accept6Source, ^{ + + LogVerbose(@"dispatch_release(accept6Source)"); + dispatch_release(acceptSource); + + LogVerbose(@"close(socket6FD)"); + close(socketFD); + }); + + LogVerbose(@"dispatch_resume(accept6Source)"); + dispatch_resume(accept6Source); + } + + flags |= kSocketStarted; + [pool drain]; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + if (result == NO) + { + LogInfo(@"Error in accept: %@", err); + + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + } + + return result; +} + +- (BOOL)doAccept:(int)parentSocketFD +{ + LogTrace(); + + BOOL isIPv4; + int childSocketFD; + NSData *childSocketAddress; + + if (parentSocketFD == socket4FD) + { + isIPv4 = YES; + + struct sockaddr_in addr; + socklen_t addrLen = sizeof(addr); + + childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen); + + if (childSocketFD == -1) + { + LogWarn(@"Accept failed with error: %@", [self errnoError]); + return NO; + } + + childSocketAddress = [NSData dataWithBytes:&addr length:addrLen]; + } + else // if (parentSocketFD == socket6FD) + { + isIPv4 = NO; + + struct sockaddr_in6 addr; + socklen_t addrLen = sizeof(addr); + + childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen); + + if (childSocketFD == -1) + { + LogWarn(@"Accept failed with error: %@", [self errnoError]); + return NO; + } + + childSocketAddress = [NSData dataWithBytes:&addr length:addrLen]; + } + + // Enable non-blocking IO on the socket + + int result = fcntl(childSocketFD, F_SETFL, O_NONBLOCK); + if (result == -1) + { + LogWarn(@"Error enabling non-blocking IO on accepted socket (fcntl)"); + return NO; + } + + // Prevent SIGPIPE signals + + int nosigpipe = 1; + setsockopt(childSocketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe)); + + // Notify delegate + + if (delegateQueue) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *delegatePool = [[NSAutoreleasePool alloc] init]; + + // Query delegate for custom socket queue + + dispatch_queue_t childSocketQueue = NULL; + + if ([theDelegate respondsToSelector:@selector(newSocketQueueForConnectionFromAddress:onSocket:)]) + { + childSocketQueue = [theDelegate newSocketQueueForConnectionFromAddress:childSocketAddress + onSocket:self]; + } + + // Create GCDAsyncSocket instance for accepted socket + + GCDAsyncSocket *acceptedSocket = [[GCDAsyncSocket alloc] initWithDelegate:delegate + delegateQueue:delegateQueue + socketQueue:childSocketQueue]; + + if (isIPv4) + acceptedSocket->socket4FD = childSocketFD; + else + acceptedSocket->socket6FD = childSocketFD; + + acceptedSocket->flags = (kSocketStarted | kConnected); + + // Setup read and write sources for accepted socket + + dispatch_async(acceptedSocket->socketQueue, ^{ + NSAutoreleasePool *socketPool = [[NSAutoreleasePool alloc] init]; + + [acceptedSocket setupReadAndWriteSourcesForNewlyConnectedSocket:childSocketFD]; + + [socketPool drain]; + }); + + // Notify delegate + + if ([theDelegate respondsToSelector:@selector(socket:didAcceptNewSocket:)]) + { + [theDelegate socket:self didAcceptNewSocket:acceptedSocket]; + } + + // Release the socket queue returned from the delegate (it was retained by acceptedSocket) + if (childSocketQueue) + dispatch_release(childSocketQueue); + + // Release the accepted socket (it should have been retained by the delegate) + [acceptedSocket release]; + + [delegatePool drain]; + }); + } + + return YES; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Connecting +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * This method runs through the various checks required prior to a connection attempt. + * It is shared between the connectToHost and connectToAddress methods. + * +**/ +- (BOOL)preConnectWithInterface:(NSString *)interface error:(NSError **)errPtr +{ + NSAssert(dispatch_get_current_queue() == socketQueue, @"Exectued on wrong dispatch queue"); + + if (delegate == nil) // Must have delegate set + { + if (errPtr) + { + NSString *msg = @"Attempting to connect without a delegate. Set a delegate first."; + *errPtr = [self badConfigError:msg]; + } + return NO; + } + + if (delegateQueue == NULL) // Must have delegate queue set + { + if (errPtr) + { + NSString *msg = @"Attempting to connect without a delegate queue. Set a delegate queue first."; + *errPtr = [self badConfigError:msg]; + } + return NO; + } + + if (![self isDisconnected]) // Must be disconnected + { + if (errPtr) + { + NSString *msg = @"Attempting to connect while connected or accepting connections. Disconnect first."; + *errPtr = [self badConfigError:msg]; + } + return NO; + } + + BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO; + BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO; + + if (isIPv4Disabled && isIPv6Disabled) // Must have IPv4 or IPv6 enabled + { + if (errPtr) + { + NSString *msg = @"Both IPv4 and IPv6 have been disabled. Must enable at least one protocol first."; + *errPtr = [self badConfigError:msg]; + } + return NO; + } + + if (interface) + { + NSData *interface4 = nil; + NSData *interface6 = nil; + + [self getInterfaceAddress4:&interface4 address6:&interface6 fromDescription:interface port:0]; + + if ((interface4 == nil) && (interface6 == nil)) + { + if (errPtr) + { + NSString *msg = @"Unknown interface. Specify valid interface by name (e.g. \"en1\") or IP address."; + *errPtr = [self badParamError:msg]; + } + return NO; + } + + if (isIPv4Disabled && (interface6 == nil)) + { + if (errPtr) + { + NSString *msg = @"IPv4 has been disabled and specified interface doesn't support IPv6."; + *errPtr = [self badParamError:msg]; + } + return NO; + } + + if (isIPv6Disabled && (interface4 == nil)) + { + if (errPtr) + { + NSString *msg = @"IPv6 has been disabled and specified interface doesn't support IPv4."; + *errPtr = [self badParamError:msg]; + } + return NO; + } + + connectInterface4 = [interface4 retain]; + connectInterface6 = [interface6 retain]; + } + + // Clear queues (spurious read/write requests post disconnect) + [readQueue removeAllObjects]; + [writeQueue removeAllObjects]; + + return YES; +} + +- (BOOL)connectToHost:(NSString*)host onPort:(UInt16)port error:(NSError **)errPtr +{ + return [self connectToHost:host onPort:port withTimeout:-1 error:errPtr]; +} + +- (BOOL)connectToHost:(NSString *)host + onPort:(UInt16)port + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr +{ + return [self connectToHost:host onPort:port viaInterface:nil withTimeout:timeout error:errPtr]; +} + +- (BOOL)connectToHost:(NSString *)host + onPort:(UInt16)port + viaInterface:(NSString *)interface + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr +{ + LogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + result = [self preConnectWithInterface:interface error:&err]; + if (!result) + { + [err retain]; + [pool drain]; + return_from_block; + } + + // We've made it past all the checks. + // It's time to start the connection process. + + flags |= kSocketStarted; + + LogVerbose(@"Dispatching DNS lookup..."); + + // It's possible that the given host parameter is actually a NSMutableString. + // So we want to copy it now, within this block that will be executed synchronously. + // This way the asynchronous lookup block below doesn't have to worry about it changing. + + int aConnectIndex = connectIndex; + NSString *hostCpy = [[host copy] autorelease]; + + dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(globalConcurrentQueue, ^{ + NSAutoreleasePool *lookupPool = [[NSAutoreleasePool alloc] init]; + + [self lookup:aConnectIndex host:hostCpy port:port]; + + [lookupPool drain]; + }); + + [self startConnectTimeout:timeout]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + if (result == NO) + { + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + } + + return result; +} + +- (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr +{ + return [self connectToAddress:remoteAddr viaInterface:nil withTimeout:-1 error:errPtr]; +} + +- (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr +{ + return [self connectToAddress:remoteAddr viaInterface:nil withTimeout:timeout error:errPtr]; +} + +- (BOOL)connectToAddress:(NSData *)remoteAddr + viaInterface:(NSString *)interface + withTimeout:(NSTimeInterval)timeout + error:(NSError **)errPtr +{ + LogTrace(); + + __block BOOL result = YES; + __block NSError *err = nil; + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // Check for problems with remoteAddr parameter + + NSData *address4 = nil; + NSData *address6 = nil; + + if ([remoteAddr length] >= sizeof(struct sockaddr)) + { + struct sockaddr *sockaddr = (struct sockaddr *)[remoteAddr bytes]; + + if (sockaddr->sa_family == AF_INET) + { + if ([remoteAddr length] == sizeof(struct sockaddr_in)) + { + address4 = remoteAddr; + } + } + else if (sockaddr->sa_family == AF_INET6) + { + if ([remoteAddr length] == sizeof(struct sockaddr_in6)) + { + address6 = remoteAddr; + } + } + } + + if ((address4 == nil) && (address6 == nil)) + { + NSString *msg = @"A valid IPv4 or IPv6 address was not given"; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO; + BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO; + + if (isIPv4Disabled && (address4 != nil)) + { + NSString *msg = @"IPv4 has been disabled and an IPv4 address was passed."; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + if (isIPv6Disabled && (address6 != nil)) + { + NSString *msg = @"IPv6 has been disabled and an IPv6 address was passed."; + err = [[self badParamError:msg] retain]; + + [pool drain]; + return_from_block; + } + + // Run through standard pre-connect checks + + result = [self preConnectWithInterface:interface error:&err]; + if (!result) + { + [err retain]; + [pool drain]; + return_from_block; + } + + // We've made it past all the checks. + // It's time to start the connection process. + + if (![self connectWithAddress4:address4 address6:address6 error:&err]) + { + [err retain]; + [pool drain]; + return_from_block; + } + + flags |= kSocketStarted; + + [self startConnectTimeout:timeout]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + if (result == NO) + { + if (errPtr) + *errPtr = [err autorelease]; + else + [err release]; + } + + return result; +} + +- (void)lookup:(int)aConnectIndex host:(NSString *)host port:(UInt16)port +{ + LogTrace(); + + // This method is executed on a global concurrent queue. + // It posts the results back to the socket queue. + // The lookupIndex is used to ignore the results if the connect operation was cancelled or timed out. + + NSError *error = nil; + + NSData *address4 = nil; + NSData *address6 = nil; + + + if ([host isEqualToString:@"localhost"] || [host isEqualToString:@"loopback"]) + { + // Use LOOPBACK address + struct sockaddr_in nativeAddr; + nativeAddr.sin_len = sizeof(struct sockaddr_in); + nativeAddr.sin_family = AF_INET; + nativeAddr.sin_port = htons(port); + nativeAddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + memset(&(nativeAddr.sin_zero), 0, sizeof(nativeAddr.sin_zero)); + + struct sockaddr_in6 nativeAddr6; + nativeAddr6.sin6_len = sizeof(struct sockaddr_in6); + nativeAddr6.sin6_family = AF_INET6; + nativeAddr6.sin6_port = htons(port); + nativeAddr6.sin6_flowinfo = 0; + nativeAddr6.sin6_addr = in6addr_loopback; + nativeAddr6.sin6_scope_id = 0; + + // Wrap the native address structures + address4 = [NSData dataWithBytes:&nativeAddr length:sizeof(nativeAddr)]; + address6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)]; + } + else + { + NSString *portStr = [NSString stringWithFormat:@"%hu", port]; + + struct addrinfo hints, *res, *res0; + + memset(&hints, 0, sizeof(hints)); + hints.ai_family = PF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_protocol = IPPROTO_TCP; + + int gai_error = getaddrinfo([host UTF8String], [portStr UTF8String], &hints, &res0); + + if (gai_error) + { + error = [self gaiError:gai_error]; + } + else + { + for(res = res0; res; res = res->ai_next) + { + if ((address4 == nil) && (res->ai_family == AF_INET)) + { + // Found IPv4 address + // Wrap the native address structure + address4 = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen]; + } + else if ((address6 == nil) && (res->ai_family == AF_INET6)) + { + // Found IPv6 address + // Wrap the native address structure + address6 = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen]; + } + } + freeaddrinfo(res0); + + if ((address4 == nil) && (address6 == nil)) + { + error = [self gaiError:EAI_FAIL]; + } + } + } + + if (error) + { + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self lookup:aConnectIndex didFail:error]; + [pool drain]; + }); + } + else + { + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self lookup:aConnectIndex didSucceedWithAddress4:address4 address6:address6]; + [pool drain]; + }); + } +} + +- (void)lookup:(int)aConnectIndex didSucceedWithAddress4:(NSData *)address4 address6:(NSData *)address6 +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Exectued on wrong dispatch queue"); + NSAssert(address4 || address6, @"Expected at least one valid address"); + + if (aConnectIndex != connectIndex) + { + LogInfo(@"Ignoring lookupDidSucceed, already disconnected"); + + // The connect operation has been cancelled. + // That is, socket was disconnected, or connection has already timed out. + return; + } + + // Check for problems + + BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO; + BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO; + + if (isIPv4Disabled && (address6 == nil)) + { + NSString *msg = @"IPv4 has been disabled and DNS lookup found no IPv6 address."; + + [self closeWithError:[self otherError:msg]]; + return; + } + + if (isIPv6Disabled && (address4 == nil)) + { + NSString *msg = @"IPv6 has been disabled and DNS lookup found no IPv4 address."; + + [self closeWithError:[self otherError:msg]]; + return; + } + + // Start the normal connection process + + NSError *err = nil; + if (![self connectWithAddress4:address4 address6:address6 error:&err]) + { + [self closeWithError:err]; + } +} + +/** + * This method is called if the DNS lookup fails. + * This method is executed on the socketQueue. + * + * Since the DNS lookup executed synchronously on a global concurrent queue, + * the original connection request may have already been cancelled or timed-out by the time this method is invoked. + * The lookupIndex tells us whether the lookup is still valid or not. +**/ +- (void)lookup:(int)aConnectIndex didFail:(NSError *)error +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Exectued on wrong dispatch queue"); + + + if (aConnectIndex != connectIndex) + { + LogInfo(@"Ignoring lookup:didFail: - already disconnected"); + + // The connect operation has been cancelled. + // That is, socket was disconnected, or connection has already timed out. + return; + } + + [self endConnectTimeout]; + [self closeWithError:error]; +} + +- (BOOL)connectWithAddress4:(NSData *)address4 address6:(NSData *)address6 error:(NSError **)errPtr +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Exectued on wrong dispatch queue"); + + + // Determine socket type + + BOOL preferIPv6 = (config & kPreferIPv6) ? YES : NO; + + BOOL useIPv6 = ((preferIPv6 && address6) || (address4 == nil)); + + // Create the socket + + int socketFD; + NSData *address; + NSData *connectInterface; + + if (useIPv6) + { + LogVerbose(@"Creating IPv6 socket"); + + socket6FD = socket(AF_INET6, SOCK_STREAM, 0); + + socketFD = socket6FD; + address = address6; + connectInterface = connectInterface6; + } + else + { + LogVerbose(@"Creating IPv4 socket"); + + socket4FD = socket(AF_INET, SOCK_STREAM, 0); + + socketFD = socket4FD; + address = address4; + connectInterface = connectInterface4; + } + + if (socketFD == SOCKET_NULL) + { + if (errPtr) + *errPtr = [self errnoErrorWithReason:@"Error in socket() function"]; + + return NO; + } + + // Bind the socket to the desired interface (if needed) + + if (connectInterface) + { + LogVerbose(@"Binding socket..."); + + if ([[self class] portFromAddress:connectInterface] > 0) + { + // Since we're going to be binding to a specific port, + // we should turn on reuseaddr to allow us to override sockets in time_wait. + + int reuseOn = 1; + setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn)); + } + + struct sockaddr *interfaceAddr = (struct sockaddr *)[connectInterface bytes]; + + int result = bind(socketFD, interfaceAddr, (socklen_t)[connectInterface length]); + if (result != 0) + { + if (errPtr) + *errPtr = [self errnoErrorWithReason:@"Error in bind() function"]; + + return NO; + } + } + + // Start the connection process in a background queue + + int aConnectIndex = connectIndex; + + dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_async(globalConcurrentQueue, ^{ + + int result = connect(socketFD, (const struct sockaddr *)[address bytes], (socklen_t)[address length]); + if (result == 0) + { + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self didConnect:aConnectIndex]; + [pool drain]; + }); + } + else + { + NSError *error = [self errnoErrorWithReason:@"Error in connect() function"]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self didNotConnect:aConnectIndex error:error]; + [pool drain]; + }); + } + }); + + LogVerbose(@"Connecting..."); + + return YES; +} + +- (void)didConnect:(int)aConnectIndex +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + + if (aConnectIndex != connectIndex) + { + LogInfo(@"Ignoring didConnect, already disconnected"); + + // The connect operation has been cancelled. + // That is, socket was disconnected, or connection has already timed out. + return; + } + + flags |= kConnected; + + [self endConnectTimeout]; + + NSString *host = [self connectedHost]; + UInt16 port = [self connectedPort]; + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:didConnectToHost:port:)]) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socket:self didConnectToHost:host port:port]; + + [pool drain]; + }); + } + + // Get the connected socket + + int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : socket6FD; + + // Enable non-blocking IO on the socket + + int result = fcntl(socketFD, F_SETFL, O_NONBLOCK); + if (result == -1) + { + NSString *errMsg = @"Error enabling non-blocking IO on socket (fcntl)"; + [self closeWithError:[self otherError:errMsg]]; + + return; + } + + // Prevent SIGPIPE signals + + int nosigpipe = 1; + setsockopt(socketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe)); + + // Setup our read/write sources. + + [self setupReadAndWriteSourcesForNewlyConnectedSocket:socketFD]; + + // Dequeue any pending read/write requests + + [self maybeDequeueRead]; + [self maybeDequeueWrite]; +} + +- (void)didNotConnect:(int)aConnectIndex error:(NSError *)error +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + + if (aConnectIndex != connectIndex) + { + LogInfo(@"Ignoring didNotConnect, already disconnected"); + + // The connect operation has been cancelled. + // That is, socket was disconnected, or connection has already timed out. + return; + } + + [self endConnectTimeout]; + [self closeWithError:error]; +} + +- (void)startConnectTimeout:(NSTimeInterval)timeout +{ + if (timeout >= 0.0) + { + connectTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, socketQueue); + + dispatch_source_set_event_handler(connectTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self doConnectTimeout]; + + [pool drain]; + }); + + dispatch_source_t theConnectTimer = connectTimer; + dispatch_source_set_cancel_handler(connectTimer, ^{ + LogVerbose(@"dispatch_release(connectTimer)"); + dispatch_release(theConnectTimer); + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + dispatch_source_set_timer(connectTimer, tt, DISPATCH_TIME_FOREVER, 0); + + dispatch_resume(connectTimer); + } +} + +- (void)endConnectTimeout +{ + LogTrace(); + + if (connectTimer) + { + dispatch_source_cancel(connectTimer); + connectTimer = NULL; + } + + // Increment connectIndex. + // This will prevent us from processing results from any related background asynchronous operations. + // + // Note: This should be called from close method even if connectTimer is NULL. + // This is because one might disconnect a socket prior to a successful connection which had no timeout. + + connectIndex++; + + if (connectInterface4) + { + [connectInterface4 release]; + connectInterface4 = nil; + } + if (connectInterface6) + { + [connectInterface6 release]; + connectInterface6 = nil; + } +} + +- (void)doConnectTimeout +{ + LogTrace(); + + [self endConnectTimeout]; + [self closeWithError:[self connectTimeoutError]]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Disconnecting +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)closeWithError:(NSError *)error +{ + LogTrace(); + + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + + [self endConnectTimeout]; + + if (currentRead != nil) [self endCurrentRead]; + if (currentWrite != nil) [self endCurrentWrite]; + + [readQueue removeAllObjects]; + [writeQueue removeAllObjects]; + + [partialReadBuffer setLength:0]; + + #if TARGET_OS_IPHONE + if (readStream || writeStream) + { + if (flags & kAddedHandshakeListener) + { + [[self class] performSelector:@selector(removeHandshakeListener:) + onThread:sslHandshakeThread + withObject:self + waitUntilDone:YES]; + } + + if (readStream) + { + CFReadStreamSetClient(readStream, kCFStreamEventNone, NULL, NULL); + CFReadStreamClose(readStream); + CFRelease(readStream); + readStream = NULL; + } + if (writeStream) + { + CFWriteStreamSetClient(writeStream, kCFStreamEventNone, NULL, NULL); + CFWriteStreamClose(writeStream); + CFRelease(writeStream); + writeStream = NULL; + } + } + #else + [sslReadBuffer setLength:0]; + if (sslContext) + { + SSLDisposeContext(sslContext); + sslContext = NULL; + } + #endif + + // For some crazy reason (in my opinion), cancelling a dispatch source doesn't + // invoke the cancel handler if the dispatch source is paused. + // So we have to unpause the source if needed. + // This allows the cancel handler to be run, which in turn releases the source and closes the socket. + + if (accept4Source) + { + LogVerbose(@"dispatch_source_cancel(accept4Source)"); + dispatch_source_cancel(accept4Source); + + // We never suspend accept4Source + + accept4Source = NULL; + } + + if (accept6Source) + { + LogVerbose(@"dispatch_source_cancel(accept6Source)"); + dispatch_source_cancel(accept6Source); + + // We never suspend accept6Source + + accept6Source = NULL; + } + + if (readSource) + { + LogVerbose(@"dispatch_source_cancel(readSource)"); + dispatch_source_cancel(readSource); + + [self resumeReadSource]; + + readSource = NULL; + } + + if (writeSource) + { + LogVerbose(@"dispatch_source_cancel(writeSource)"); + dispatch_source_cancel(writeSource); + + [self resumeWriteSource]; + + writeSource = NULL; + } + + // The sockets will be closed by the cancel handlers of the corresponding source + + socket4FD = SOCKET_NULL; + socket6FD = SOCKET_NULL; + + // If the client has passed the connect/accept method, then the connection has at least begun. + // Notify delegate that it is now ending. + BOOL shouldCallDelegate = (flags & kSocketStarted); + + // Clear stored socket info and all flags (config remains as is) + socketFDBytesAvailable = 0; + flags = 0; + + if (shouldCallDelegate) + { + if (delegateQueue && [delegate respondsToSelector: @selector(socketDidDisconnect:withError:)]) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socketDidDisconnect:self withError:error]; + + [pool drain]; + }); + } + } +} + +- (void)disconnect +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (flags & kSocketStarted) + { + [self closeWithError:nil]; + } + + [pool drain]; + }; + + // Synchronous disconnection, as documented in the header file + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); +} + +- (void)disconnectAfterReading +{ + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (flags & kSocketStarted) + { + flags |= (kForbidReadsWrites | kDisconnectAfterReads); + [self maybeClose]; + } + + [pool drain]; + }); +} + +- (void)disconnectAfterWriting +{ + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (flags & kSocketStarted) + { + flags |= (kForbidReadsWrites | kDisconnectAfterWrites); + [self maybeClose]; + } + + [pool drain]; + }); +} + +- (void)disconnectAfterReadingAndWriting +{ + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (flags & kSocketStarted) + { + flags |= (kForbidReadsWrites | kDisconnectAfterReads | kDisconnectAfterWrites); + [self maybeClose]; + } + + [pool drain]; + }); +} + +/** + * Closes the socket if possible. + * That is, if all writes have completed, and we're set to disconnect after writing, + * or if all reads have completed, and we're set to disconnect after reading. +**/ +- (void)maybeClose +{ + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + BOOL shouldClose = NO; + + if (flags & kDisconnectAfterReads) + { + if (([readQueue count] == 0) && (currentRead == nil)) + { + if (flags & kDisconnectAfterWrites) + { + if (([writeQueue count] == 0) && (currentWrite == nil)) + { + shouldClose = YES; + } + } + else + { + shouldClose = YES; + } + } + } + else if (flags & kDisconnectAfterWrites) + { + if (([writeQueue count] == 0) && (currentWrite == nil)) + { + shouldClose = YES; + } + } + + if (shouldClose) + { + [self closeWithError:nil]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Errors +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSError *)badConfigError:(NSString *)errMsg +{ + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketBadConfigError userInfo:userInfo]; +} + +- (NSError *)badParamError:(NSString *)errMsg +{ + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketBadParamError userInfo:userInfo]; +} + +- (NSError *)gaiError:(int)gai_error +{ + NSString *errMsg = [NSString stringWithCString:gai_strerror(gai_error) encoding:NSASCIIStringEncoding]; + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:@"kCFStreamErrorDomainNetDB" code:gai_error userInfo:userInfo]; +} + +- (NSError *)errnoErrorWithReason:(NSString *)reason +{ + NSString *errMsg = [NSString stringWithUTF8String:strerror(errno)]; + NSDictionary *userInfo = [NSDictionary dictionaryWithObjectsAndKeys:errMsg, NSLocalizedDescriptionKey, + reason, NSLocalizedFailureReasonErrorKey, nil]; + + return [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:userInfo]; +} + +- (NSError *)errnoError +{ + NSString *errMsg = [NSString stringWithUTF8String:strerror(errno)]; + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:NSPOSIXErrorDomain code:errno userInfo:userInfo]; +} + +- (NSError *)sslError:(OSStatus)ssl_error +{ + NSString *msg = @"Error code definition can be found in Apple's SecureTransport.h"; + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:msg forKey:NSLocalizedRecoverySuggestionErrorKey]; + + return [NSError errorWithDomain:@"kCFStreamErrorDomainSSL" code:ssl_error userInfo:userInfo]; +} + +- (NSError *)connectTimeoutError +{ + NSString *errMsg = NSLocalizedStringWithDefaultValue(@"GCDAsyncSocketConnectTimeoutError", + @"GCDAsyncSocket", [NSBundle mainBundle], + @"Attempt to connect to host timed out", nil); + + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketConnectTimeoutError userInfo:userInfo]; +} + +/** + * Returns a standard AsyncSocket maxed out error. +**/ +- (NSError *)readMaxedOutError +{ + NSString *errMsg = NSLocalizedStringWithDefaultValue(@"GCDAsyncSocketReadMaxedOutError", + @"GCDAsyncSocket", [NSBundle mainBundle], + @"Read operation reached set maximum length", nil); + + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketReadMaxedOutError userInfo:info]; +} + +/** + * Returns a standard AsyncSocket write timeout error. +**/ +- (NSError *)readTimeoutError +{ + NSString *errMsg = NSLocalizedStringWithDefaultValue(@"GCDAsyncSocketReadTimeoutError", + @"GCDAsyncSocket", [NSBundle mainBundle], + @"Read operation timed out", nil); + + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketReadTimeoutError userInfo:userInfo]; +} + +/** + * Returns a standard AsyncSocket write timeout error. +**/ +- (NSError *)writeTimeoutError +{ + NSString *errMsg = NSLocalizedStringWithDefaultValue(@"GCDAsyncSocketWriteTimeoutError", + @"GCDAsyncSocket", [NSBundle mainBundle], + @"Write operation timed out", nil); + + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketWriteTimeoutError userInfo:userInfo]; +} + +- (NSError *)connectionClosedError +{ + NSString *errMsg = NSLocalizedStringWithDefaultValue(@"GCDAsyncSocketClosedError", + @"GCDAsyncSocket", [NSBundle mainBundle], + @"Socket closed by remote peer", nil); + + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketClosedError userInfo:userInfo]; +} + +- (NSError *)otherError:(NSString *)errMsg +{ + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketOtherError userInfo:userInfo]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Diagnostics +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)isDisconnected +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (flags & kSocketStarted) ? NO : YES; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + return result; +} + +- (BOOL)isConnected +{ + __block BOOL result; + + dispatch_block_t block = ^{ + result = (flags & kConnected) ? YES : NO; + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + return result; +} + +- (NSString *)connectedHost +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (socket4FD != SOCKET_NULL) + return [self connectedHostFromSocket4:socket4FD]; + if (socket6FD != SOCKET_NULL) + return [self connectedHostFromSocket6:socket6FD]; + + return nil; + } + else + { + __block NSString *result = nil; + + dispatch_sync(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (socket4FD != SOCKET_NULL) + result = [[self connectedHostFromSocket4:socket4FD] retain]; + else if (socket6FD != SOCKET_NULL) + result = [[self connectedHostFromSocket6:socket6FD] retain]; + + [pool drain]; + }); + + return [result autorelease]; + } +} + +- (UInt16)connectedPort +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (socket4FD != SOCKET_NULL) + return [self connectedPortFromSocket4:socket4FD]; + if (socket6FD != SOCKET_NULL) + return [self connectedPortFromSocket6:socket6FD]; + + return 0; + } + else + { + __block UInt16 result = 0; + + dispatch_sync(socketQueue, ^{ + // No need for autorelease pool + + if (socket4FD != SOCKET_NULL) + result = [self connectedPortFromSocket4:socket4FD]; + else if (socket6FD != SOCKET_NULL) + result = [self connectedPortFromSocket6:socket6FD]; + }); + + return result; + } +} + +- (NSString *)localHost +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (socket4FD != SOCKET_NULL) + return [self localHostFromSocket4:socket4FD]; + if (socket6FD != SOCKET_NULL) + return [self localHostFromSocket6:socket6FD]; + + return nil; + } + else + { + __block NSString *result = nil; + + dispatch_sync(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (socket4FD != SOCKET_NULL) + result = [[self localHostFromSocket4:socket4FD] retain]; + else if (socket6FD != SOCKET_NULL) + result = [[self localHostFromSocket6:socket6FD] retain]; + + [pool drain]; + }); + + return [result autorelease]; + } +} + +- (UInt16)localPort +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (socket4FD != SOCKET_NULL) + return [self localPortFromSocket4:socket4FD]; + if (socket6FD != SOCKET_NULL) + return [self localPortFromSocket6:socket6FD]; + + return 0; + } + else + { + __block UInt16 result = 0; + + dispatch_sync(socketQueue, ^{ + // No need for autorelease pool + + if (socket4FD != SOCKET_NULL) + result = [self localPortFromSocket4:socket4FD]; + else if (socket6FD != SOCKET_NULL) + result = [self localPortFromSocket6:socket6FD]; + }); + + return result; + } +} + +- (NSString *)connectedHost4 +{ + if (socket4FD != SOCKET_NULL) + return [self connectedHostFromSocket4:socket4FD]; + + return nil; +} + +- (NSString *)connectedHost6 +{ + if (socket6FD != SOCKET_NULL) + return [self connectedHostFromSocket6:socket6FD]; + + return nil; +} + +- (UInt16)connectedPort4 +{ + if (socket4FD != SOCKET_NULL) + return [self connectedPortFromSocket4:socket4FD]; + + return 0; +} + +- (UInt16)connectedPort6 +{ + if (socket6FD != SOCKET_NULL) + return [self connectedPortFromSocket6:socket6FD]; + + return 0; +} + +- (NSString *)localHost4 +{ + if (socket4FD != SOCKET_NULL) + return [self localHostFromSocket4:socket4FD]; + + return nil; +} + +- (NSString *)localHost6 +{ + if (socket6FD != SOCKET_NULL) + return [self localHostFromSocket6:socket6FD]; + + return nil; +} + +- (UInt16)localPort4 +{ + if (socket4FD != SOCKET_NULL) + return [self localPortFromSocket4:socket4FD]; + + return 0; +} + +- (UInt16)localPort6 +{ + if (socket6FD != SOCKET_NULL) + return [self localPortFromSocket6:socket6FD]; + + return 0; +} + +- (NSString *)connectedHostFromSocket4:(int)socketFD +{ + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getpeername(socketFD, (struct sockaddr *)&sockaddr4, &sockaddr4len) < 0) + { + return nil; + } + return [[self class] hostFromAddress4:&sockaddr4]; +} + +- (NSString *)connectedHostFromSocket6:(int)socketFD +{ + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getpeername(socketFD, (struct sockaddr *)&sockaddr6, &sockaddr6len) < 0) + { + return nil; + } + return [[self class] hostFromAddress6:&sockaddr6]; +} + +- (UInt16)connectedPortFromSocket4:(int)socketFD +{ + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getpeername(socketFD, (struct sockaddr *)&sockaddr4, &sockaddr4len) < 0) + { + return 0; + } + return [[self class] portFromAddress4:&sockaddr4]; +} + +- (UInt16)connectedPortFromSocket6:(int)socketFD +{ + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getpeername(socketFD, (struct sockaddr *)&sockaddr6, &sockaddr6len) < 0) + { + return 0; + } + return [[self class] portFromAddress6:&sockaddr6]; +} + +- (NSString *)localHostFromSocket4:(int)socketFD +{ + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getsockname(socketFD, (struct sockaddr *)&sockaddr4, &sockaddr4len) < 0) + { + return nil; + } + return [[self class] hostFromAddress4:&sockaddr4]; +} + +- (NSString *)localHostFromSocket6:(int)socketFD +{ + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getsockname(socketFD, (struct sockaddr *)&sockaddr6, &sockaddr6len) < 0) + { + return nil; + } + return [[self class] hostFromAddress6:&sockaddr6]; +} + +- (UInt16)localPortFromSocket4:(int)socketFD +{ + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getsockname(socketFD, (struct sockaddr *)&sockaddr4, &sockaddr4len) < 0) + { + return 0; + } + return [[self class] portFromAddress4:&sockaddr4]; +} + +- (UInt16)localPortFromSocket6:(int)socketFD +{ + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getsockname(socketFD, (struct sockaddr *)&sockaddr6, &sockaddr6len) < 0) + { + return 0; + } + return [[self class] portFromAddress6:&sockaddr6]; +} + +- (NSData *)connectedAddress +{ + __block NSData *result = nil; + + dispatch_block_t block = ^{ + if (socket4FD != SOCKET_NULL) + { + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getpeername(socket4FD, (struct sockaddr *)&sockaddr4, &sockaddr4len) == 0) + { + result = [[NSData alloc] initWithBytes:&sockaddr4 length:sockaddr4len]; + } + } + + if (socket6FD != SOCKET_NULL) + { + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getpeername(socket6FD, (struct sockaddr *)&sockaddr6, &sockaddr6len) == 0) + { + result = [[NSData alloc] initWithBytes:&sockaddr6 length:sockaddr6len]; + } + } + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + return [result autorelease]; +} + +- (NSData *)localAddress +{ + __block NSData *result = nil; + + dispatch_block_t block = ^{ + if (socket4FD != SOCKET_NULL) + { + struct sockaddr_in sockaddr4; + socklen_t sockaddr4len = sizeof(sockaddr4); + + if (getsockname(socket4FD, (struct sockaddr *)&sockaddr4, &sockaddr4len) == 0) + { + result = [[NSData alloc] initWithBytes:&sockaddr4 length:sockaddr4len]; + } + } + + if (socket6FD != SOCKET_NULL) + { + struct sockaddr_in6 sockaddr6; + socklen_t sockaddr6len = sizeof(sockaddr6); + + if (getsockname(socket6FD, (struct sockaddr *)&sockaddr6, &sockaddr6len) == 0) + { + result = [[NSData alloc] initWithBytes:&sockaddr6 length:sockaddr6len]; + } + } + }; + + if (dispatch_get_current_queue() == socketQueue) + block(); + else + dispatch_sync(socketQueue, block); + + return [result autorelease]; +} + +- (BOOL)isIPv4 +{ + if (dispatch_get_current_queue() == socketQueue) + { + return (socket4FD != SOCKET_NULL); + } + else + { + __block BOOL result = NO; + + dispatch_sync(socketQueue, ^{ + result = (socket4FD != SOCKET_NULL); + }); + + return result; + } +} + +- (BOOL)isIPv6 +{ + if (dispatch_get_current_queue() == socketQueue) + { + return (socket6FD != SOCKET_NULL); + } + else + { + __block BOOL result = NO; + + dispatch_sync(socketQueue, ^{ + result = (socket6FD != SOCKET_NULL); + }); + + return result; + } +} + +- (BOOL)isSecure +{ + if (dispatch_get_current_queue() == socketQueue) + { + return (flags & kSocketSecure) ? YES : NO; + } + else + { + __block BOOL result; + + dispatch_sync(socketQueue, ^{ + result = (flags & kSocketSecure) ? YES : NO; + }); + + return result; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Finds the address of an interface description. + * An inteface description may be an interface name (en0, en1, lo0) or corresponding IP (192.168.4.34). + * + * The interface description may optionally contain a port number at the end, separated by a colon. + * If a non-zeor port parameter is provided, any port number in the interface description is ignored. + * + * The returned value is a 'struct sockaddr' wrapped in an NSData object. +**/ +- (void)getInterfaceAddress4:(NSData **)interfaceAddr4Ptr + address6:(NSData **)interfaceAddr6Ptr + fromDescription:(NSString *)interfaceDescription + port:(UInt16)port +{ + NSData *addr4 = nil; + NSData *addr6 = nil; + + NSString *interface = nil; + + NSArray *components = [interfaceDescription componentsSeparatedByString:@":"]; + if ([components count] > 0) + { + NSString *temp = [components objectAtIndex:0]; + if ([temp length] > 0) + { + interface = temp; + } + } + if ([components count] > 1 && port == 0) + { + long portL = strtol([[components objectAtIndex:1] UTF8String], NULL, 10); + + if (portL > 0 && portL <= UINT16_MAX) + { + port = (UInt16)portL; + } + } + + if (interface == nil) + { + // ANY address + + struct sockaddr_in nativeAddr4; + memset(&nativeAddr4, 0, sizeof(nativeAddr4)); + + nativeAddr4.sin_len = sizeof(nativeAddr4); + nativeAddr4.sin_family = AF_INET; + nativeAddr4.sin_port = htons(port); + nativeAddr4.sin_addr.s_addr = htonl(INADDR_ANY); + + struct sockaddr_in6 nativeAddr6; + memset(&nativeAddr6, 0, sizeof(nativeAddr6)); + + nativeAddr6.sin6_len = sizeof(nativeAddr6); + nativeAddr6.sin6_family = AF_INET6; + nativeAddr6.sin6_port = htons(port); + nativeAddr6.sin6_addr = in6addr_any; + + addr4 = [NSData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)]; + addr6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)]; + } + else if ([interface isEqualToString:@"localhost"] || [interface isEqualToString:@"loopback"]) + { + // LOOPBACK address + + struct sockaddr_in nativeAddr4; + memset(&nativeAddr4, 0, sizeof(nativeAddr4)); + + nativeAddr4.sin_len = sizeof(struct sockaddr_in); + nativeAddr4.sin_family = AF_INET; + nativeAddr4.sin_port = htons(port); + nativeAddr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + struct sockaddr_in6 nativeAddr6; + memset(&nativeAddr6, 0, sizeof(nativeAddr6)); + + nativeAddr6.sin6_len = sizeof(struct sockaddr_in6); + nativeAddr6.sin6_family = AF_INET6; + nativeAddr6.sin6_port = htons(port); + nativeAddr6.sin6_addr = in6addr_loopback; + + addr4 = [NSData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)]; + addr6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)]; + } + else + { + const char *iface = [interface UTF8String]; + + struct ifaddrs *addrs; + const struct ifaddrs *cursor; + + if ((getifaddrs(&addrs) == 0)) + { + cursor = addrs; + while (cursor != NULL) + { + if ((addr4 == nil) && (cursor->ifa_addr->sa_family == AF_INET)) + { + // IPv4 + + struct sockaddr_in *addr = (struct sockaddr_in *)cursor->ifa_addr; + + if (strcmp(cursor->ifa_name, iface) == 0) + { + // Name match + + struct sockaddr_in nativeAddr4 = *addr; + nativeAddr4.sin_port = htons(port); + + addr4 = [NSData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)]; + } + else + { + char ip[INET_ADDRSTRLEN]; + + const char *conversion; + conversion = inet_ntop(AF_INET, &addr->sin_addr, ip, sizeof(ip)); + + if ((conversion != NULL) && (strcmp(ip, iface) == 0)) + { + // IP match + + struct sockaddr_in nativeAddr4 = *addr; + nativeAddr4.sin_port = htons(port); + + addr4 = [NSData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)]; + } + } + } + else if ((addr6 == nil) && (cursor->ifa_addr->sa_family == AF_INET6)) + { + // IPv6 + + struct sockaddr_in6 *addr = (struct sockaddr_in6 *)cursor->ifa_addr; + + if (strcmp(cursor->ifa_name, iface) == 0) + { + // Name match + + struct sockaddr_in6 nativeAddr6 = *addr; + nativeAddr6.sin6_port = htons(port); + + addr6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)]; + } + else + { + char ip[INET6_ADDRSTRLEN]; + + const char *conversion; + conversion = inet_ntop(AF_INET6, &addr->sin6_addr, ip, sizeof(ip)); + + if ((conversion != NULL) && (strcmp(ip, iface) == 0)) + { + // IP match + + struct sockaddr_in6 nativeAddr6 = *addr; + nativeAddr6.sin6_port = htons(port); + + addr6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)]; + } + } + } + + cursor = cursor->ifa_next; + } + + freeifaddrs(addrs); + } + } + + if (interfaceAddr4Ptr) *interfaceAddr4Ptr = addr4; + if (interfaceAddr6Ptr) *interfaceAddr6Ptr = addr6; +} + +- (void)setupReadAndWriteSourcesForNewlyConnectedSocket:(int)socketFD +{ + readSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socketFD, 0, socketQueue); + writeSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, socketFD, 0, socketQueue); + + // Setup event handlers + + dispatch_source_set_event_handler(readSource, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogVerbose(@"readEventBlock"); + + socketFDBytesAvailable = dispatch_source_get_data(readSource); + LogVerbose(@"socketFDBytesAvailable: %lu", socketFDBytesAvailable); + + if (socketFDBytesAvailable > 0) + [self doReadData]; + else + [self doReadEOF]; + + [pool drain]; + }); + + dispatch_source_set_event_handler(writeSource, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogVerbose(@"writeEventBlock"); + + flags |= kSocketCanAcceptBytes; + [self doWriteData]; + + [pool drain]; + }); + + // Setup cancel handlers + + __block int socketFDRefCount = 2; + + dispatch_source_t theReadSource = readSource; + dispatch_source_t theWriteSource = writeSource; + + dispatch_source_set_cancel_handler(readSource, ^{ + + LogVerbose(@"readCancelBlock"); + + LogVerbose(@"dispatch_release(readSource)"); + dispatch_release(theReadSource); + + if (--socketFDRefCount == 0) + { + LogVerbose(@"close(socketFD)"); + close(socketFD); + } + }); + + dispatch_source_set_cancel_handler(writeSource, ^{ + + LogVerbose(@"writeCancelBlock"); + + LogVerbose(@"dispatch_release(writeSource)"); + dispatch_release(theWriteSource); + + if (--socketFDRefCount == 0) + { + LogVerbose(@"close(socketFD)"); + close(socketFD); + } + }); + + // We will not be able to read until data arrives. + // But we should be able to write immediately. + + socketFDBytesAvailable = 0; + flags &= ~kReadSourceSuspended; + + LogVerbose(@"dispatch_resume(readSource)"); + dispatch_resume(readSource); + + flags |= kSocketCanAcceptBytes; + flags |= kWriteSourceSuspended; +} + +- (BOOL)usingCFStream +{ + #if TARGET_OS_IPHONE + + if (flags & kSocketSecure) + { + // Due to the fact that Apple doesn't give us the full power of SecureTransport on iOS, + // we are relegated to using the slower, less powerful, and RunLoop based CFStream API. :( Boo! + // + // Thus we're not able to use the GCD read/write sources in this particular scenario. + + return YES; + } + + #endif + + return NO; +} + +- (void)suspendReadSource +{ + if (!(flags & kReadSourceSuspended)) + { + LogVerbose(@"dispatch_suspend(readSource)"); + + dispatch_suspend(readSource); + flags |= kReadSourceSuspended; + } +} + +- (void)resumeReadSource +{ + if (flags & kReadSourceSuspended) + { + LogVerbose(@"dispatch_resume(readSource)"); + + dispatch_resume(readSource); + flags &= ~kReadSourceSuspended; + } +} + +- (void)suspendWriteSource +{ + if (!(flags & kWriteSourceSuspended)) + { + LogVerbose(@"dispatch_suspend(writeSource)"); + + dispatch_suspend(writeSource); + flags |= kWriteSourceSuspended; + } +} + +- (void)resumeWriteSource +{ + if (flags & kWriteSourceSuspended) + { + LogVerbose(@"dispatch_resume(writeSource)"); + + dispatch_resume(writeSource); + flags &= ~kWriteSourceSuspended; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Reading +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag +{ + [self readDataWithTimeout:timeout buffer:nil bufferOffset:0 maxLength:0 tag:tag]; +} + +- (void)readDataWithTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag +{ + [self readDataWithTimeout:timeout buffer:buffer bufferOffset:offset maxLength:0 tag:tag]; +} + +- (void)readDataWithTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + maxLength:(NSUInteger)length + tag:(long)tag +{ + if (offset > [buffer length]) return; + + GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer + startOffset:offset + maxLength:length + timeout:timeout + readLength:0 + terminator:nil + tag:tag]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogTrace(); + + if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites)) + { + [readQueue addObject:packet]; + [self maybeDequeueRead]; + } + + [pool drain]; + }); + + // Do not rely on the block being run in order to release the packet, + // as the queue might get released without the block completing. + [packet release]; +} + +- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag +{ + [self readDataToLength:length withTimeout:timeout buffer:nil bufferOffset:0 tag:tag]; +} + +- (void)readDataToLength:(NSUInteger)length + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag +{ + if (length == 0) return; + if (offset > [buffer length]) return; + + GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer + startOffset:offset + maxLength:0 + timeout:timeout + readLength:length + terminator:nil + tag:tag]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogTrace(); + + if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites)) + { + [readQueue addObject:packet]; + [self maybeDequeueRead]; + } + + [pool drain]; + }); + + // Do not rely on the block being run in order to release the packet, + // as the queue might get released without the block completing. + [packet release]; +} + +- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag +{ + [self readDataToData:data withTimeout:timeout buffer:nil bufferOffset:0 maxLength:0 tag:tag]; +} + +- (void)readDataToData:(NSData *)data + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + tag:(long)tag +{ + [self readDataToData:data withTimeout:timeout buffer:buffer bufferOffset:offset maxLength:0 tag:tag]; +} + +- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(NSUInteger)length tag:(long)tag +{ + [self readDataToData:data withTimeout:timeout buffer:nil bufferOffset:0 maxLength:length tag:tag]; +} + +- (void)readDataToData:(NSData *)data + withTimeout:(NSTimeInterval)timeout + buffer:(NSMutableData *)buffer + bufferOffset:(NSUInteger)offset + maxLength:(NSUInteger)length + tag:(long)tag +{ + if ([data length] == 0) return; + if (offset > [buffer length]) return; + if (length > 0 && length < [data length]) return; + + GCDAsyncReadPacket *packet = [[GCDAsyncReadPacket alloc] initWithData:buffer + startOffset:offset + maxLength:length + timeout:timeout + readLength:0 + terminator:data + tag:tag]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogTrace(); + + if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites)) + { + [readQueue addObject:packet]; + [self maybeDequeueRead]; + } + + [pool drain]; + }); + + // Do not rely on the block being run in order to release the packet, + // as the queue might get released without the block completing. + [packet release]; +} + +/** + * This method starts a new read, if needed. + * + * It is called when: + * - a user requests a read + * - after a read request has finished (to handle the next request) + * - immediately after the socket opens to handle any pending requests + * + * This method also handles auto-disconnect post read/write completion. +**/ +- (void)maybeDequeueRead +{ + LogTrace(); + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + // If we're not currently processing a read AND we have an available read stream + if ((currentRead == nil) && (flags & kConnected)) + { + if ([readQueue count] > 0) + { + // Dequeue the next object in the write queue + currentRead = [[readQueue objectAtIndex:0] retain]; + [readQueue removeObjectAtIndex:0]; + + + if ([currentRead isKindOfClass:[GCDAsyncSpecialPacket class]]) + { + LogVerbose(@"Dequeued GCDAsyncSpecialPacket"); + + // Attempt to start TLS + flags |= kStartingReadTLS; + + // This method won't do anything unless both kStartingReadTLS and kStartingWriteTLS are set + [self maybeStartTLS]; + } + else + { + LogVerbose(@"Dequeued GCDAsyncReadPacket"); + + // Setup read timer (if needed) + [self setupReadTimerWithTimeout:currentRead->timeout]; + + // Immediately read, if possible + [self doReadData]; + } + } + else if (flags & kDisconnectAfterReads) + { + if (flags & kDisconnectAfterWrites) + { + if (([writeQueue count] == 0) && (currentWrite == nil)) + { + [self closeWithError:nil]; + } + } + else + { + [self closeWithError:nil]; + } + } + } +} + +- (void)doReadData +{ + LogTrace(); + + // This method is called on the socketQueue. + // It might be called directly, or via the readSource when data is available to be read. + + if ((currentRead == nil) || (flags & kReadsPaused)) + { + LogVerbose(@"No currentRead or kReadsPaused"); + + // Unable to read at this time + + if ([self usingCFStream]) + { + // CFReadStream only fires once when there is available data. + // It won't fire again until we've invoked CFReadStreamRead. + } + else + { + // If the readSource is firing, we need to pause it + // or else it will continue to fire over and over again. + // + // If the readSource is not firing, + // we want it to continue monitoring the socket. + + if (socketFDBytesAvailable > 0) + { + [self suspendReadSource]; + } + } + return; + } + + BOOL hasBytesAvailable; + unsigned long estimatedBytesAvailable; + + #if TARGET_OS_IPHONE + if (flags & kSocketSecure) + { + // Relegated to using CFStream... :( Boo! Give us SecureTransport Apple! + + estimatedBytesAvailable = 0; + hasBytesAvailable = (flags & kSecureSocketHasBytesAvailable) ? YES : NO; + } + else + { + estimatedBytesAvailable = socketFDBytesAvailable; + hasBytesAvailable = (estimatedBytesAvailable > 0); + + } + #else + + estimatedBytesAvailable = socketFDBytesAvailable + [sslReadBuffer length]; + + if (flags & kSocketSecure) + { + // SecureTransport has an internal buffer of its own. + // When we invoke SSLRead, it in turn invokes our lower level read IO function, + // and reads data in encrypted chunks from the socket. + // If we ask for a length of data from SSLRead that doesn't fall on the border of + // one of these encrypted chunks, then the SSLRead function stores the extra + // data in its own internal buffer. + // + // The SSLGetBufferedReadSize function will tell us the size of this internal buffer. + // From the documentation: + // + // "This function does not block or cause any low-level read operations to occur." + + size_t sslInternalBufSize = 0; + SSLGetBufferedReadSize(sslContext, &sslInternalBufSize); + + estimatedBytesAvailable += sslInternalBufSize; + } + + hasBytesAvailable = (estimatedBytesAvailable > 0); + + #endif + + if ((hasBytesAvailable == NO) && ([partialReadBuffer length] == 0)) + { + LogVerbose(@"No data available to read..."); + + // No data available to read. + + if (![self usingCFStream]) + { + // Need to wait for readSource to fire and notify us of + // available data in the socket's internal read buffer. + + [self resumeReadSource]; + } + return; + } + + if (flags & kStartingReadTLS) + { + LogVerbose(@"Waiting for SSL/TLS handshake to complete"); + + // The readQueue is waiting for SSL/TLS handshake to complete. + + if (flags & kStartingWriteTLS) + { + #if !TARGET_OS_IPHONE + + // We are in the process of a SSL Handshake. + // We were waiting for incoming data which has just arrived. + + [self continueSSLHandshake]; + + #endif + } + else + { + // We are still waiting for the writeQueue to drain and start the SSL/TLS process. + // We now know data is available to read. + + if (![self usingCFStream]) + { + // Suspend the read source or else it will continue to fire nonstop. + + [self suspendReadSource]; + } + } + + return; + } + + BOOL done = NO; // Completed read operation + BOOL waiting = NO; // Ran out of data, waiting for more + BOOL socketEOF = NO; // Nothing more to read (end of file) + NSError *error = nil; // Error occured + + NSUInteger totalBytesReadForCurrentRead = 0; + + // + // STEP 1 - READ FROM PREBUFFER + // + + NSUInteger partialReadBufferLength = [partialReadBuffer length]; + + if (partialReadBufferLength > 0) + { + // There are 3 types of read packets: + // + // 1) Read all available data. + // 2) Read a specific length of data. + // 3) Read up to a particular terminator. + + NSUInteger bytesToCopy; + + if (currentRead->term != nil) + { + // Read type #3 - read up to a terminator + + bytesToCopy = [currentRead readLengthForTermWithPreBuffer:partialReadBuffer found:&done]; + } + else + { + // Read type #1 or #2 + + bytesToCopy = [currentRead readLengthForNonTermWithHint:partialReadBufferLength]; + } + + // Make sure we have enough room in the buffer for our read. + + [currentRead ensureCapacityForAdditionalDataOfLength:bytesToCopy]; + + // Copy bytes from prebuffer into packet buffer + + UInt8 *buffer = (UInt8 *)[currentRead->buffer mutableBytes] + currentRead->startOffset + currentRead->bytesDone; + + memcpy(buffer, [partialReadBuffer bytes], bytesToCopy); + + // Remove the copied bytes from the partial read buffer + [partialReadBuffer replaceBytesInRange:NSMakeRange(0, bytesToCopy) withBytes:NULL length:0]; + partialReadBufferLength -= bytesToCopy; + + LogVerbose(@"copied(%lu) partialReadBufferLength(%lu)", bytesToCopy, partialReadBufferLength); + + // Update totals + + currentRead->bytesDone += bytesToCopy; + totalBytesReadForCurrentRead += bytesToCopy; + + // Check to see if the read operation is done + + if (currentRead->readLength > 0) + { + // Read type #2 - read a specific length of data + + done = (currentRead->bytesDone == currentRead->readLength); + } + else if (currentRead->term != nil) + { + // Read type #3 - read up to a terminator + + // Our 'done' variable was updated via the readLengthForTermWithPreBuffer:found: method + + if (!done && currentRead->maxLength > 0) + { + // We're not done and there's a set maxLength. + // Have we reached that maxLength yet? + + if (currentRead->bytesDone >= currentRead->maxLength) + { + error = [self readMaxedOutError]; + } + } + } + else + { + // Read type #1 - read all available data + // + // We're done as soon as we've read all available data. + // There might still be data in the socket to read, + // so we're not done yet. + } + + } + + // + // STEP 2 - READ FROM SOCKET + // + + if (!done && !error && hasBytesAvailable) + { + NSAssert((partialReadBufferLength == 0), @"Invalid logic"); + + // There are 3 types of read packets: + // + // 1) Read all available data. + // 2) Read a specific length of data. + // 3) Read up to a particular terminator. + + BOOL readIntoPartialReadBuffer = NO; + NSUInteger bytesToRead; + + if ([self usingCFStream]) + { + // Since Apple has neglected to make SecureTransport available on iOS, + // we are relegated to using the slower, less powerful, RunLoop based CFStream API. + // + // This API doesn't tell us how much data is available on the socket to be read. + // If we had that information we could optimize our memory allocations, and sys calls. + // + // But alas... + // So we do it old school, and just read as much data from the socket as we can. + + NSUInteger defaultReadLength = (1024 * 32); + + bytesToRead = [currentRead optimalReadLengthWithDefault:defaultReadLength + shouldPreBuffer:&readIntoPartialReadBuffer]; + } + else + { + if (currentRead->term != nil) + { + // Read type #3 - read up to a terminator + + bytesToRead = [currentRead readLengthForTermWithHint:estimatedBytesAvailable + shouldPreBuffer:&readIntoPartialReadBuffer]; + } + else + { + // Read type #1 or #2 + + bytesToRead = [currentRead readLengthForNonTermWithHint:estimatedBytesAvailable]; + } + } + + if (bytesToRead > SIZE_MAX) // NSUInteger may be bigger than size_t (read param 3) + { + bytesToRead = SIZE_MAX; + } + + // Make sure we have enough room in the buffer for our read. + // + // We are either reading directly into the currentRead->buffer, + // or we're reading into the temporary partialReadBuffer. + + UInt8 *buffer; + + if (readIntoPartialReadBuffer) + { + if (bytesToRead > partialReadBufferLength) + { + [partialReadBuffer setLength:bytesToRead]; + } + + buffer = [partialReadBuffer mutableBytes]; + } + else + { + [currentRead ensureCapacityForAdditionalDataOfLength:bytesToRead]; + + buffer = (UInt8 *)[currentRead->buffer mutableBytes] + currentRead->startOffset + currentRead->bytesDone; + } + + // Read data into buffer + + size_t bytesRead = 0; + + if (flags & kSocketSecure) + { + #if TARGET_OS_IPHONE + + CFIndex result = CFReadStreamRead(readStream, (UInt8 *)buffer, (CFIndex)bytesToRead); + LogVerbose(@"CFReadStreamRead(): result = %i", (int)result); + + if (result < 0) + { + error = [NSMakeCollectable(CFReadStreamCopyError(readStream)) autorelease]; + + if (readIntoPartialReadBuffer) + [partialReadBuffer setLength:0]; + } + else if (result == 0) + { + socketEOF = YES; + + if (readIntoPartialReadBuffer) + [partialReadBuffer setLength:0]; + } + else + { + waiting = YES; + bytesRead = (size_t)result; + } + + // We only know how many decrypted bytes were read. + // The actual number of bytes read was likely more due to the overhead of the encryption. + // So we reset our flag, and rely on the next callback to alert us of more data. + flags &= ~kSecureSocketHasBytesAvailable; + + #else + + OSStatus result = SSLRead(sslContext, buffer, (size_t)bytesToRead, &bytesRead); + LogVerbose(@"read from secure socket = %u", (unsigned)bytesRead); + + if (result != noErr) + { + if (result == errSSLWouldBlock) + waiting = YES; + else + error = [self sslError:result]; + + // It's possible that bytesRead > 0, yet the result is errSSLWouldBlock. + // This happens when the SSLRead function is able to read some data, + // but not the entire amount we requested. + + if (bytesRead <= 0) + { + bytesRead = 0; + + if (readIntoPartialReadBuffer) + [partialReadBuffer setLength:0]; + } + } + + // Do not modify socketFDBytesAvailable. + // It will be updated via the SSLReadFunction(). + + #endif + } + else + { + int socketFD = (socket4FD == SOCKET_NULL) ? socket6FD : socket4FD; + + ssize_t result = read(socketFD, buffer, (size_t)bytesToRead); + LogVerbose(@"read from socket = %i", (int)result); + + if (result < 0) + { + if (errno == EWOULDBLOCK) + waiting = YES; + else + error = [self errnoErrorWithReason:@"Error in read() function"]; + + socketFDBytesAvailable = 0; + + if (readIntoPartialReadBuffer) + [partialReadBuffer setLength:0]; + } + else if (result == 0) + { + socketEOF = YES; + socketFDBytesAvailable = 0; + + if (readIntoPartialReadBuffer) + [partialReadBuffer setLength:0]; + } + else + { + bytesRead = result; + + if (socketFDBytesAvailable <= bytesRead) + socketFDBytesAvailable = 0; + else + socketFDBytesAvailable -= bytesRead; + + if (socketFDBytesAvailable == 0) + { + waiting = YES; + } + } + } + + if (bytesRead > 0) + { + // Check to see if the read operation is done + + if (currentRead->readLength > 0) + { + // Read type #2 - read a specific length of data + // + // Note: We should never be using a prebuffer when we're reading a specific length of data. + + NSAssert(readIntoPartialReadBuffer == NO, @"Invalid logic"); + + currentRead->bytesDone += bytesRead; + totalBytesReadForCurrentRead += bytesRead; + + done = (currentRead->bytesDone == currentRead->readLength); + } + else if (currentRead->term != nil) + { + // Read type #3 - read up to a terminator + + if (readIntoPartialReadBuffer) + { + // We just read a big chunk of data into the partialReadBuffer. + // Search for the terminating sequence. + // + // Note: We are depending upon [partialReadBuffer length] to tell us how much data is + // available in the partialReadBuffer. So we need to be sure this matches how many bytes + // have actually been read into said buffer. + + [partialReadBuffer setLength:bytesRead]; + + bytesToRead = [currentRead readLengthForTermWithPreBuffer:partialReadBuffer found:&done]; + + // Ensure there's room on the read packet's buffer + + [currentRead ensureCapacityForAdditionalDataOfLength:bytesToRead]; + + // Copy bytes from prebuffer into read buffer + + UInt8 *preBuf = [partialReadBuffer mutableBytes]; + UInt8 *readBuf = (UInt8 *)[currentRead->buffer mutableBytes] + currentRead->startOffset + + currentRead->bytesDone; + + memcpy(readBuf, preBuf, bytesToRead); + + // Remove the copied bytes from the prebuffer + [partialReadBuffer replaceBytesInRange:NSMakeRange(0, bytesToRead) withBytes:NULL length:0]; + + // Update totals + currentRead->bytesDone += bytesToRead; + totalBytesReadForCurrentRead += bytesToRead; + + // Our 'done' variable was updated via the readLengthForTermWithPreBuffer:found: method above + } + else + { + // We just read a big chunk of data directly into the packet's buffer. + // We need to move any overflow into the prebuffer. + + NSInteger overflow = [currentRead searchForTermAfterPreBuffering:bytesRead]; + + if (overflow == 0) + { + // Perfect match! + // Every byte we read stays in the read buffer, + // and the last byte we read was the last byte of the term. + + currentRead->bytesDone += bytesRead; + totalBytesReadForCurrentRead += bytesRead; + done = YES; + } + else if (overflow > 0) + { + // The term was found within the data that we read, + // and there are extra bytes that extend past the end of the term. + // We need to move these excess bytes out of the read packet and into the prebuffer. + + NSInteger underflow = bytesRead - overflow; + + // Copy excess data into partialReadBuffer + void *overflowBuffer = buffer + currentRead->bytesDone + underflow; + + [partialReadBuffer appendBytes:overflowBuffer length:overflow]; + + // Note: The completeCurrentRead method will trim the buffer for us. + + currentRead->bytesDone += underflow; + totalBytesReadForCurrentRead += underflow; + done = YES; + } + else + { + // The term was not found within the data that we read. + + currentRead->bytesDone += bytesRead; + totalBytesReadForCurrentRead += bytesRead; + done = NO; + } + } + + if (!done && currentRead->maxLength > 0) + { + // We're not done and there's a set maxLength. + // Have we reached that maxLength yet? + + if (currentRead->bytesDone >= currentRead->maxLength) + { + error = [self readMaxedOutError]; + } + } + } + else + { + // Read type #1 - read all available data + + if (readIntoPartialReadBuffer) + { + // We just read a chunk of data into the partialReadBuffer. + // Copy the data into the read packet. + // + // Recall that we didn't read directly into the packet's buffer to avoid + // over-allocating memory since we had no clue how much data was available to be read. + // + // Note: We are depending upon [partialReadBuffer length] to tell us how much data is + // available in the partialReadBuffer. So we need to be sure this matches how many bytes + // have actually been read into said buffer. + + [partialReadBuffer setLength:bytesRead]; + + // Ensure there's room on the read packet's buffer + + [currentRead ensureCapacityForAdditionalDataOfLength:bytesRead]; + + // Copy bytes from prebuffer into read buffer + + UInt8 *preBuf = [partialReadBuffer mutableBytes]; + UInt8 *readBuf = (UInt8 *)[currentRead->buffer mutableBytes] + currentRead->startOffset + + currentRead->bytesDone; + + memcpy(readBuf, preBuf, bytesRead); + + // Remove the copied bytes from the prebuffer + [partialReadBuffer replaceBytesInRange:NSMakeRange(0, bytesRead) withBytes:NULL length:0]; + + // Update totals + currentRead->bytesDone += bytesRead; + totalBytesReadForCurrentRead += bytesRead; + } + else + { + currentRead->bytesDone += bytesRead; + totalBytesReadForCurrentRead += bytesRead; + } + + done = YES; + } + + } // if (bytesRead > 0) + + } // if (!done && !error && hasBytesAvailable) + + + if (!done && currentRead->readLength == 0 && currentRead->term == nil) + { + // Read type #1 - read all available data + // + // We might arrive here if we read data from the prebuffer but not from the socket. + + done = (totalBytesReadForCurrentRead > 0); + } + + // Only one of the following can possibly be true: + // + // - waiting + // - socketEOF + // - socketError + // - maxoutError + // + // They may all be false. + // One of the above may be true even if done is true. + // This might be the case if we completed read type #1 via data from the prebuffer. + + if (done) + { + [self completeCurrentRead]; + + if (!socketEOF && !error) + { + [self maybeDequeueRead]; + } + } + else if (totalBytesReadForCurrentRead > 0) + { + // We're not done read type #2 or #3 yet, but we have read in some bytes + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:didReadPartialDataOfLength:tag:)]) + { + id theDelegate = delegate; + GCDAsyncReadPacket *theRead = currentRead; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socket:self didReadPartialDataOfLength:totalBytesReadForCurrentRead tag:theRead->tag]; + + [pool drain]; + }); + } + } + + // Check for errors + + if (error) + { + [self closeWithError:error]; + } + else if (socketEOF) + { + [self doReadEOF]; + } + else if (waiting) + { + if (![self usingCFStream]) + { + // Monitor the socket for readability (if we're not already doing so) + [self resumeReadSource]; + } + } + + // Do not add any code here without first adding return statements in the error cases above. +} + +- (void)doReadEOF +{ + LogTrace(); + + BOOL shouldDisconnect; + NSError *error = nil; + + if ((flags & kStartingReadTLS) || (flags & kStartingWriteTLS)) + { + // We received an EOF during or prior to startTLS. + // The SSL/TLS handshake is now impossible, so this is an unrecoverable situation. + + shouldDisconnect = YES; + + #if !TARGET_OS_IPHONE + error = [self sslError:errSSLClosedAbort]; + #endif + } + else if (config & kAllowHalfDuplexConnection) + { + // We just received an EOF (end of file) from the socket's read stream. + // Query the socket to see if it is still writeable. + + int socketFD = (socket4FD == SOCKET_NULL) ? socket6FD : socket4FD; + + struct pollfd pfd[1]; + pfd[0].fd = socketFD; + pfd[0].events = POLLOUT; + pfd[0].revents = 0; + + poll(pfd, 1, 0); + + shouldDisconnect = (pfd[0].revents & POLLOUT) ? NO : YES; + } + else + { + shouldDisconnect = YES; + } + + + if (shouldDisconnect) + { + if (error == nil) + { + error = [self connectionClosedError]; + } + [self closeWithError:error]; + } + else + { + // Notify the delegate + + if (delegateQueue && [delegate respondsToSelector:@selector(socketDidCloseReadStream:)]) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socketDidCloseReadStream:self]; + + [pool drain]; + }); + } + + if (![self usingCFStream]) + { + // Suspend the read source (if needed) + + [self suspendReadSource]; + } + } +} + +- (void)completeCurrentRead +{ + LogTrace(); + + NSAssert(currentRead, @"Trying to complete current read when there is no current read."); + + + NSData *result; + + if (currentRead->bufferOwner) + { + // We created the buffer on behalf of the user. + // Trim our buffer to be the proper size. + [currentRead->buffer setLength:currentRead->bytesDone]; + + result = currentRead->buffer; + } + else + { + // We did NOT create the buffer. + // The buffer is owned by the caller. + // Only trim the buffer if we had to increase its size. + + if ([currentRead->buffer length] > currentRead->originalBufferLength) + { + NSUInteger readSize = currentRead->startOffset + currentRead->bytesDone; + NSUInteger origSize = currentRead->originalBufferLength; + + NSUInteger buffSize = MAX(readSize, origSize); + + [currentRead->buffer setLength:buffSize]; + } + + UInt8 *buffer = (UInt8 *)[currentRead->buffer mutableBytes] + currentRead->startOffset; + + result = [NSData dataWithBytesNoCopy:buffer length:currentRead->bytesDone freeWhenDone:NO]; + } + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:didReadData:withTag:)]) + { + id theDelegate = delegate; + GCDAsyncReadPacket *theRead = currentRead; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socket:self didReadData:result withTag:theRead->tag]; + + [pool drain]; + }); + } + + [self endCurrentRead]; +} + +- (void)endCurrentRead +{ + if (readTimer) + { + dispatch_source_cancel(readTimer); + readTimer = NULL; + } + + [currentRead release]; + currentRead = nil; +} + +- (void)setupReadTimerWithTimeout:(NSTimeInterval)timeout +{ + if (timeout >= 0.0) + { + readTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, socketQueue); + + dispatch_source_set_event_handler(readTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self doReadTimeout]; + [pool drain]; + }); + + dispatch_source_t theReadTimer = readTimer; + dispatch_source_set_cancel_handler(readTimer, ^{ + LogVerbose(@"dispatch_release(readTimer)"); + dispatch_release(theReadTimer); + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(readTimer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(readTimer); + } +} + +- (void)doReadTimeout +{ + // This is a little bit tricky. + // Ideally we'd like to synchronously query the delegate about a timeout extension. + // But if we do so synchronously we risk a possible deadlock. + // So instead we have to do so asynchronously, and callback to ourselves from within the delegate block. + + flags |= kReadsPaused; + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:shouldTimeoutReadWithTag:elapsed:bytesDone:)]) + { + id theDelegate = delegate; + GCDAsyncReadPacket *theRead = currentRead; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *delegatePool = [[NSAutoreleasePool alloc] init]; + + NSTimeInterval timeoutExtension = 0.0; + + timeoutExtension = [theDelegate socket:self shouldTimeoutReadWithTag:theRead->tag + elapsed:theRead->timeout + bytesDone:theRead->bytesDone]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *callbackPool = [[NSAutoreleasePool alloc] init]; + + [self doReadTimeoutWithExtension:timeoutExtension]; + + [callbackPool drain]; + }); + + [delegatePool drain]; + }); + } + else + { + [self doReadTimeoutWithExtension:0.0]; + } +} + +- (void)doReadTimeoutWithExtension:(NSTimeInterval)timeoutExtension +{ + if (currentRead) + { + if (timeoutExtension > 0.0) + { + currentRead->timeout += timeoutExtension; + + // Reschedule the timer + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeoutExtension * NSEC_PER_SEC)); + dispatch_source_set_timer(readTimer, tt, DISPATCH_TIME_FOREVER, 0); + + // Unpause reads, and continue + flags &= ~kReadsPaused; + [self doReadData]; + } + else + { + LogVerbose(@"ReadTimeout"); + + [self closeWithError:[self readTimeoutError]]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Writing +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag +{ + if ([data length] == 0) return; + + GCDAsyncWritePacket *packet = [[GCDAsyncWritePacket alloc] initWithData:data timeout:timeout tag:tag]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogTrace(); + + if ((flags & kSocketStarted) && !(flags & kForbidReadsWrites)) + { + [writeQueue addObject:packet]; + [self maybeDequeueWrite]; + } + + [pool drain]; + }); + + // Do not rely on the block being run in order to release the packet, + // as the queue might get released without the block completing. + [packet release]; +} + +/** + * Conditionally starts a new write. + * + * It is called when: + * - a user requests a write + * - after a write request has finished (to handle the next request) + * - immediately after the socket opens to handle any pending requests + * + * This method also handles auto-disconnect post read/write completion. +**/ +- (void)maybeDequeueWrite +{ + LogTrace(); + NSAssert(dispatch_get_current_queue() == socketQueue, @"Must be dispatched on socketQueue"); + + + // If we're not currently processing a write AND we have an available write stream + if ((currentWrite == nil) && (flags & kConnected)) + { + if ([writeQueue count] > 0) + { + // Dequeue the next object in the write queue + currentWrite = [[writeQueue objectAtIndex:0] retain]; + [writeQueue removeObjectAtIndex:0]; + + + if ([currentWrite isKindOfClass:[GCDAsyncSpecialPacket class]]) + { + LogVerbose(@"Dequeued GCDAsyncSpecialPacket"); + + // Attempt to start TLS + flags |= kStartingWriteTLS; + + // This method won't do anything unless both kStartingReadTLS and kStartingWriteTLS are set + [self maybeStartTLS]; + } + else + { + LogVerbose(@"Dequeued GCDAsyncWritePacket"); + + // Setup write timer (if needed) + [self setupWriteTimerWithTimeout:currentWrite->timeout]; + + // Immediately write, if possible + [self doWriteData]; + } + } + else if (flags & kDisconnectAfterWrites) + { + if (flags & kDisconnectAfterReads) + { + if (([readQueue count] == 0) && (currentRead == nil)) + { + [self closeWithError:nil]; + } + } + else + { + [self closeWithError:nil]; + } + } + } +} + +- (void)doWriteData +{ + LogTrace(); + + // This method is called by the writeSource via the socketQueue + + if ((currentWrite == nil) || (flags & kWritesPaused)) + { + LogVerbose(@"No currentWrite or kWritesPaused"); + + // Unable to write at this time + + if ([self usingCFStream]) + { + // CFWriteStream only fires once when there is available data. + // It won't fire again until we've invoked CFWriteStreamWrite. + } + else + { + // If the writeSource is firing, we need to pause it + // or else it will continue to fire over and over again. + + if (flags & kSocketCanAcceptBytes) + { + [self suspendWriteSource]; + } + } + return; + } + + if (!(flags & kSocketCanAcceptBytes)) + { + LogVerbose(@"No space available to write..."); + + // No space available to write. + + if (![self usingCFStream]) + { + // Need to wait for writeSource to fire and notify us of + // available space in the socket's internal write buffer. + + [self resumeWriteSource]; + } + return; + } + + if (flags & kStartingWriteTLS) + { + LogVerbose(@"Waiting for SSL/TLS handshake to complete"); + + // The writeQueue is waiting for SSL/TLS handshake to complete. + + if (flags & kStartingReadTLS) + { + #if !TARGET_OS_IPHONE + + // We are in the process of a SSL Handshake. + // We were waiting for available space in the socket's internal OS buffer to continue writing. + + [self continueSSLHandshake]; + + #endif + } + else + { + // We are still waiting for the readQueue to drain and start the SSL/TLS process. + // We now know we can write to the socket. + + if (![self usingCFStream]) + { + // Suspend the write source or else it will continue to fire nonstop. + + [self suspendWriteSource]; + } + } + + return; + } + + // Note: This method is not called if theCurrentWrite is an GCDAsyncSpecialPacket (startTLS packet) + + BOOL waiting = NO; + NSError *error = nil; + size_t bytesWritten = 0; + + if (flags & kSocketSecure) + { + #if TARGET_OS_IPHONE + + void *buffer = (void *)[currentWrite->buffer bytes] + currentWrite->bytesDone; + + NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone; + + if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3) + { + bytesToWrite = SIZE_MAX; + } + + CFIndex result = CFWriteStreamWrite(writeStream, (UInt8 *)buffer, (CFIndex)bytesToWrite); + LogVerbose(@"CFWriteStreamWrite(%lu) = %li", bytesToWrite, result); + + if (result < 0) + { + error = [NSMakeCollectable(CFWriteStreamCopyError(writeStream)) autorelease]; + } + else + { + bytesWritten = (size_t)result; + + // We always set waiting to true in this scenario. + // CFStream may have altered our underlying socket to non-blocking. + // Thus if we attempt to write without a callback, we may end up blocking our queue. + waiting = YES; + } + + #else + + // We're going to use the SSLWrite function. + // + // OSStatus SSLWrite(SSLContextRef context, const void *data, size_t dataLength, size_t *processed) + // + // Parameters: + // context - An SSL session context reference. + // data - A pointer to the buffer of data to write. + // dataLength - The amount, in bytes, of data to write. + // processed - On return, the length, in bytes, of the data actually written. + // + // It sounds pretty straight-forward, + // but there are a few caveats you should be aware of. + // + // The SSLWrite method operates in a non-obvious (and rather annoying) manner. + // According to the documentation: + // + // Because you may configure the underlying connection to operate in a non-blocking manner, + // a write operation might return errSSLWouldBlock, indicating that less data than requested + // was actually transferred. In this case, you should repeat the call to SSLWrite until some + // other result is returned. + // + // This sounds perfect, but when our SSLWriteFunction returns errSSLWouldBlock, + // then the SSLWrite method returns (with the proper errSSLWouldBlock return value), + // but it sets bytesWritten to bytesToWrite !! + // + // In other words, if the SSLWrite function doesn't completely write all the data we tell it to, + // then it doesn't tell us how many bytes were actually written. + // + // You might be wondering: + // If the SSLWrite function doesn't tell us how many bytes were written, + // then how in the world are we supposed to update our parameters (buffer & bytesToWrite) + // for the next time we invoke SSLWrite? + // + // The answer is that SSLWrite cached all the data we told it to write, + // and it will push out that data next time we call SSLWrite. + // If we call SSLWrite with new data, it will push out the cached data first, and then the new data. + // If we call SSLWrite with empty data, then it will simply push out the cached data. + // + // For this purpose we're going to break large writes into a series of smaller writes. + // This allows us to report progress back to the delegate. + + OSStatus result; + + BOOL hasCachedDataToWrite = (sslWriteCachedLength > 0); + BOOL hasNewDataToWrite = YES; + + if (hasCachedDataToWrite) + { + size_t processed = 0; + + result = SSLWrite(sslContext, NULL, 0, &processed); + + if (result == noErr) + { + bytesWritten = sslWriteCachedLength; + sslWriteCachedLength = 0; + + if (currentWrite->bytesDone == [currentWrite->buffer length]) + { + // We've written all data for the current write. + hasNewDataToWrite = NO; + } + } + else + { + if (result == errSSLWouldBlock) + { + waiting = YES; + } + else + { + error = [self sslError:result]; + } + + // Can't write any new data since we were unable to write the cached data. + hasNewDataToWrite = NO; + } + } + + if (hasNewDataToWrite) + { + const UInt8 *buffer = (const UInt8 *)[currentWrite->buffer bytes] + currentWrite->bytesDone + bytesWritten; + + NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone - bytesWritten; + + if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3) + { + bytesToWrite = SIZE_MAX; + } + + size_t bytesRemaining = bytesToWrite; + + BOOL keepLooping = YES; + while (keepLooping) + { + size_t sslBytesToWrite = MIN(bytesRemaining, 32768); + size_t sslBytesWritten = 0; + + result = SSLWrite(sslContext, buffer, sslBytesToWrite, &sslBytesWritten); + + if (result == noErr) + { + buffer += sslBytesWritten; + bytesWritten += sslBytesWritten; + bytesRemaining -= sslBytesWritten; + + keepLooping = (bytesRemaining > 0); + } + else + { + if (result == errSSLWouldBlock) + { + waiting = YES; + sslWriteCachedLength = sslBytesToWrite; + } + else + { + error = [self sslError:result]; + } + + keepLooping = NO; + } + + } // while (keepLooping) + + } // if (hasNewDataToWrite) + + #endif + } + else + { + int socketFD = (socket4FD == SOCKET_NULL) ? socket6FD : socket4FD; + + const UInt8 *buffer = (const UInt8 *)[currentWrite->buffer bytes] + currentWrite->bytesDone; + + NSUInteger bytesToWrite = [currentWrite->buffer length] - currentWrite->bytesDone; + + if (bytesToWrite > SIZE_MAX) // NSUInteger may be bigger than size_t (write param 3) + { + bytesToWrite = SIZE_MAX; + } + + ssize_t result = write(socketFD, buffer, (size_t)bytesToWrite); + LogVerbose(@"wrote to socket = %zd", result); + + // Check results + if (result < 0) + { + if (errno == EWOULDBLOCK) + { + waiting = YES; + } + else + { + error = [self errnoErrorWithReason:@"Error in write() function"]; + } + } + else + { + bytesWritten = result; + } + } + + // We're done with our writing. + // If we explictly ran into a situation where the socket told us there was no room in the buffer, + // then we immediately resume listening for notifications. + // + // We must do this before we dequeue another write, + // as that may in turn invoke this method again. + // + // Note that if CFStream is involved, it may have maliciously put our socket in blocking mode. + + if (waiting) + { + flags &= ~kSocketCanAcceptBytes; + + if (![self usingCFStream]) + { + [self resumeWriteSource]; + } + } + + // Check our results + + BOOL done = NO; + + if (bytesWritten > 0) + { + // Update total amount read for the current write + currentWrite->bytesDone += bytesWritten; + LogVerbose(@"currentWrite->bytesDone = %lu", currentWrite->bytesDone); + + // Is packet done? + done = (currentWrite->bytesDone == [currentWrite->buffer length]); + } + + if (done) + { + [self completeCurrentWrite]; + + if (!error) + { + [self maybeDequeueWrite]; + } + } + else + { + // We were unable to finish writing the data, + // so we're waiting for another callback to notify us of available space in the lower-level output buffer. + + if (!waiting & !error) + { + // This would be the case if our write was able to accept some data, but not all of it. + + flags &= ~kSocketCanAcceptBytes; + + if (![self usingCFStream]) + { + [self resumeWriteSource]; + } + } + + if (bytesWritten > 0) + { + // We're not done with the entire write, but we have written some bytes + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:didWritePartialDataOfLength:tag:)]) + { + id theDelegate = delegate; + GCDAsyncWritePacket *theWrite = currentWrite; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socket:self didWritePartialDataOfLength:bytesWritten tag:theWrite->tag]; + + [pool drain]; + }); + } + } + } + + // Check for errors + + if (error) + { + [self closeWithError:[self errnoErrorWithReason:@"Error in write() function"]]; + } + + // Do not add any code here without first adding a return statement in the error case above. +} + +- (void)completeCurrentWrite +{ + LogTrace(); + + NSAssert(currentWrite, @"Trying to complete current write when there is no current write."); + + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:didWriteDataWithTag:)]) + { + id theDelegate = delegate; + GCDAsyncWritePacket *theWrite = currentWrite; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socket:self didWriteDataWithTag:theWrite->tag]; + + [pool drain]; + }); + } + + [self endCurrentWrite]; +} + +- (void)endCurrentWrite +{ + if (writeTimer) + { + dispatch_source_cancel(writeTimer); + writeTimer = NULL; + } + + [currentWrite release]; + currentWrite = nil; +} + +- (void)setupWriteTimerWithTimeout:(NSTimeInterval)timeout +{ + if (timeout >= 0.0) + { + writeTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, socketQueue); + + dispatch_source_set_event_handler(writeTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self doWriteTimeout]; + + [pool drain]; + }); + + dispatch_source_t theWriteTimer = writeTimer; + dispatch_source_set_cancel_handler(writeTimer, ^{ + LogVerbose(@"dispatch_release(writeTimer)"); + dispatch_release(theWriteTimer); + }); + + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeout * NSEC_PER_SEC)); + + dispatch_source_set_timer(writeTimer, tt, DISPATCH_TIME_FOREVER, 0); + dispatch_resume(writeTimer); + } +} + +- (void)doWriteTimeout +{ + // This is a little bit tricky. + // Ideally we'd like to synchronously query the delegate about a timeout extension. + // But if we do so synchronously we risk a possible deadlock. + // So instead we have to do so asynchronously, and callback to ourselves from within the delegate block. + + flags |= kWritesPaused; + + if (delegateQueue && [delegate respondsToSelector:@selector(socket:shouldTimeoutWriteWithTag:elapsed:bytesDone:)]) + { + id theDelegate = delegate; + GCDAsyncWritePacket *theWrite = currentWrite; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *delegatePool = [[NSAutoreleasePool alloc] init]; + + NSTimeInterval timeoutExtension = 0.0; + + timeoutExtension = [theDelegate socket:self shouldTimeoutWriteWithTag:theWrite->tag + elapsed:theWrite->timeout + bytesDone:theWrite->bytesDone]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *callbackPool = [[NSAutoreleasePool alloc] init]; + + [self doWriteTimeoutWithExtension:timeoutExtension]; + + [callbackPool drain]; + }); + + [delegatePool drain]; + }); + } + else + { + [self doWriteTimeoutWithExtension:0.0]; + } +} + +- (void)doWriteTimeoutWithExtension:(NSTimeInterval)timeoutExtension +{ + if (currentWrite) + { + if (timeoutExtension > 0.0) + { + currentWrite->timeout += timeoutExtension; + + // Reschedule the timer + dispatch_time_t tt = dispatch_time(DISPATCH_TIME_NOW, (timeoutExtension * NSEC_PER_SEC)); + dispatch_source_set_timer(writeTimer, tt, DISPATCH_TIME_FOREVER, 0); + + // Unpause writes, and continue + flags &= ~kWritesPaused; + [self doWriteData]; + } + else + { + LogVerbose(@"WriteTimeout"); + + [self closeWithError:[self writeTimeoutError]]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Security +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)startTLS:(NSDictionary *)tlsSettings +{ + LogTrace(); + + if (tlsSettings == nil) + { + // Passing nil/NULL to CFReadStreamSetProperty will appear to work the same as passing an empty dictionary, + // but causes problems if we later try to fetch the remote host's certificate. + // + // To be exact, it causes the following to return NULL instead of the normal result: + // CFReadStreamCopyProperty(readStream, kCFStreamPropertySSLPeerCertificates) + // + // So we use an empty dictionary instead, which works perfectly. + + tlsSettings = [NSDictionary dictionary]; + } + + GCDAsyncSpecialPacket *packet = [[GCDAsyncSpecialPacket alloc] initWithTLSSettings:tlsSettings]; + + dispatch_async(socketQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ((flags & kSocketStarted) && !(flags & kQueuedTLS) && !(flags & kForbidReadsWrites)) + { + [readQueue addObject:packet]; + [writeQueue addObject:packet]; + + flags |= kQueuedTLS; + + [self maybeDequeueRead]; + [self maybeDequeueWrite]; + } + + [pool drain]; + }); + + [packet release]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Security - Mac OS X +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if !TARGET_OS_IPHONE + +- (OSStatus)sslReadWithBuffer:(void *)buffer length:(size_t *)bufferLength +{ + LogVerbose(@"sslReadWithBuffer:%p length:%lu", buffer, (unsigned long)*bufferLength); + + if ((socketFDBytesAvailable == 0) && ([sslReadBuffer length] == 0)) + { + LogVerbose(@"%@ - No data available to read...", THIS_METHOD); + + // No data available to read. + // + // Need to wait for readSource to fire and notify us of + // available data in the socket's internal read buffer. + + [self resumeReadSource]; + + *bufferLength = 0; + return errSSLWouldBlock; + } + + size_t totalBytesLeft = *bufferLength; + size_t totalBytesRead = 0; + + BOOL done = NO; + BOOL socketError = NO; + + // + // STEP 1 : READ FROM SSL PRE BUFFER + // + + NSUInteger sslReadBufferLength = [sslReadBuffer length]; + + if (sslReadBufferLength > 0) + { + LogVerbose(@"%@: Reading from SSL pre buffer...", THIS_METHOD); + + size_t bytesToCopy = (size_t)((sslReadBufferLength > totalBytesLeft) ? totalBytesLeft : sslReadBufferLength); + + LogVerbose(@"%@: Copying %zu bytes from sslReadBuffer", THIS_METHOD, bytesToCopy); + + memcpy(buffer, [sslReadBuffer mutableBytes], bytesToCopy); + + [sslReadBuffer replaceBytesInRange:NSMakeRange(0, bytesToCopy) withBytes:NULL length:0]; + + LogVerbose(@"%@: sslReadBuffer.length = %lu", THIS_METHOD, (unsigned long)[sslReadBuffer length]); + + totalBytesLeft -= bytesToCopy; + totalBytesRead += bytesToCopy; + + done = (totalBytesLeft == 0); + + if (done) LogVerbose(@"%@: Complete", THIS_METHOD); + } + + // + // STEP 2 : READ FROM SOCKET + // + + if (!done && (socketFDBytesAvailable > 0)) + { + LogVerbose(@"%@: Reading from socket...", THIS_METHOD); + + int socketFD = (socket6FD == SOCKET_NULL) ? socket4FD : socket6FD; + + BOOL readIntoPreBuffer; + size_t bytesToRead; + UInt8 *buf; + + if (socketFDBytesAvailable > totalBytesLeft) + { + // Read all available data from socket into sslReadBuffer. + // Then copy requested amount into dataBuffer. + + LogVerbose(@"%@: Reading into sslReadBuffer...", THIS_METHOD); + + if ([sslReadBuffer length] < socketFDBytesAvailable) + { + [sslReadBuffer setLength:socketFDBytesAvailable]; + } + + readIntoPreBuffer = YES; + bytesToRead = (size_t)socketFDBytesAvailable; + buf = [sslReadBuffer mutableBytes]; + } + else + { + // Read available data from socket directly into dataBuffer. + + LogVerbose(@"%@: Reading directly into dataBuffer...", THIS_METHOD); + + readIntoPreBuffer = NO; + bytesToRead = totalBytesLeft; + buf = (UInt8 *)buffer + totalBytesRead; + } + + ssize_t result = read(socketFD, buf, bytesToRead); + LogVerbose(@"%@: read from socket = %zd", THIS_METHOD, result); + + if (result < 0) + { + LogVerbose(@"%@: read errno = %i", THIS_METHOD, errno); + + if (errno != EWOULDBLOCK) + { + socketError = YES; + } + + socketFDBytesAvailable = 0; + + if (readIntoPreBuffer) + { + [sslReadBuffer setLength:0]; + } + } + else if (result == 0) + { + socketError = YES; + socketFDBytesAvailable = 0; + + if (readIntoPreBuffer) + { + [sslReadBuffer setLength:0]; + } + } + else + { + size_t bytesReadFromSocket = result; + + if (socketFDBytesAvailable > bytesReadFromSocket) + socketFDBytesAvailable -= bytesReadFromSocket; + else + socketFDBytesAvailable = 0; + + if (readIntoPreBuffer) + { + size_t bytesToCopy = MIN(totalBytesLeft, bytesReadFromSocket); + + LogVerbose(@"%@: Copying %zu bytes out of sslReadBuffer", THIS_METHOD, bytesToCopy); + + memcpy((UInt8 *)buffer + totalBytesRead, [sslReadBuffer bytes], bytesToCopy); + + [sslReadBuffer setLength:bytesReadFromSocket]; + [sslReadBuffer replaceBytesInRange:NSMakeRange(0, bytesToCopy) withBytes:NULL length:0]; + + totalBytesLeft -= bytesToCopy; + totalBytesRead += bytesToCopy; + + LogVerbose(@"%@: sslReadBuffer.length = %lu", THIS_METHOD, (unsigned long)[sslReadBuffer length]); + } + else + { + totalBytesLeft -= bytesReadFromSocket; + totalBytesRead += bytesReadFromSocket; + } + + done = (totalBytesLeft == 0); + + if (done) LogVerbose(@"%@: Complete", THIS_METHOD); + } + } + + *bufferLength = totalBytesRead; + + if (done) + return noErr; + + if (socketError) + return errSSLClosedAbort; + + return errSSLWouldBlock; +} + +- (OSStatus)sslWriteWithBuffer:(const void *)buffer length:(size_t *)bufferLength +{ + if (!(flags & kSocketCanAcceptBytes)) + { + // Unable to write. + // + // Need to wait for writeSource to fire and notify us of + // available space in the socket's internal write buffer. + + [self resumeWriteSource]; + + *bufferLength = 0; + return errSSLWouldBlock; + } + + size_t bytesToWrite = *bufferLength; + size_t bytesWritten = 0; + + BOOL done = NO; + BOOL socketError = NO; + + int socketFD = (socket4FD == SOCKET_NULL) ? socket6FD : socket4FD; + + ssize_t result = write(socketFD, buffer, bytesToWrite); + + if (result < 0) + { + if (errno != EWOULDBLOCK) + { + socketError = YES; + } + + flags &= ~kSocketCanAcceptBytes; + } + else if (result == 0) + { + flags &= ~kSocketCanAcceptBytes; + } + else + { + bytesWritten = result; + + done = (bytesWritten == bytesToWrite); + } + + *bufferLength = bytesWritten; + + if (done) + return noErr; + + if (socketError) + return errSSLClosedAbort; + + return errSSLWouldBlock; +} + +static OSStatus SSLReadFunction(SSLConnectionRef connection, void *data, size_t *dataLength) +{ + GCDAsyncSocket *asyncSocket = (GCDAsyncSocket *)connection; + + NSCAssert(dispatch_get_current_queue() == asyncSocket->socketQueue, @"What the deuce?"); + + return [asyncSocket sslReadWithBuffer:data length:dataLength]; +} + +static OSStatus SSLWriteFunction(SSLConnectionRef connection, const void *data, size_t *dataLength) +{ + GCDAsyncSocket *asyncSocket = (GCDAsyncSocket *)connection; + + NSCAssert(dispatch_get_current_queue() == asyncSocket->socketQueue, @"What the deuce?"); + + return [asyncSocket sslWriteWithBuffer:data length:dataLength]; +} + +- (void)maybeStartTLS +{ + LogTrace(); + + // We can't start TLS until: + // - All queued reads prior to the user calling startTLS are complete + // - All queued writes prior to the user calling startTLS are complete + // + // We'll know these conditions are met when both kStartingReadTLS and kStartingWriteTLS are set + + if ((flags & kStartingReadTLS) && (flags & kStartingWriteTLS)) + { + LogVerbose(@"Starting TLS..."); + + OSStatus status; + + GCDAsyncSpecialPacket *tlsPacket = (GCDAsyncSpecialPacket *)currentRead; + NSDictionary *tlsSettings = tlsPacket->tlsSettings; + + // Create SSLContext, and setup IO callbacks and connection ref + + BOOL isServer = [[tlsSettings objectForKey:(NSString *)kCFStreamSSLIsServer] boolValue]; + + status = SSLNewContext(isServer, &sslContext); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLNewContext"]]; + return; + } + + status = SSLSetIOFuncs(sslContext, &SSLReadFunction, &SSLWriteFunction); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetIOFuncs"]]; + return; + } + + status = SSLSetConnection(sslContext, (SSLConnectionRef)self); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetConnection"]]; + return; + } + + // Configure SSLContext from given settings + // + // Checklist: + // 1. kCFStreamSSLPeerName + // 2. kCFStreamSSLAllowsAnyRoot + // 3. kCFStreamSSLAllowsExpiredRoots + // 4. kCFStreamSSLValidatesCertificateChain + // 5. kCFStreamSSLAllowsExpiredCertificates + // 6. kCFStreamSSLCertificates + // 7. kCFStreamSSLLevel + // 8. GCDAsyncSocketSSLCipherSuites + // 9. GCDAsyncSocketSSLDiffieHellmanParameters + + id value; + + // 1. kCFStreamSSLPeerName + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLPeerName]; + if ([value isKindOfClass:[NSString class]]) + { + NSString *peerName = (NSString *)value; + + const char *peer = [peerName UTF8String]; + size_t peerLen = strlen(peer); + + status = SSLSetPeerDomainName(sslContext, peer, peerLen); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetPeerDomainName"]]; + return; + } + } + + // 2. kCFStreamSSLAllowsAnyRoot + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLAllowsAnyRoot]; + if (value) + { + BOOL allowsAnyRoot = [value boolValue]; + + status = SSLSetAllowsAnyRoot(sslContext, allowsAnyRoot); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetAllowsAnyRoot"]]; + return; + } + } + + // 3. kCFStreamSSLAllowsExpiredRoots + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLAllowsExpiredRoots]; + if (value) + { + BOOL allowsExpiredRoots = [value boolValue]; + + status = SSLSetAllowsExpiredRoots(sslContext, allowsExpiredRoots); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetAllowsExpiredRoots"]]; + return; + } + } + + // 4. kCFStreamSSLValidatesCertificateChain + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLValidatesCertificateChain]; + if (value) + { + BOOL validatesCertChain = [value boolValue]; + + status = SSLSetEnableCertVerify(sslContext, validatesCertChain); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetEnableCertVerify"]]; + return; + } + } + + // 5. kCFStreamSSLAllowsExpiredCertificates + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLAllowsExpiredCertificates]; + if (value) + { + BOOL allowsExpiredCerts = [value boolValue]; + + status = SSLSetAllowsExpiredCerts(sslContext, allowsExpiredCerts); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetAllowsExpiredCerts"]]; + return; + } + } + + // 6. kCFStreamSSLCertificates + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLCertificates]; + if (value) + { + CFArrayRef certs = (CFArrayRef)value; + + status = SSLSetCertificate(sslContext, certs); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetCertificate"]]; + return; + } + } + + // 7. kCFStreamSSLLevel + + value = [tlsSettings objectForKey:(NSString *)kCFStreamSSLLevel]; + if (value) + { + NSString *sslLevel = (NSString *)value; + + if ([sslLevel isEqualToString:(NSString *)kCFStreamSocketSecurityLevelSSLv2]) + { + // kCFStreamSocketSecurityLevelSSLv2: + // + // Specifies that SSL version 2 be set as the security protocol. + + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocolAll, NO); + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocol2, YES); + } + else if ([sslLevel isEqualToString:(NSString *)kCFStreamSocketSecurityLevelSSLv3]) + { + // kCFStreamSocketSecurityLevelSSLv3: + // + // Specifies that SSL version 3 be set as the security protocol. + // If SSL version 3 is not available, specifies that SSL version 2 be set as the security protocol. + + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocolAll, NO); + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocol2, YES); + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocol3, YES); + } + else if ([sslLevel isEqualToString:(NSString *)kCFStreamSocketSecurityLevelTLSv1]) + { + // kCFStreamSocketSecurityLevelTLSv1: + // + // Specifies that TLS version 1 be set as the security protocol. + + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocolAll, NO); + SSLSetProtocolVersionEnabled(sslContext, kTLSProtocol1, YES); + } + else if ([sslLevel isEqualToString:(NSString *)kCFStreamSocketSecurityLevelNegotiatedSSL]) + { + // kCFStreamSocketSecurityLevelNegotiatedSSL: + // + // Specifies that the highest level security protocol that can be negotiated be used. + + SSLSetProtocolVersionEnabled(sslContext, kSSLProtocolAll, YES); + } + } + + // 8. GCDAsyncSocketSSLCipherSuites + + value = [tlsSettings objectForKey:GCDAsyncSocketSSLCipherSuites]; + if (value) + { + NSArray *cipherSuites = (NSArray *)value; + NSUInteger numberCiphers = [cipherSuites count]; + SSLCipherSuite ciphers[numberCiphers]; + + NSUInteger cipherIndex; + for (cipherIndex = 0; cipherIndex < numberCiphers; cipherIndex++) + { + NSNumber *cipherObject = [cipherSuites objectAtIndex:cipherIndex]; + ciphers[cipherIndex] = [cipherObject shortValue]; + } + + status = SSLSetEnabledCiphers(sslContext, ciphers, numberCiphers); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetEnabledCiphers"]]; + return; + } + } + + // 9. GCDAsyncSocketSSLDiffieHellmanParameters + + value = [tlsSettings objectForKey:GCDAsyncSocketSSLDiffieHellmanParameters]; + if (value) + { + NSData *diffieHellmanData = (NSData *)value; + + status = SSLSetDiffieHellmanParams(sslContext, [diffieHellmanData bytes], [diffieHellmanData length]); + if (status != noErr) + { + [self closeWithError:[self otherError:@"Error in SSLSetDiffieHellmanParams"]]; + return; + } + } + + // Setup the sslReadBuffer + // + // If there is any data in the partialReadBuffer, + // this needs to be moved into the sslReadBuffer, + // as this data is now part of the secure read stream. + + sslReadBuffer = [[NSMutableData alloc] init]; + + if ([partialReadBuffer length] > 0) + { + [sslReadBuffer appendData:partialReadBuffer]; + [partialReadBuffer setLength:0]; + } + + // Start the SSL Handshake process + + [self continueSSLHandshake]; + } +} + +- (void)continueSSLHandshake +{ + LogTrace(); + + // If the return value is noErr, the session is ready for normal secure communication. + // If the return value is errSSLWouldBlock, the SSLHandshake function must be called again. + // Otherwise, the return value indicates an error code. + + OSStatus status = SSLHandshake(sslContext); + + if (status == noErr) + { + LogVerbose(@"SSLHandshake complete"); + + flags &= ~kStartingReadTLS; + flags &= ~kStartingWriteTLS; + + flags |= kSocketSecure; + + if (delegateQueue && [delegate respondsToSelector:@selector(socketDidSecure:)]) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socketDidSecure:self]; + + [pool drain]; + }); + } + + [self endCurrentRead]; + [self endCurrentWrite]; + + [self maybeDequeueRead]; + [self maybeDequeueWrite]; + } + else if (status == errSSLWouldBlock) + { + LogVerbose(@"SSLHandshake continues..."); + + // Handshake continues... + // + // This method will be called again from doReadData or doWriteData. + } + else + { + [self closeWithError:[self sslError:status]]; + } +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Security - iOS +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if TARGET_OS_IPHONE + ++ (void)startHandshakeThreadIfNeeded +{ + static dispatch_once_t predicate; + + dispatch_once(&predicate, ^{ + + sslHandshakeThread = [[NSThread alloc] initWithTarget:self + selector:@selector(sslHandshakeThread) + object:nil]; + [sslHandshakeThread start]; + }); +} + ++ (void)sslHandshakeThread +{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + LogInfo(@"SSLHandshakeThread: Started"); + + // We can't run the run loop unless it has an associated input source or a timer. + // So we'll just create a timer that will never fire - unless the server runs for 10,000 years. + [NSTimer scheduledTimerWithTimeInterval:DBL_MAX target:self selector:@selector(ignore:) userInfo:nil repeats:NO]; + + [[NSRunLoop currentRunLoop] run]; + + LogInfo(@"SSLHandshakeThread: Stopped"); + + [pool release]; +} + ++ (void)addHandshakeListener:(GCDAsyncSocket *)asyncSocket +{ + LogTrace(); + + CFRunLoopRef runLoop = CFRunLoopGetCurrent(); + + if (asyncSocket->readStream) + CFReadStreamScheduleWithRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode); + + if (asyncSocket->writeStream) + CFWriteStreamScheduleWithRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode); +} + ++ (void)removeHandshakeListener:(GCDAsyncSocket *)asyncSocket +{ + LogTrace(); + + CFRunLoopRef runLoop = CFRunLoopGetCurrent(); + + if (asyncSocket->readStream) + CFReadStreamUnscheduleFromRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode); + + if (asyncSocket->writeStream) + CFWriteStreamUnscheduleFromRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode); +} + +- (void)finishSSLHandshake +{ + LogTrace(); + + if ((flags & kStartingReadTLS) && (flags & kStartingWriteTLS)) + { + flags &= ~kStartingReadTLS; + flags &= ~kStartingWriteTLS; + + flags |= kSocketSecure; + + if (delegateQueue && [delegate respondsToSelector:@selector(socketDidSecure:)]) + { + id theDelegate = delegate; + + dispatch_async(delegateQueue, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [theDelegate socketDidSecure:self]; + + [pool release]; + }); + } + + [self endCurrentRead]; + [self endCurrentWrite]; + + [self maybeDequeueRead]; + [self maybeDequeueWrite]; + } +} + +- (void)abortSSLHandshake:(NSError *)error +{ + LogTrace(); + + if ((flags & kStartingReadTLS) && (flags & kStartingWriteTLS)) + { + flags &= ~kStartingReadTLS; + flags &= ~kStartingWriteTLS; + + [self closeWithError:error]; + } +} + +static void CFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo) +{ + GCDAsyncSocket *asyncSocket = [(GCDAsyncSocket *)pInfo retain]; + + switch(type) + { + case kCFStreamEventHasBytesAvailable: + { + dispatch_async(asyncSocket->socketQueue, ^{ + + LogCVerbose(@"CFReadStreamCallback - HasBytesAvailable"); + + if (asyncSocket->readStream != stream) + return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ((asyncSocket->flags & kStartingReadTLS) && (asyncSocket->flags & kStartingWriteTLS)) + { + asyncSocket->flags |= kSecureSocketHasBytesAvailable; + [asyncSocket finishSSLHandshake]; + } + else + { + asyncSocket->flags |= kSecureSocketHasBytesAvailable; + [asyncSocket doReadData]; + } + + [pool release]; + }); + + break; + } + default: + { + NSError *error = NSMakeCollectable(CFReadStreamCopyError(stream)); + + dispatch_async(asyncSocket->socketQueue, ^{ + + LogCVerbose(@"CFReadStreamCallback - Other"); + + if (asyncSocket->readStream != stream) + return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ((asyncSocket->flags & kStartingReadTLS) && (asyncSocket->flags & kStartingWriteTLS)) + { + [asyncSocket abortSSLHandshake:error]; + } + else + { + [asyncSocket closeWithError:error]; + } + + [pool release]; + }); + + [error release]; + break; + } + } + + [asyncSocket release]; +} + +static void CFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo) +{ + GCDAsyncSocket *asyncSocket = [(GCDAsyncSocket *)pInfo retain]; + + switch(type) + { + case kCFStreamEventCanAcceptBytes: + { + dispatch_async(asyncSocket->socketQueue, ^{ + + LogCVerbose(@"CFWriteStreamCallback - CanAcceptBytes"); + + if (asyncSocket->writeStream != stream) + return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ((asyncSocket->flags & kStartingReadTLS) && (asyncSocket->flags & kStartingWriteTLS)) + { + asyncSocket->flags |= kSocketCanAcceptBytes; + [asyncSocket finishSSLHandshake]; + } + else + { + asyncSocket->flags |= kSocketCanAcceptBytes; + [asyncSocket doWriteData]; + } + + [pool release]; + }); + + break; + } + default: + { + NSError *error = NSMakeCollectable(CFWriteStreamCopyError(stream)); + + dispatch_async(asyncSocket->socketQueue, ^{ + + LogCVerbose(@"CFWriteStreamCallback - Other"); + + if (asyncSocket->writeStream != stream) + return_from_block; + + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if ((asyncSocket->flags & kStartingReadTLS) && (asyncSocket->flags & kStartingWriteTLS)) + { + [asyncSocket abortSSLHandshake:error]; + } + else + { + [asyncSocket closeWithError:error]; + } + + [pool release]; + }); + + [error release]; + break; + } + } + + [asyncSocket release]; +} + +- (BOOL)createReadAndWriteStream +{ + NSAssert((readStream == NULL && writeStream == NULL), @"Read/Write stream not null"); + + int socketFD = (socket6FD == SOCKET_NULL) ? socket4FD : socket6FD; + + if (socketFD == SOCKET_NULL) + { + return NO; + } + + LogVerbose(@"Creating read and write stream..."); + + CFStreamCreatePairWithSocket(NULL, (CFSocketNativeHandle)socketFD, &readStream, &writeStream); + + // The kCFStreamPropertyShouldCloseNativeSocket property should be false by default (for our case). + // But let's not take any chances. + + if (readStream) + CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse); + if (writeStream) + CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse); + + if ((readStream == NULL) || (writeStream == NULL)) + { + LogWarn(@"Unable to create read and write stream..."); + + if (readStream) + { + CFReadStreamClose(readStream); + CFRelease(readStream); + readStream = NULL; + } + if (writeStream) + { + CFWriteStreamClose(writeStream); + CFRelease(writeStream); + writeStream = NULL; + } + + return NO; + } + + return YES; +} + +- (void)maybeStartTLS +{ + LogTrace(); + + // We can't start TLS until: + // - All queued reads prior to the user calling startTLS are complete + // - All queued writes prior to the user calling startTLS are complete + // + // We'll know these conditions are met when both kStartingReadTLS and kStartingWriteTLS are set + + if ((flags & kStartingReadTLS) && (flags & kStartingWriteTLS)) + { + LogVerbose(@"Starting TLS..."); + + if ([partialReadBuffer length] > 0) + { + NSString *msg = @"Invalid TLS transition. Handshake has already been read from socket."; + + [self closeWithError:[self otherError:msg]]; + return; + } + + [self suspendReadSource]; + [self suspendWriteSource]; + + socketFDBytesAvailable = 0; + flags &= ~kSocketCanAcceptBytes; + flags &= ~kSecureSocketHasBytesAvailable; + + if (readStream == NULL || writeStream == NULL) + { + if (![self createReadAndWriteStream]) + { + [self closeWithError:[self otherError:@"Error in CFStreamCreatePairWithSocket"]]; + return; + } + } + + streamContext.version = 0; + streamContext.info = self; + streamContext.retain = nil; + streamContext.release = nil; + streamContext.copyDescription = nil; + + CFOptionFlags readStreamEvents = kCFStreamEventHasBytesAvailable | + kCFStreamEventErrorOccurred | + kCFStreamEventEndEncountered ; + + if (!CFReadStreamSetClient(readStream, readStreamEvents, &CFReadStreamCallback, &streamContext)) + { + [self closeWithError:[self otherError:@"Error in CFReadStreamSetClient"]]; + return; + } + + CFOptionFlags writeStreamEvents = kCFStreamEventCanAcceptBytes | + kCFStreamEventErrorOccurred | + kCFStreamEventEndEncountered ; + + if (!CFWriteStreamSetClient(writeStream, writeStreamEvents, &CFWriteStreamCallback, &streamContext)) + { + [self closeWithError:[self otherError:@"Error in CFWriteStreamSetClient"]]; + return; + } + + [[self class] startHandshakeThreadIfNeeded]; + [[self class] performSelector:@selector(addHandshakeListener:) + onThread:sslHandshakeThread + withObject:self + waitUntilDone:YES]; + + flags |= kAddedHandshakeListener; + + NSAssert([currentRead isKindOfClass:[GCDAsyncSpecialPacket class]], @"Invalid read packet for startTLS"); + NSAssert([currentWrite isKindOfClass:[GCDAsyncSpecialPacket class]], @"Invalid write packet for startTLS"); + + GCDAsyncSpecialPacket *tlsPacket = (GCDAsyncSpecialPacket *)currentRead; + NSDictionary *tlsSettings = tlsPacket->tlsSettings; + + // Getting an error concerning kCFStreamPropertySSLSettings ? + // You need to add the CFNetwork framework to your iOS application. + + BOOL r1 = CFReadStreamSetProperty(readStream, kCFStreamPropertySSLSettings, (CFDictionaryRef)tlsSettings); + BOOL r2 = CFWriteStreamSetProperty(writeStream, kCFStreamPropertySSLSettings, (CFDictionaryRef)tlsSettings); + + // For some reason, starting around the time of iOS 4.3, + // the first call to set the kCFStreamPropertySSLSettings will return true, + // but the second will return false. + // + // Order doesn't seem to matter. + // So you could call CFReadStreamSetProperty and then CFWriteStreamSetProperty, or you could reverse the order. + // Either way, the first call will return true, and the second returns false. + // + // Interestingly, this doesn't seem to affect anything. + // Which is not altogether unusual, as the documentation seems to suggest that (for many settings) + // setting it on one side of the stream automatically sets it for the other side of the stream. + // + // Although there isn't anything in the documentation to suggest that the second attempt would fail. + // + // Furthermore, this only seems to affect streams that are negotiating a security upgrade. + // In other words, the socket gets connected, there is some back-and-forth communication over the unsecure + // connection, and then a startTLS is issued. + // So this mostly affects newer protocols (XMPP, IMAP) as opposed to older protocols (HTTPS). + + if (!r1 && !r2) // Yes, the && is correct - workaround for apple bug. + { + [self closeWithError:[self otherError:@"Error in CFStreamSetProperty"]]; + return; + } + + CFStreamStatus readStatus = CFReadStreamGetStatus(readStream); + CFStreamStatus writeStatus = CFWriteStreamGetStatus(writeStream); + + if ((readStatus == kCFStreamStatusNotOpen) || (writeStatus == kCFStreamStatusNotOpen)) + { + r1 = CFReadStreamOpen(readStream); + r2 = CFWriteStreamOpen(writeStream); + + if (!r1 || !r2) + { + [self closeWithError:[self otherError:@"Error in CFStreamOpen"]]; + } + } + + LogVerbose(@"Waiting for SSL Handshake to complete..."); + } +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Advanced +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)performBlock:(dispatch_block_t)block +{ + dispatch_sync(socketQueue, block); +} + +- (int)socketFD +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (socket4FD != SOCKET_NULL) + return socket4FD; + else + return socket6FD; + } + else + { + return SOCKET_NULL; + } +} + +- (int)socket4FD +{ + if (dispatch_get_current_queue() == socketQueue) + return socket4FD; + else + return SOCKET_NULL; +} + +- (int)socket6FD +{ + if (dispatch_get_current_queue() == socketQueue) + return socket6FD; + else + return SOCKET_NULL; +} + +#if TARGET_OS_IPHONE + +- (CFReadStreamRef)readStream +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (readStream == NULL) + [self createReadAndWriteStream]; + + return readStream; + } + else + { + return NULL; + } +} + +- (CFWriteStreamRef)writeStream +{ + if (dispatch_get_current_queue() == socketQueue) + { + if (writeStream == NULL) + [self createReadAndWriteStream]; + + return writeStream; + } + else + { + return NULL; + } +} + +- (BOOL)enableBackgroundingOnSocketWithCaveat:(BOOL)caveat +{ + if (readStream == NULL || writeStream == NULL) + { + if (![self createReadAndWriteStream]) + { + // Error occured creating streams (perhaps socket isn't open) + return NO; + } + } + + BOOL r1, r2; + + LogVerbose(@"Enabling backgrouding on socket"); + + r1 = CFReadStreamSetProperty(readStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP); + r2 = CFWriteStreamSetProperty(writeStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP); + + if (!r1 || !r2) + { + LogError(@"Error setting voip type"); + return NO; + } + + if (!caveat) + { + CFStreamStatus readStatus = CFReadStreamGetStatus(readStream); + CFStreamStatus writeStatus = CFWriteStreamGetStatus(writeStream); + + if ((readStatus == kCFStreamStatusNotOpen) || (writeStatus == kCFStreamStatusNotOpen)) + { + r1 = CFReadStreamOpen(readStream); + r2 = CFWriteStreamOpen(writeStream); + + if (!r1 || !r2) + { + LogError(@"Error opening bg streams"); + return NO; + } + } + } + + return YES; +} + +- (BOOL)enableBackgroundingOnSocket +{ + LogTrace(); + + if (dispatch_get_current_queue() == socketQueue) + { + return [self enableBackgroundingOnSocketWithCaveat:NO]; + } + else + { + return NO; + } +} + +- (BOOL)enableBackgroundingOnSocketWithCaveat +{ + LogTrace(); + + if (dispatch_get_current_queue() == socketQueue) + { + return [self enableBackgroundingOnSocketWithCaveat:YES]; + } + else + { + return NO; + } +} + +#else + +- (SSLContextRef)sslContext +{ + if (dispatch_get_current_queue() == socketQueue) + return sslContext; + else + return NULL; +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Class Methods +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (NSString *)hostFromAddress4:(struct sockaddr_in *)pSockaddr4 +{ + char addrBuf[INET_ADDRSTRLEN]; + + if (inet_ntop(AF_INET, &pSockaddr4->sin_addr, addrBuf, (socklen_t)sizeof(addrBuf)) == NULL) + { + addrBuf[0] = '\0'; + } + + return [NSString stringWithCString:addrBuf encoding:NSASCIIStringEncoding]; +} + ++ (NSString *)hostFromAddress6:(struct sockaddr_in6 *)pSockaddr6 +{ + char addrBuf[INET6_ADDRSTRLEN]; + + if (inet_ntop(AF_INET6, &pSockaddr6->sin6_addr, addrBuf, (socklen_t)sizeof(addrBuf)) == NULL) + { + addrBuf[0] = '\0'; + } + + return [NSString stringWithCString:addrBuf encoding:NSASCIIStringEncoding]; +} + ++ (UInt16)portFromAddress4:(struct sockaddr_in *)pSockaddr4 +{ + return ntohs(pSockaddr4->sin_port); +} + ++ (UInt16)portFromAddress6:(struct sockaddr_in6 *)pSockaddr6 +{ + return ntohs(pSockaddr6->sin6_port); +} + ++ (NSString *)hostFromAddress:(NSData *)address +{ + NSString *host; + + if ([self getHost:&host port:NULL fromAddress:address]) + return host; + else + return nil; +} + ++ (UInt16)portFromAddress:(NSData *)address +{ + UInt16 port; + + if ([self getHost:NULL port:&port fromAddress:address]) + return port; + else + return 0; +} + ++ (BOOL)getHost:(NSString **)hostPtr port:(UInt16 *)portPtr fromAddress:(NSData *)address +{ + if ([address length] >= sizeof(struct sockaddr)) + { + struct sockaddr *addrX = (struct sockaddr *)[address bytes]; + + if (addrX->sa_family == AF_INET) + { + if ([address length] >= sizeof(struct sockaddr_in)) + { + struct sockaddr_in *addr4 = (struct sockaddr_in *)addrX; + + if (hostPtr) *hostPtr = [self hostFromAddress4:addr4]; + if (portPtr) *portPtr = [self portFromAddress4:addr4]; + + return YES; + } + } + else if (addrX->sa_family == AF_INET6) + { + if ([address length] >= sizeof(struct sockaddr_in6)) + { + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addrX; + + if (hostPtr) *hostPtr = [self hostFromAddress6:addr6]; + if (portPtr) *portPtr = [self portFromAddress6:addr6]; + + return YES; + } + } + } + + return NO; +} + ++ (NSData *)CRLFData +{ + return [NSData dataWithBytes:"\x0D\x0A" length:2]; +} + ++ (NSData *)CRData +{ + return [NSData dataWithBytes:"\x0D" length:1]; +} + ++ (NSData *)LFData +{ + return [NSData dataWithBytes:"\x0A" length:1]; +} + ++ (NSData *)ZeroData +{ + return [NSData dataWithBytes:"" length:1]; +} + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDASLLogger.h b/xmpp/Vendor/CocoaLumberjack/DDASLLogger.h new file mode 100755 index 0000000..eec4bb2 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDASLLogger.h @@ -0,0 +1,41 @@ +#import +#import + +#import "DDLog.h" + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * + * + * This class provides a logger for the Apple System Log facility. + * + * As described in the "Getting Started" page, + * the traditional NSLog() function directs it's output to two places: + * + * - Apple System Log + * - StdErr (if stderr is a TTY) so log statements show up in Xcode console + * + * To duplicate NSLog() functionality you can simply add this logger and a tty logger. + * However, if you instead choose to use file logging (for faster performance), + * you may choose to use a file logger and a tty logger. +**/ + +@interface DDASLLogger : DDAbstractLogger +{ + aslclient client; +} + ++ (DDASLLogger *)sharedInstance; + +// Inherited from DDAbstractLogger + +// - (id )logFormatter; +// - (void)setLogFormatter:(id )formatter; + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDASLLogger.m b/xmpp/Vendor/CocoaLumberjack/DDASLLogger.m new file mode 100755 index 0000000..d88f192 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDASLLogger.m @@ -0,0 +1,86 @@ +#import "DDASLLogger.h" + +#import + + +@implementation DDASLLogger + +static DDASLLogger *sharedInstance; + +/** + * The runtime sends initialize to each class in a program exactly one time just before the class, + * or any class that inherits from it, is sent its first message from within the program. (Thus the + * method may never be invoked if the class is not used.) The runtime sends the initialize message to + * classes in a thread-safe manner. Superclasses receive this message before their subclasses. + * + * This method may also be called directly (assumably by accident), hence the safety mechanism. +**/ ++ (void)initialize +{ + static BOOL initialized = NO; + if (!initialized) + { + initialized = YES; + + sharedInstance = [[DDASLLogger alloc] init]; + } +} + ++ (DDASLLogger *)sharedInstance +{ + return sharedInstance; +} + +- (id)init +{ + if (sharedInstance != nil) + { + [self release]; + return nil; + } + + if ((self = [super init])) + { + // A default asl client is provided for the main thread, + // but background threads need to create their own client. + + client = asl_open(NULL, "com.apple.console", 0); + } + return self; +} + +- (void)logMessage:(DDLogMessage *)logMessage +{ + NSString *logMsg = logMessage->logMsg; + + if (formatter) + { + logMsg = [formatter formatLogMessage:logMessage]; + } + + if (logMsg) + { + const char *msg = [logMsg UTF8String]; + + int aslLogLevel; + switch (logMessage->logLevel) + { + // Note: By default ASL will filter anything above level 5 (Notice). + // So our mappings shouldn't go above that level. + + case 1 : aslLogLevel = ASL_LEVEL_CRIT; break; + case 2 : aslLogLevel = ASL_LEVEL_ERR; break; + case 3 : aslLogLevel = ASL_LEVEL_WARNING; break; + default : aslLogLevel = ASL_LEVEL_NOTICE; break; + } + + asl_log(client, NULL, aslLogLevel, "%s", msg); + } +} + +- (NSString *)loggerName +{ + return @"cocoa.lumberjack.aslLogger"; +} + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.h b/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.h new file mode 100644 index 0000000..07b6620 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.h @@ -0,0 +1,102 @@ +#import + +#import "DDLog.h" + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * + * + * This class provides an abstract implementation of a database logger. + * + * That is, it provides the base implementation for a database logger to build atop of. + * All that is needed for a concrete database logger is to extend this class + * and override the methods in the implementation file that are prefixed with "db_". +**/ + +@interface DDAbstractDatabaseLogger : DDAbstractLogger { +@protected + NSUInteger saveThreshold; + NSTimeInterval saveInterval; + NSTimeInterval maxAge; + NSTimeInterval deleteInterval; + BOOL deleteOnEverySave; + + BOOL saveTimerSuspended; + NSUInteger unsavedCount; + dispatch_time_t unsavedTime; + dispatch_source_t saveTimer; + dispatch_time_t lastDeleteTime; + dispatch_source_t deleteTimer; +} + +/** + * Specifies how often to save the data to disk. + * Since saving is an expensive operation (disk io) it is not done after every log statement. + * These properties allow you to configure how/when the logger saves to disk. + * + * A save is done when either (whichever happens first): + * + * - The number of unsaved log entries reaches saveThreshold + * - The amount of time since the oldest unsaved log entry was created reaches saveInterval + * + * You can optionally disable the saveThreshold by setting it to zero. + * If you disable the saveThreshold you are entirely dependent on the saveInterval. + * + * You can optionally disable the saveInterval by setting it to zero (or a negative value). + * If you disable the saveInterval you are entirely dependent on the saveThreshold. + * + * It's not wise to disable both saveThreshold and saveInterval. + * + * The default saveThreshold is 500. + * The default saveInterval is 60 seconds. +**/ +@property (assign, readwrite) NSUInteger saveThreshold; +@property (assign, readwrite) NSTimeInterval saveInterval; + +/** + * It is likely you don't want the log entries to persist forever. + * Doing so would allow the database to grow infinitely large over time. + * + * The maxAge property provides a way to specify how old a log statement can get + * before it should get deleted from the database. + * + * The deleteInterval specifies how often to sweep for old log entries. + * Since deleting is an expensive operation (disk io) is is done on a fixed interval. + * + * An alternative to the deleteInterval is the deleteOnEverySave option. + * This specifies that old log entries should be deleted during every save operation. + * + * You can optionally disable the maxAge by setting it to zero (or a negative value). + * If you disable the maxAge then old log statements are not deleted. + * + * You can optionally disable the deleteInterval by setting it to zero (or a negative value). + * + * If you disable both deleteInterval and deleteOnEverySave then old log statements are not deleted. + * + * It's not wise to enable both deleteInterval and deleteOnEverySave. + * + * The default maxAge is 7 days. + * The default deleteInterval is 5 minutes. + * The default deleteOnEverySave is NO. +**/ +@property (assign, readwrite) NSTimeInterval maxAge; +@property (assign, readwrite) NSTimeInterval deleteInterval; +@property (assign, readwrite) BOOL deleteOnEverySave; + +/** + * Forces a save of any pending log entries (flushes log entries to disk). +**/ +- (void)savePendingLogEntries; + +/** + * Removes any log entries that are older than maxAge. +**/ +- (void)deleteOldLogEntries; + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.m b/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.m new file mode 100644 index 0000000..3e34d4e --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDAbstractDatabaseLogger.m @@ -0,0 +1,608 @@ +#import "DDAbstractDatabaseLogger.h" + +@interface DDAbstractDatabaseLogger () +- (void)destroySaveTimer; +- (void)destroyDeleteTimer; +@end + +#pragma mark - + +@implementation DDAbstractDatabaseLogger + +- (id)init +{ + if ((self = [super init])) + { + saveThreshold = 500; + saveInterval = 60; // 60 seconds + maxAge = (60 * 60 * 24 * 7); // 7 days + deleteInterval = (60 * 5); // 5 minutes + } + return self; +} + +- (void)dealloc +{ + [self destroySaveTimer]; + [self destroyDeleteTimer]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Override Me +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)db_log:(DDLogMessage *)logMessage +{ + // Override me and add your implementation. + // + // Return YES if an item was added to the buffer. + // Return NO if the logMessage was ignored. + + return NO; +} + +- (void)db_save +{ + // Override me and add your implementation. +} + +- (void)db_delete +{ + // Override me and add your implementation. +} + +- (void)db_saveAndDelete +{ + // Override me and add your implementation. +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Private API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)performSaveAndSuspendSaveTimer +{ + if (unsavedCount > 0) + { + if (deleteOnEverySave) + [self db_saveAndDelete]; + else + [self db_save]; + } + + unsavedCount = 0; + unsavedTime = 0; + + if (saveTimer && !saveTimerSuspended) + { + dispatch_suspend(saveTimer); + saveTimerSuspended = YES; + } +} + +- (void)performDelete +{ + if (maxAge > 0.0) + { + [self db_delete]; + + lastDeleteTime = dispatch_time(DISPATCH_TIME_NOW, 0); + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Timers +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)destroySaveTimer +{ + if (saveTimer) + { + dispatch_source_cancel(saveTimer); + dispatch_release(saveTimer); + saveTimer = NULL; + } +} + +- (void)updateAndResumeSaveTimer +{ + if ((saveTimer != NULL) && (saveInterval > 0.0) && (unsavedTime > 0.0)) + { + uint64_t interval = saveInterval * NSEC_PER_SEC; + dispatch_time_t startTime = dispatch_time(unsavedTime, interval); + + dispatch_source_set_timer(saveTimer, startTime, interval, 1.0); + + if (saveTimerSuspended) + { + dispatch_resume(saveTimer); + saveTimerSuspended = NO; + } + } +} + +- (void)createSuspendedSaveTimer +{ + if ((saveTimer == NULL) && (saveInterval > 0.0)) + { + saveTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue); + + dispatch_source_set_event_handler(saveTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performSaveAndSuspendSaveTimer]; + + [pool drain]; + }); + + saveTimerSuspended = YES; + } +} + +- (void)destroyDeleteTimer +{ + if (deleteTimer) + { + dispatch_source_cancel(deleteTimer); + dispatch_release(deleteTimer); + deleteTimer = NULL; + } +} + +- (void)updateDeleteTimer +{ + if ((deleteTimer != NULL) && (deleteInterval > 0.0) && (maxAge > 0.0)) + { + uint64_t interval = deleteInterval * NSEC_PER_SEC; + dispatch_time_t startTime; + + if (lastDeleteTime > 0) + startTime = dispatch_time(lastDeleteTime, interval); + else + startTime = dispatch_time(DISPATCH_TIME_NOW, interval); + + dispatch_source_set_timer(deleteTimer, startTime, interval, 1.0); + } +} + +- (void)createAndStartDeleteTimer +{ + if ((deleteTimer == NULL) && (deleteInterval > 0.0) && (maxAge > 0.0)) + { + deleteTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, loggerQueue); + + dispatch_source_set_event_handler(deleteTimer, ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performDelete]; + + [pool drain]; + }); + + [self updateDeleteTimer]; + + dispatch_resume(deleteTimer); + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSUInteger)saveThreshold +{ + if (dispatch_get_current_queue() == loggerQueue) + { + return saveThreshold; + } + else + { + __block NSUInteger result; + + dispatch_sync(loggerQueue, ^{ + result = saveThreshold; + }); + + return result; + } +} + +- (void)setSaveThreshold:(NSUInteger)threshold +{ + dispatch_block_t block = ^{ + + if (saveThreshold != threshold) + { + saveThreshold = threshold; + + // Since the saveThreshold has changed, + // we check to see if the current unsavedCount has surpassed the new threshold. + // + // If it has, we immediately save the log. + + if ((unsavedCount >= saveThreshold) && (saveThreshold > 0)) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performSaveAndSuspendSaveTimer]; + + [pool drain]; + } + } + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +- (NSTimeInterval)saveInterval +{ + if (dispatch_get_current_queue() == loggerQueue) + { + return saveInterval; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(loggerQueue, ^{ + result = saveInterval; + }); + + return result; + } +} + +- (void)setSaveInterval:(NSTimeInterval)interval +{ + dispatch_block_t block = ^{ + + if (saveInterval != interval) + { + saveInterval = interval; + + // There are several cases we need to handle here. + // + // 1. If the saveInterval was previously enabled and it just got disabled, + // then we need to stop the saveTimer. (And we might as well release it.) + // + // 2. If the saveInterval was previously disabled and it just got enabled, + // then we need to setup the saveTimer. (Plus we might need to do an immediate save.) + // + // 3. If the saveInterval increased, then we need to reset the timer so that it fires at the later date. + // + // 4. If the saveInterval decreased, then we need to reset the timer so that it fires at an earlier date. + // (Plus we might need to do an immediate save.) + + if (saveInterval > 0.0) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (saveTimer == NULL) + { + // Handles #2 + // + // Since the saveTimer uses the unsavedTime to calculate it's first fireDate, + // if a save is needed the timer will fire immediately. + + [self createSuspendedSaveTimer]; + [self updateAndResumeSaveTimer]; + } + else + { + // Handles #3 + // Handles #4 + // + // Since the saveTimer uses the unsavedTime to calculate it's first fireDate, + // if a save is needed the timer will fire immediately. + + [self updateAndResumeSaveTimer]; + } + + [pool drain]; + } + else if (saveTimer) + { + // Handles #1 + + [self destroySaveTimer]; + } + } + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +- (NSTimeInterval)maxAge +{ + if (dispatch_get_current_queue() == loggerQueue) + { + return maxAge; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(loggerQueue, ^{ + result = maxAge; + }); + + return result; + } +} + +- (void)setMaxAge:(NSTimeInterval)interval +{ + dispatch_block_t block = ^{ + + if (maxAge != interval) + { + NSTimeInterval oldMaxAge = maxAge; + NSTimeInterval newMaxAge = interval; + + maxAge = interval; + + // There are several cases we need to handle here. + // + // 1. If the maxAge was previously enabled and it just got disabled, + // then we need to stop the deleteTimer. (And we might as well release it.) + // + // 2. If the maxAge was previously disabled and it just got enabled, + // then we need to setup the deleteTimer. (Plus we might need to do an immediate delete.) + // + // 3. If the maxAge was increased, + // then we don't need to do anything. + // + // 4. If the maxAge was decreased, + // then we should do an immediate delete. + + BOOL shouldDeleteNow = NO; + + if (oldMaxAge > 0.0) + { + if (newMaxAge <= 0.0) + { + // Handles #1 + + [self destroyDeleteTimer]; + } + else if (oldMaxAge > newMaxAge) + { + // Handles #4 + shouldDeleteNow = YES; + } + } + else if (newMaxAge > 0.0) + { + // Handles #2 + shouldDeleteNow = YES; + } + + if (shouldDeleteNow) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performDelete]; + + if (deleteTimer) + [self updateDeleteTimer]; + else + [self createAndStartDeleteTimer]; + + [pool drain]; + } + } + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +- (NSTimeInterval)deleteInterval +{ + if (dispatch_get_current_queue() == loggerQueue) + { + return deleteInterval; + } + else + { + __block NSTimeInterval result; + + dispatch_sync(loggerQueue, ^{ + result = deleteInterval; + }); + + return result; + } +} + +- (void)setDeleteInterval:(NSTimeInterval)interval +{ + dispatch_block_t block = ^{ + + if (deleteInterval != interval) + { + deleteInterval = interval; + + // There are several cases we need to handle here. + // + // 1. If the deleteInterval was previously enabled and it just got disabled, + // then we need to stop the deleteTimer. (And we might as well release it.) + // + // 2. If the deleteInterval was previously disabled and it just got enabled, + // then we need to setup the deleteTimer. (Plus we might need to do an immediate delete.) + // + // 3. If the deleteInterval increased, then we need to reset the timer so that it fires at the later date. + // + // 4. If the deleteInterval decreased, then we need to reset the timer so that it fires at an earlier date. + // (Plus we might need to do an immediate delete.) + + if (deleteInterval > 0.0) + { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + if (deleteTimer == NULL) + { + // Handles #2 + // + // Since the deleteTimer uses the lastDeleteTime to calculate it's first fireDate, + // if a delete is needed the timer will fire immediately. + + [self createAndStartDeleteTimer]; + } + else + { + // Handles #3 + // Handles #4 + // + // Since the deleteTimer uses the lastDeleteTime to calculate it's first fireDate, + // if a save is needed the timer will fire immediately. + + [self updateDeleteTimer]; + } + + [pool drain]; + } + else if (deleteTimer) + { + // Handles #1 + + [self destroyDeleteTimer]; + } + } + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +- (BOOL)deleteOnEverySave +{ + if (dispatch_get_current_queue() == loggerQueue) + { + return deleteOnEverySave; + } + else + { + __block BOOL result; + + dispatch_sync(loggerQueue, ^{ + result = deleteOnEverySave; + }); + + return result; + } +} + +- (void)setDeleteOnEverySave:(BOOL)flag +{ + dispatch_block_t block = ^{ + + deleteOnEverySave = flag; + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Public API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)savePendingLogEntries +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performSaveAndSuspendSaveTimer]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +- (void)deleteOldLogEntries +{ + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self performDelete]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async(loggerQueue, block); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark DDLogger +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)didAddLogger +{ + // If you override me be sure to invoke [super didAddLogger]; + + [self createSuspendedSaveTimer]; + + [self createAndStartDeleteTimer]; +} + +- (void)willRemoveLogger +{ + // If you override me be sure to invoke [super willRemoveLogger]; + + [self performSaveAndSuspendSaveTimer]; + + [self destroySaveTimer]; + [self destroyDeleteTimer]; +} + +- (void)logMessage:(DDLogMessage *)logMessage +{ + if ([self db_log:logMessage]) + { + BOOL firstUnsavedEntry = (++unsavedCount == 1); + + if ((unsavedCount >= saveThreshold) && (saveThreshold > 0)) + { + [self performSaveAndSuspendSaveTimer]; + } + else if (firstUnsavedEntry) + { + unsavedTime = dispatch_time(DISPATCH_TIME_NOW, 0); + [self updateAndResumeSaveTimer]; + } + } +} + +- (void)flush +{ + // This method is invoked by DDLog's flushLog method. + // + // It is called automatically when the application quits, + // or if the developer invokes DDLog's flushLog method prior to crashing or something. + + [self performSaveAndSuspendSaveTimer]; +} + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDFileLogger.h b/xmpp/Vendor/CocoaLumberjack/DDFileLogger.h new file mode 100644 index 0000000..482152e --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDFileLogger.h @@ -0,0 +1,293 @@ +#import +#import "DDLog.h" + +@class DDLogFileInfo; + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * + * + * This class provides a logger to write log statements to a file. +**/ + + +// Default configuration and safety/sanity values. +// +// maximumFileSize -> DEFAULT_LOG_MAX_FILE_SIZE +// rollingFrequency -> DEFAULT_LOG_ROLLING_FREQUENCY +// maximumNumberOfLogFiles -> DEFAULT_LOG_MAX_NUM_LOG_FILES +// +// You should carefully consider the proper configuration values for your application. + +#define DEFAULT_LOG_MAX_FILE_SIZE (1024 * 1024) // 1 MB +#define DEFAULT_LOG_ROLLING_FREQUENCY (60 * 60 * 24) // 24 Hours +#define DEFAULT_LOG_MAX_NUM_LOG_FILES (5) // 5 Files + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// The LogFileManager protocol is designed to allow you to control all aspects of your log files. +// +// The primary purpose of this is to allow you to do something with the log files after they have been rolled. +// Perhaps you want to compress them to save disk space. +// Perhaps you want to upload them to an FTP server. +// Perhaps you want to run some analytics on the file. +// +// A default LogFileManager is, of course, provided. +// The default LogFileManager simply deletes old log files according to the maximumNumberOfLogFiles property. +// +// This protocol provides various methods to fetch the list of log files. +// +// There are two variants: sorted and unsorted. +// If sorting is not necessary, the unsorted variant is obviously faster. +// The sorted variant will return an array sorted by when the log files were created, +// with the most recently created log file at index 0, and the oldest log file at the end of the array. +// +// You can fetch only the log file paths (full path including name), log file names (name only), +// or an array of DDLogFileInfo objects. +// The DDLogFileInfo class is documented below, and provides a handy wrapper that +// gives you easy access to various file attributes such as the creation date or the file size. + +@protocol DDLogFileManager +@required + +// Public properties + +@property (readwrite, assign) NSUInteger maximumNumberOfLogFiles; + +// Public methods + +- (NSString *)logsDirectory; + +- (NSArray *)unsortedLogFilePaths; +- (NSArray *)unsortedLogFileNames; +- (NSArray *)unsortedLogFileInfos; + +- (NSArray *)sortedLogFilePaths; +- (NSArray *)sortedLogFileNames; +- (NSArray *)sortedLogFileInfos; + +// Private methods (only to be used by DDFileLogger) + +- (NSString *)createNewLogFile; + +@optional + +// Notifications from DDFileLogger + +- (void)didArchiveLogFile:(NSString *)logFilePath; +- (void)didRollAndArchiveLogFile:(NSString *)logFilePath; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Default log file manager. +// +// All log files are placed inside the logsDirectory. +// If a specific logsDirectory isn't specified, the default directory is used. +// On Mac, this is in ~/Library/Application Support//Logs. +// On iPhone, this is in ~/Documents/Logs. +// +// Log files are named "log-.txt", +// where uuid is a 6 character hexadecimal consisting of the set [0123456789ABCDEF]. +// +// Archived log files are automatically deleted according to the maximumNumberOfLogFiles property. + +@interface DDLogFileManagerDefault : NSObject +{ + NSUInteger maximumNumberOfLogFiles; + NSString *_logsDirectory; +} + +- (id)init; +- (id)initWithLogsDirectory:(NSString *)logsDirectory; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// Most users will want file log messages to be prepended with the date and time. +// Rather than forcing the majority of users to write their own formatter, +// we will supply a logical default formatter. +// Users can easily replace this formatter with their own by invoking the setLogFormatter method. +// It can also be removed by calling setLogFormatter, and passing a nil parameter. +// +// In addition to the convenience of having a logical default formatter, +// it will also provide a template that makes it easy for developers to copy and change. + +@interface DDLogFileFormatterDefault : NSObject +{ + NSDateFormatter *dateFormatter; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDFileLogger : DDAbstractLogger +{ + id logFileManager; + + DDLogFileInfo *currentLogFileInfo; + NSFileHandle *currentLogFileHandle; + + NSTimer *rollingTimer; + + unsigned long long maximumFileSize; + NSTimeInterval rollingFrequency; +} + +- (id)init; +- (id)initWithLogFileManager:(id )logFileManager; + +// Configuration +// +// maximumFileSize: +// The approximate maximum size to allow log files to grow. +// If a log file is larger than this value after a write, +// then the log file is rolled. +// +// rollingFrequency +// How often to roll the log file. +// The frequency is given as an NSTimeInterval, which is a double that specifies the interval in seconds. +// Once the log file gets to be this old, it is rolled. +// +// Both the maximumFileSize and the rollingFrequency are used to manage rolling. +// Whichever occurs first will cause the log file to be rolled. +// +// For example: +// The rollingFrequency is 24 hours, +// but the log file surpasses the maximumFileSize after only 20 hours. +// The log file will be rolled at that 20 hour mark. +// A new log file will be created, and the 24 hour timer will be restarted. +// +// logFileManager +// Allows you to retrieve the list of log files, +// and configure the maximum number of archived log files to keep. + +@property (readwrite, assign) unsigned long long maximumFileSize; + +@property (readwrite, assign) NSTimeInterval rollingFrequency; + +@property (nonatomic, readonly) id logFileManager; + + +// You can optionally force the current log file to be rolled with this method. + +- (void)rollLogFile; + +// Inherited from DDAbstractLogger + +// - (id )logFormatter; +// - (void)setLogFormatter:(id )formatter; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// DDLogFileInfo is a simple class that provides access to various file attributes. +// It provides good performance as it only fetches the information if requested, +// and it caches the information to prevent duplicate fetches. +// +// It was designed to provide quick snapshots of the current state of log files, +// and to help sort log files in an array. +// +// This class does not monitor the files, or update it's cached attribute values if the file changes on disk. +// This is not what the class was designed for. +// +// If you absolutely must get updated values, +// you can invoke the reset method which will clear the cache. + +@interface DDLogFileInfo : NSObject +{ + NSString *filePath; + NSString *fileName; + + NSDictionary *fileAttributes; + + NSDate *creationDate; + NSDate *modificationDate; + + unsigned long long fileSize; +} + +@property (nonatomic, readonly) NSString *filePath; +@property (nonatomic, readonly) NSString *fileName; + +@property (nonatomic, readonly) NSDictionary *fileAttributes; + +@property (nonatomic, readonly) NSDate *creationDate; +@property (nonatomic, readonly) NSDate *modificationDate; + +@property (nonatomic, readonly) unsigned long long fileSize; + +@property (nonatomic, readonly) NSTimeInterval age; + +@property (nonatomic, readwrite) BOOL isArchived; + ++ (id)logFileWithPath:(NSString *)filePath; + +- (id)initWithFilePath:(NSString *)filePath; + +- (void)reset; +- (void)renameFile:(NSString *)newFileName; + +#if TARGET_IPHONE_SIMULATOR + +// So here's the situation. +// Extended attributes are perfect for what we're trying to do here (marking files as archived). +// This is exactly what extended attributes were designed for. +// +// But Apple screws us over on the simulator. +// Everytime you build-and-go, they copy the application into a new folder on the hard drive, +// and as part of the process they strip extended attributes from our log files. +// Normally, a copy of a file preserves extended attributes. +// So obviously Apple has gone to great lengths to piss us off. +// +// Thus we use a slightly different tactic for marking log files as archived in the simulator. +// That way it "just works" and there's no confusion when testing. +// +// The difference in method names is indicative of the difference in functionality. +// On the simulator we add an attribute by appending a filename extension. +// +// For example: +// log-ABC123.txt -> log-ABC123.archived.txt + +- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName; + +- (void)addExtensionAttributeWithName:(NSString *)attrName; +- (void)removeExtensionAttributeWithName:(NSString *)attrName; + +#else + +// Normal use of extended attributes used everywhere else, +// such as on Macs and on iPhone devices. + +- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName; + +- (void)addExtendedAttributeWithName:(NSString *)attrName; +- (void)removeExtendedAttributeWithName:(NSString *)attrName; + +#endif + +- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another; +- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another; + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDFileLogger.m b/xmpp/Vendor/CocoaLumberjack/DDFileLogger.m new file mode 100644 index 0000000..2221dee --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDFileLogger.m @@ -0,0 +1,1498 @@ +#import "DDFileLogger.h" + +#import +#import +#import +#import + +// We probably shouldn't be using DDLog() statements within the DDLog implementation. +// But we still want to leave our log statements for any future debugging, +// and to allow other developers to trace the implementation (which is a great learning tool). +// +// So we use primitive logging macros around NSLog. +// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog. + +#define LOG_LEVEL 2 + +#define NSLogError(frmt, ...) do{ if(LOG_LEVEL >= 1) NSLog((frmt), ##__VA_ARGS__); } while(0) +#define NSLogWarn(frmt, ...) do{ if(LOG_LEVEL >= 2) NSLog((frmt), ##__VA_ARGS__); } while(0) +#define NSLogInfo(frmt, ...) do{ if(LOG_LEVEL >= 3) NSLog((frmt), ##__VA_ARGS__); } while(0) +#define NSLogVerbose(frmt, ...) do{ if(LOG_LEVEL >= 4) NSLog((frmt), ##__VA_ARGS__); } while(0) + +@interface DDLogFileManagerDefault (PrivateAPI) + +- (void)deleteOldLogFiles; +- (NSString *)defaultLogsDirectory; + +@end + +@interface DDFileLogger (PrivateAPI) + +#if GCD_MAYBE_UNAVAILABLE + +- (void)lt_getMaximumFileSize:(NSMutableArray *)resultHolder; +- (void)lt_setMaximumFileSize:(NSNumber *)maximumFileSizeWrapper; + +- (void)lt_getRollingFrequency:(NSMutableArray *)resultHolder; +- (void)lt_setRollingFrequency:(NSNumber *)rollingFrequencyWrapper; + +#endif + +- (void)rollLogFileNow; +- (void)maybeRollLogFileDueToAge:(NSTimer *)aTimer; +- (void)maybeRollLogFileDueToSize; +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDLogFileManagerDefault + +@synthesize maximumNumberOfLogFiles; + +- (id)init +{ + return [self initWithLogsDirectory:nil]; +} + +- (id)initWithLogsDirectory:(NSString *)aLogsDirectory +{ + if ((self = [super init])) + { + maximumNumberOfLogFiles = DEFAULT_LOG_MAX_NUM_LOG_FILES; + + if (aLogsDirectory) + _logsDirectory = [aLogsDirectory copy]; + else + _logsDirectory = [[self defaultLogsDirectory] copy]; + + NSKeyValueObservingOptions kvoOptions = NSKeyValueObservingOptionOld | NSKeyValueObservingOptionNew; + + [self addObserver:self forKeyPath:@"maximumNumberOfLogFiles" options:kvoOptions context:nil]; + + NSLogVerbose(@"DDFileLogManagerDefault: logsDirectory:\n%@", [self logsDirectory]); + NSLogVerbose(@"DDFileLogManagerDefault: sortedLogFileNames:\n%@", [self sortedLogFileNames]); + } + return self; +} + +- (void)dealloc +{ + [_logsDirectory release]; + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)observeValueForKeyPath:(NSString *)keyPath + ofObject:(id)object + change:(NSDictionary *)change + context:(void *)context +{ + NSNumber *old = [change objectForKey:NSKeyValueChangeOldKey]; + NSNumber *new = [change objectForKey:NSKeyValueChangeNewKey]; + + if ([old isEqual:new]) + { + // No change in value - don't bother with any processing. + return; + } + + if ([keyPath isEqualToString:@"maximumNumberOfLogFiles"]) + { + NSLogInfo(@"DDFileLogManagerDefault: Responding to configuration change: maximumNumberOfLogFiles"); + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_async([DDLog loggingQueue], ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self deleteOldLogFiles]; + + [pool drain]; + }); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(deleteOldLogFiles) + onThread:[DDLog loggingThread] + withObject:nil + waitUntilDone:NO]; + + #endif + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark File Deleting +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Deletes archived log files that exceed the maximumNumberOfLogFiles configuration value. +**/ +- (void)deleteOldLogFiles +{ + NSLogVerbose(@"DDLogFileManagerDefault: deleteOldLogFiles"); + + NSArray *sortedLogFileInfos = [self sortedLogFileInfos]; + + NSUInteger maxNumLogFiles = self.maximumNumberOfLogFiles; + + // Do we consider the first file? + // We are only supposed to be deleting archived files. + // In most cases, the first file is likely the log file that is currently being written to. + // So in most cases, we do not want to consider this file for deletion. + + NSUInteger count = [sortedLogFileInfos count]; + BOOL excludeFirstFile = NO; + + if (count > 0) + { + DDLogFileInfo *logFileInfo = [sortedLogFileInfos objectAtIndex:0]; + + if (!logFileInfo.isArchived) + { + excludeFirstFile = YES; + } + } + + NSArray *sortedArchivedLogFileInfos; + if (excludeFirstFile) + { + count--; + sortedArchivedLogFileInfos = [sortedLogFileInfos subarrayWithRange:NSMakeRange(1, count)]; + } + else + { + sortedArchivedLogFileInfos = sortedLogFileInfos; + } + + NSUInteger i; + for (i = 0; i < count; i++) + { + if (i >= maxNumLogFiles) + { + DDLogFileInfo *logFileInfo = [sortedArchivedLogFileInfos objectAtIndex:i]; + + NSLogInfo(@"DDLogFileManagerDefault: Deleting file: %@", logFileInfo.fileName); + + [[NSFileManager defaultManager] removeItemAtPath:logFileInfo.filePath error:nil]; + } + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Log Files +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the path to the default logs directory. + * If the logs directory doesn't exist, this method automatically creates it. +**/ +- (NSString *)defaultLogsDirectory +{ +#if TARGET_OS_IPHONE + NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES); + NSString *baseDir = ([paths count] > 0) ? [paths objectAtIndex:0] : nil; +#else + NSArray *paths = NSSearchPathForDirectoriesInDomains(NSApplicationSupportDirectory, NSUserDomainMask, YES); + NSString *basePath = ([paths count] > 0) ? [paths objectAtIndex:0] : NSTemporaryDirectory(); + + NSString *appName = [[NSProcessInfo processInfo] processName]; + + NSString *baseDir = [basePath stringByAppendingPathComponent:appName]; +#endif + + return [baseDir stringByAppendingPathComponent:@"Logs"]; +} + +- (NSString *)logsDirectory +{ + // We could do this check once, during initalization, and not bother again. + // But this way the code continues to work if the directory gets deleted while the code is running. + + if (![[NSFileManager defaultManager] fileExistsAtPath:_logsDirectory]) + { + NSError *err = nil; + if (![[NSFileManager defaultManager] createDirectoryAtPath:_logsDirectory + withIntermediateDirectories:YES attributes:nil error:&err]) + { + NSLogError(@"DDFileLogManagerDefault: Error creating logsDirectory: %@", err); + } + } + + return _logsDirectory; +} + +- (BOOL)isLogFile:(NSString *)fileName +{ + // A log file has a name like "log-.txt", where is a HEX-string of 6 characters. + // + // For example: log-DFFE99.txt + + BOOL hasProperPrefix = [fileName hasPrefix:@"log-"]; + + BOOL hasProperLength = [fileName length] >= 10; + + + if (hasProperPrefix && hasProperLength) + { + NSCharacterSet *hexSet = [NSCharacterSet characterSetWithCharactersInString:@"0123456789ABCDEF"]; + + NSString *hex = [fileName substringWithRange:NSMakeRange(4, 6)]; + NSString *nohex = [hex stringByTrimmingCharactersInSet:hexSet]; + + if ([nohex length] == 0) + { + return YES; + } + } + + return NO; +} + +/** + * Returns an array of NSString objects, + * each of which is the filePath to an existing log file on disk. +**/ +- (NSArray *)unsortedLogFilePaths +{ + NSString *logsDirectory = [self logsDirectory]; + NSArray *fileNames = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:logsDirectory error:nil]; + + NSMutableArray *unsortedLogFilePaths = [NSMutableArray arrayWithCapacity:[fileNames count]]; + + for (NSString *fileName in fileNames) + { + // Filter out any files that aren't log files. (Just for extra safety) + + if ([self isLogFile:fileName]) + { + NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName]; + + [unsortedLogFilePaths addObject:filePath]; + } + } + + return unsortedLogFilePaths; +} + +/** + * Returns an array of NSString objects, + * each of which is the fileName of an existing log file on disk. +**/ +- (NSArray *)unsortedLogFileNames +{ + NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths]; + + NSMutableArray *unsortedLogFileNames = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]]; + + for (NSString *filePath in unsortedLogFilePaths) + { + [unsortedLogFileNames addObject:[filePath lastPathComponent]]; + } + + return unsortedLogFileNames; +} + +/** + * Returns an array of DDLogFileInfo objects, + * each representing an existing log file on disk, + * and containing important information about the log file such as it's modification date and size. +**/ +- (NSArray *)unsortedLogFileInfos +{ + NSArray *unsortedLogFilePaths = [self unsortedLogFilePaths]; + + NSMutableArray *unsortedLogFileInfos = [NSMutableArray arrayWithCapacity:[unsortedLogFilePaths count]]; + + for (NSString *filePath in unsortedLogFilePaths) + { + DDLogFileInfo *logFileInfo = [[DDLogFileInfo alloc] initWithFilePath:filePath]; + + [unsortedLogFileInfos addObject:logFileInfo]; + [logFileInfo release]; + } + + return unsortedLogFileInfos; +} + +/** + * Just like the unsortedLogFilePaths method, but sorts the array. + * The items in the array are sorted by modification date. + * The first item in the array will be the most recently modified log file. +**/ +- (NSArray *)sortedLogFilePaths +{ + NSArray *sortedLogFileInfos = [self sortedLogFileInfos]; + + NSMutableArray *sortedLogFilePaths = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]]; + + for (DDLogFileInfo *logFileInfo in sortedLogFileInfos) + { + [sortedLogFilePaths addObject:[logFileInfo filePath]]; + } + + return sortedLogFilePaths; +} + +/** + * Just like the unsortedLogFileNames method, but sorts the array. + * The items in the array are sorted by modification date. + * The first item in the array will be the most recently modified log file. +**/ +- (NSArray *)sortedLogFileNames +{ + NSArray *sortedLogFileInfos = [self sortedLogFileInfos]; + + NSMutableArray *sortedLogFileNames = [NSMutableArray arrayWithCapacity:[sortedLogFileInfos count]]; + + for (DDLogFileInfo *logFileInfo in sortedLogFileInfos) + { + [sortedLogFileNames addObject:[logFileInfo fileName]]; + } + + return sortedLogFileNames; +} + +/** + * Just like the unsortedLogFileInfos method, but sorts the array. + * The items in the array are sorted by modification date. + * The first item in the array will be the most recently modified log file. +**/ +- (NSArray *)sortedLogFileInfos +{ + return [[self unsortedLogFileInfos] sortedArrayUsingSelector:@selector(reverseCompareByCreationDate:)]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Creation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Generates a short UUID suitable for use in the log file's name. + * The result will have six characters, all in the hexadecimal set [0123456789ABCDEF]. +**/ +- (NSString *)generateShortUUID +{ + CFUUIDRef uuid = CFUUIDCreate(NULL); + + CFStringRef fullStr = CFUUIDCreateString(NULL, uuid); + CFStringRef shortStr = CFStringCreateWithSubstring(NULL, fullStr, CFRangeMake(0, 6)); + + CFRelease(fullStr); + CFRelease(uuid); + + return [NSMakeCollectable(shortStr) autorelease]; +} + +/** + * Generates a new unique log file path, and creates the corresponding log file. +**/ +- (NSString *)createNewLogFile +{ + // Generate a random log file name, and create the file (if there isn't a collision) + + NSString *logsDirectory = [self logsDirectory]; + do + { + NSString *fileName = [NSString stringWithFormat:@"log-%@.txt", [self generateShortUUID]]; + + NSString *filePath = [logsDirectory stringByAppendingPathComponent:fileName]; + + if (![[NSFileManager defaultManager] fileExistsAtPath:filePath]) + { + NSLogVerbose(@"DDLogFileManagerDefault: Creating new log file: %@", fileName); + + [[NSFileManager defaultManager] createFileAtPath:filePath contents:nil attributes:nil]; + + // Since we just created a new log file, we may need to delete some old log files + [self deleteOldLogFiles]; + + return filePath; + } + + } while(YES); +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDLogFileFormatterDefault + +- (id)init +{ + if((self = [super init])) + { + dateFormatter = [[NSDateFormatter alloc] init]; + [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; + [dateFormatter setDateFormat:@"yyyy/MM/dd HH:mm:ss:SSS"]; + } + return self; +} + +- (NSString *)formatLogMessage:(DDLogMessage *)logMessage +{ + NSString *dateAndTime = [dateFormatter stringFromDate:(logMessage->timestamp)]; + + return [NSString stringWithFormat:@"%@ %@", dateAndTime, logMessage->logMsg]; +} + +- (void)dealloc +{ + [dateFormatter release]; + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDFileLogger + +@synthesize maximumFileSize; +@synthesize rollingFrequency; +@synthesize logFileManager; + +- (id)init +{ + DDLogFileManagerDefault *defaultLogFileManager = [[[DDLogFileManagerDefault alloc] init] autorelease]; + + return [self initWithLogFileManager:defaultLogFileManager]; +} + +- (id)initWithLogFileManager:(id )aLogFileManager +{ + if ((self = [super init])) + { + maximumFileSize = DEFAULT_LOG_MAX_FILE_SIZE; + rollingFrequency = DEFAULT_LOG_ROLLING_FREQUENCY; + + logFileManager = [aLogFileManager retain]; + + formatter = [[DDLogFileFormatterDefault alloc] init]; + } + return self; +} + +- (void)dealloc +{ + [formatter release]; + [logFileManager release]; + + [currentLogFileInfo release]; + + [currentLogFileHandle synchronizeFile]; + [currentLogFileHandle closeFile]; + [currentLogFileHandle release]; + + [rollingTimer invalidate]; + [rollingTimer release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Configuration +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (unsigned long long)maximumFileSize +{ + // The design of this method is taken from the DDAbstractLogger implementation. + // For documentation please refer to the DDAbstractLogger implementation. + + // Note: The internal implementation should access the maximumFileSize variable directly, + // but if we forget to do this, then this method should at least work properly. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + if (dispatch_get_current_queue() == loggerQueue) + { + return maximumFileSize; + } + + __block unsigned long long result; + + dispatch_block_t block = ^{ + result = maximumFileSize; + }; + dispatch_sync([DDLog loggingQueue], block); + + return result; + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + + if ([NSThread currentThread] == loggingThread) + { + return maximumFileSize; + } + + unsigned long long result; + NSMutableArray *resultHolder = [[NSMutableArray alloc] init]; + + [self performSelector:@selector(lt_getMaximumFileSize:) + onThread:loggingThread + withObject:resultHolder + waitUntilDone:YES]; + + OSMemoryBarrier(); + + result = [[resultHolder objectAtIndex:0] unsignedLongLongValue]; + [resultHolder release]; + + return result; + + #endif + } +} + +- (void)setMaximumFileSize:(unsigned long long)newMaximumFileSize +{ + // The design of this method is taken from the DDAbstractLogger implementation. + // For documentation please refer to the DDAbstractLogger implementation. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + maximumFileSize = newMaximumFileSize; + [self maybeRollLogFileDueToSize]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async([DDLog loggingQueue], block); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + NSNumber *newMaximumFileSizeWrapper = [NSNumber numberWithUnsignedLongLong:newMaximumFileSize]; + + if ([NSThread currentThread] == loggingThread) + { + [self lt_setMaximumFileSize:newMaximumFileSizeWrapper]; + } + else + { + [self performSelector:@selector(lt_setMaximumFileSize:) + onThread:loggingThread + withObject:newMaximumFileSizeWrapper + waitUntilDone:NO]; + } + + #endif + } +} + +- (NSTimeInterval)rollingFrequency +{ + // The design of this method is taken from the DDAbstractLogger implementation. + // For documentation please refer to the DDAbstractLogger implementation. + + // Note: The internal implementation should access the rollingFrequency variable directly, + // but if we forget to do this, then this method should at least work properly. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + if (dispatch_get_current_queue() == loggerQueue) + { + return rollingFrequency; + } + + __block NSTimeInterval result; + + dispatch_block_t block = ^{ + result = rollingFrequency; + }; + dispatch_sync([DDLog loggingQueue], block); + + return result; + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + + if ([NSThread currentThread] == loggingThread) + { + return rollingFrequency; + } + + NSTimeInterval result; + NSMutableArray *resultHolder = [[NSMutableArray alloc] init]; + + [self performSelector:@selector(lt_getRollingFrequency:) + onThread:loggingThread + withObject:resultHolder + waitUntilDone:YES]; + + OSMemoryBarrier(); + + result = [[resultHolder objectAtIndex:0] doubleValue]; + [resultHolder release]; + + return result; + + #endif + } +} + +- (void)setRollingFrequency:(NSTimeInterval)newRollingFrequency +{ + // The design of this method is taken from the DDAbstractLogger implementation. + // For documentation please refer to the DDAbstractLogger implementation. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + rollingFrequency = newRollingFrequency; + [self maybeRollLogFileDueToAge:nil]; + + [pool drain]; + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async([DDLog loggingQueue], block); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + NSNumber *newMaximumRollingFrequencyWrapper = [NSNumber numberWithDouble:newRollingFrequency]; + + if ([NSThread currentThread] == loggingThread) + { + [self lt_setRollingFrequency:newMaximumRollingFrequencyWrapper]; + } + else + { + [self performSelector:@selector(lt_setRollingFrequency:) + onThread:loggingThread + withObject:newMaximumRollingFrequencyWrapper + waitUntilDone:NO]; + } + + #endif + } +} + +#if GCD_MAYBE_UNAVAILABLE + +- (void)lt_getMaximumFileSize:(NSMutableArray *)resultHolder +{ + // This method is executed on the logging thread. + + [resultHolder addObject:[NSNumber numberWithUnsignedLongLong:maximumFileSize]]; + OSMemoryBarrier(); +} + +- (void)lt_setMaximumFileSize:(NSNumber *)maximumFileSizeWrapper +{ + // This method is executed on the logging thread. + + maximumFileSize = [maximumFileSizeWrapper unsignedLongLongValue]; + + [self maybeRollLogFileDueToSize]; +} + +- (void)lt_getRollingFrequency:(NSMutableArray *)resultHolder +{ + // This method is executed on the logging thread. + + [resultHolder addObject:[NSNumber numberWithDouble:rollingFrequency]]; + OSMemoryBarrier(); +} + +- (void)lt_setRollingFrequency:(NSNumber *)rollingFrequencyWrapper +{ + // This method is executed on the logging thread. + + rollingFrequency = [rollingFrequencyWrapper doubleValue]; + + [self maybeRollLogFileDueToAge:nil]; +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark File Rolling +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)scheduleTimerToRollLogFileDueToAge +{ + if (rollingTimer) + { + [rollingTimer invalidate]; + [rollingTimer release]; + rollingTimer = nil; + } + + if (currentLogFileInfo == nil) + { + return; + } + + NSDate *logFileCreationDate = [currentLogFileInfo creationDate]; + + NSTimeInterval ti = [logFileCreationDate timeIntervalSinceReferenceDate]; + ti += rollingFrequency; + + NSDate *logFileRollingDate = [NSDate dateWithTimeIntervalSinceReferenceDate:ti]; + + NSLogVerbose(@"DDFileLogger: scheduleTimerToRollLogFileDueToAge"); + + NSLogVerbose(@"DDFileLogger: logFileCreationDate: %@", logFileCreationDate); + NSLogVerbose(@"DDFileLogger: logFileRollingDate : %@", logFileRollingDate); + + rollingTimer = [[NSTimer scheduledTimerWithTimeInterval:[logFileRollingDate timeIntervalSinceNow] + target:self + selector:@selector(maybeRollLogFileDueToAge:) + userInfo:nil + repeats:NO] retain]; +} + +- (void)rollLogFile +{ + // This method is public. + // We need to execute the rolling on our logging thread/queue. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t block = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + [self rollLogFileNow]; + [pool drain]; + }; + dispatch_async([DDLog loggingQueue], block); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(rollLogFileNow) + onThread:[DDLog loggingThread] + withObject:nil + waitUntilDone:NO]; + + #endif + } +} + +- (void)rollLogFileNow +{ + NSLogVerbose(@"DDFileLogger: rollLogFileNow"); + + [currentLogFileHandle synchronizeFile]; + [currentLogFileHandle closeFile]; + [currentLogFileHandle release]; + currentLogFileHandle = nil; + + currentLogFileInfo.isArchived = YES; + + if ([logFileManager respondsToSelector:@selector(didRollAndArchiveLogFile:)]) + { + [logFileManager didRollAndArchiveLogFile:(currentLogFileInfo.filePath)]; + } + + [currentLogFileInfo release]; + currentLogFileInfo = nil; +} + +- (void)maybeRollLogFileDueToAge:(NSTimer *)aTimer +{ + if (currentLogFileInfo.age >= rollingFrequency) + { + NSLogVerbose(@"DDFileLogger: Rolling log file due to age..."); + + [self rollLogFileNow]; + } + else + { + [self scheduleTimerToRollLogFileDueToAge]; + } +} + +- (void)maybeRollLogFileDueToSize +{ + // This method is called from logMessage. + // Keep it FAST. + + unsigned long long fileSize = [currentLogFileHandle offsetInFile]; + + // Note: Use direct access to maximumFileSize variable. + // We specifically wrote our own getter/setter method to allow us to do this (for performance reasons). + + if (fileSize >= maximumFileSize) // YES, we are using direct access. Read note above. + { + NSLogVerbose(@"DDFileLogger: Rolling log file due to size..."); + + [self rollLogFileNow]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark File Logging +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the log file that should be used. + * If there is an existing log file that is suitable, + * within the constraints of maximumFileSize and rollingFrequency, then it is returned. + * + * Otherwise a new file is created and returned. +**/ +- (DDLogFileInfo *)currentLogFileInfo +{ + if (currentLogFileInfo == nil) + { + NSArray *sortedLogFileInfos = [logFileManager sortedLogFileInfos]; + + if ([sortedLogFileInfos count] > 0) + { + DDLogFileInfo *mostRecentLogFileInfo = [sortedLogFileInfos objectAtIndex:0]; + + BOOL useExistingLogFile = YES; + BOOL shouldArchiveMostRecent = NO; + + if (mostRecentLogFileInfo.isArchived) + { + useExistingLogFile = NO; + shouldArchiveMostRecent = NO; + } + else if (mostRecentLogFileInfo.fileSize >= maximumFileSize) + { + useExistingLogFile = NO; + shouldArchiveMostRecent = YES; + } + else if (mostRecentLogFileInfo.age >= rollingFrequency) + { + useExistingLogFile = NO; + shouldArchiveMostRecent = YES; + } + + if (useExistingLogFile) + { + NSLogVerbose(@"DDFileLogger: Resuming logging with file %@", mostRecentLogFileInfo.fileName); + + currentLogFileInfo = [mostRecentLogFileInfo retain]; + } + else + { + if (shouldArchiveMostRecent) + { + mostRecentLogFileInfo.isArchived = YES; + + if ([logFileManager respondsToSelector:@selector(didArchiveLogFile:)]) + { + [logFileManager didArchiveLogFile:(mostRecentLogFileInfo.filePath)]; + } + } + } + } + + if (currentLogFileInfo == nil) + { + NSString *currentLogFilePath = [logFileManager createNewLogFile]; + + currentLogFileInfo = [[DDLogFileInfo alloc] initWithFilePath:currentLogFilePath]; + } + } + + return currentLogFileInfo; +} + +- (NSFileHandle *)currentLogFileHandle +{ + if (currentLogFileHandle == nil) + { + NSString *logFilePath = [[self currentLogFileInfo] filePath]; + + currentLogFileHandle = [[NSFileHandle fileHandleForWritingAtPath:logFilePath] retain]; + [currentLogFileHandle seekToEndOfFile]; + + if (currentLogFileHandle) + { + [self scheduleTimerToRollLogFileDueToAge]; + } + } + + return currentLogFileHandle; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark DDLogger Protocol +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)logMessage:(DDLogMessage *)logMessage +{ + NSString *logMsg = logMessage->logMsg; + + if (formatter) + { + logMsg = [formatter formatLogMessage:logMessage]; + } + + if (logMsg) + { + if (![logMsg hasSuffix:@"\n"]) + { + logMsg = [logMsg stringByAppendingString:@"\n"]; + } + + NSData *logData = [logMsg dataUsingEncoding:NSUTF8StringEncoding]; + + [[self currentLogFileHandle] writeData:logData]; + + [self maybeRollLogFileDueToSize]; + } +} + +- (NSString *)loggerName +{ + return @"cocoa.lumberjack.fileLogger"; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if TARGET_IPHONE_SIMULATOR + #define XATTR_ARCHIVED_NAME @"archived" +#else + #define XATTR_ARCHIVED_NAME @"lumberjack.log.archived" +#endif + +@implementation DDLogFileInfo + +@synthesize filePath; + +@dynamic fileName; +@dynamic fileAttributes; +@dynamic creationDate; +@dynamic modificationDate; +@dynamic fileSize; +@dynamic age; + +@dynamic isArchived; + + +#pragma mark Lifecycle + ++ (id)logFileWithPath:(NSString *)aFilePath +{ + return [[[DDLogFileInfo alloc] initWithFilePath:aFilePath] autorelease]; +} + +- (id)initWithFilePath:(NSString *)aFilePath +{ + if ((self = [super init])) + { + filePath = [aFilePath copy]; + } + return self; +} + +- (void)dealloc +{ + [filePath release]; + [fileName release]; + + [fileAttributes release]; + + [creationDate release]; + [modificationDate release]; + + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Standard Info +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSDictionary *)fileAttributes +{ + if (fileAttributes == nil) + { + fileAttributes = [[[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil] retain]; + } + return fileAttributes; +} + +- (NSString *)fileName +{ + if (fileName == nil) + { + fileName = [[filePath lastPathComponent] retain]; + } + return fileName; +} + +- (NSDate *)modificationDate +{ + if (modificationDate == nil) + { + modificationDate = [[[self fileAttributes] objectForKey:NSFileModificationDate] retain]; + } + + return modificationDate; +} + +- (NSDate *)creationDate +{ + if (creationDate == nil) + { + + #if TARGET_OS_IPHONE + + const char *path = [filePath UTF8String]; + + struct attrlist attrList; + memset(&attrList, 0, sizeof(attrList)); + attrList.bitmapcount = ATTR_BIT_MAP_COUNT; + attrList.commonattr = ATTR_CMN_CRTIME; + + struct { + u_int32_t attrBufferSizeInBytes; + struct timespec crtime; + } attrBuffer; + + int result = getattrlist(path, &attrList, &attrBuffer, sizeof(attrBuffer), 0); + if (result == 0) + { + double seconds = (double)(attrBuffer.crtime.tv_sec); + double nanos = (double)(attrBuffer.crtime.tv_nsec); + + NSTimeInterval ti = seconds + (nanos / 1000000000.0); + + creationDate = [[NSDate dateWithTimeIntervalSince1970:ti] retain]; + } + else + { + NSLogError(@"DDLogFileInfo: creationDate(%@): getattrlist result = %i", self.fileName, result); + } + + #else + + creationDate = [[[self fileAttributes] objectForKey:NSFileCreationDate] retain]; + + #endif + + } + return creationDate; +} + +- (unsigned long long)fileSize +{ + if (fileSize == 0) + { + fileSize = [[[self fileAttributes] objectForKey:NSFileSize] unsignedLongLongValue]; + } + + return fileSize; +} + +- (NSTimeInterval)age +{ + return [[self creationDate] timeIntervalSinceNow] * -1.0; +} + +- (NSString *)description +{ + return [[NSDictionary dictionaryWithObjectsAndKeys: + self.filePath, @"filePath", + self.fileName, @"fileName", + self.fileAttributes, @"fileAttributes", + self.creationDate, @"creationDate", + self.modificationDate, @"modificationDate", + [NSNumber numberWithUnsignedLongLong:self.fileSize], @"fileSize", + [NSNumber numberWithDouble:self.age], @"age", + [NSNumber numberWithBool:self.isArchived], @"isArchived", + nil] description]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Archiving +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)isArchived +{ + +#if TARGET_IPHONE_SIMULATOR + + // Extended attributes don't work properly on the simulator. + // So we have to use a less attractive alternative. + // See full explanation in the header file. + + return [self hasExtensionAttributeWithName:XATTR_ARCHIVED_NAME]; + +#else + + return [self hasExtendedAttributeWithName:XATTR_ARCHIVED_NAME]; + +#endif +} + +- (void)setIsArchived:(BOOL)flag +{ + +#if TARGET_IPHONE_SIMULATOR + + // Extended attributes don't work properly on the simulator. + // So we have to use a less attractive alternative. + // See full explanation in the header file. + + if (flag) + [self addExtensionAttributeWithName:XATTR_ARCHIVED_NAME]; + else + [self removeExtensionAttributeWithName:XATTR_ARCHIVED_NAME]; + +#else + + if (flag) + [self addExtendedAttributeWithName:XATTR_ARCHIVED_NAME]; + else + [self removeExtendedAttributeWithName:XATTR_ARCHIVED_NAME]; + +#endif +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Changes +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)reset +{ + [fileName release]; + fileName = nil; + + [fileAttributes release]; + fileAttributes = nil; + + [creationDate release]; + creationDate = nil; + + [modificationDate release]; + modificationDate = nil; +} + +- (void)renameFile:(NSString *)newFileName +{ + // This method is only used on the iPhone simulator, where normal extended attributes are broken. + // See full explanation in the header file. + + if (![newFileName isEqualToString:[self fileName]]) + { + NSString *fileDir = [filePath stringByDeletingLastPathComponent]; + + NSString *newFilePath = [fileDir stringByAppendingPathComponent:newFileName]; + + NSLogVerbose(@"DDLogFileInfo: Renaming file: '%@' -> '%@'", self.fileName, newFileName); + + NSError *error = nil; + if (![[NSFileManager defaultManager] moveItemAtPath:filePath toPath:newFilePath error:&error]) + { + NSLogError(@"DDLogFileInfo: Error renaming file (%@): %@", self.fileName, error); + } + + [filePath release]; + filePath = [newFilePath retain]; + + [self reset]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Attribute Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if TARGET_IPHONE_SIMULATOR + +// Extended attributes don't work properly on the simulator. +// So we have to use a less attractive alternative. +// See full explanation in the header file. + +- (BOOL)hasExtensionAttributeWithName:(NSString *)attrName +{ + // This method is only used on the iPhone simulator, where normal extended attributes are broken. + // See full explanation in the header file. + + // Split the file name into components. + // + // log-ABC123.archived.uploaded.txt + // + // 0. log-ABC123 + // 1. archived + // 2. uploaded + // 3. txt + // + // So we want to search for the attrName in the components (ignoring the first and last array indexes). + + NSArray *components = [[self fileName] componentsSeparatedByString:@"."]; + + // Watch out for file names without an extension + + NSUInteger count = [components count]; + NSUInteger max = (count >= 2) ? count-1 : count; + + NSUInteger i; + for (i = 1; i < max; i++) + { + NSString *attr = [components objectAtIndex:i]; + + if ([attrName isEqualToString:attr]) + { + return YES; + } + } + + return NO; +} + +- (void)addExtensionAttributeWithName:(NSString *)attrName +{ + // This method is only used on the iPhone simulator, where normal extended attributes are broken. + // See full explanation in the header file. + + if ([attrName length] == 0) return; + + // Example: + // attrName = "archived" + // + // "log-ABC123.txt" -> "log-ABC123.archived.txt" + + NSArray *components = [[self fileName] componentsSeparatedByString:@"."]; + + NSUInteger count = [components count]; + + NSUInteger estimatedNewLength = [[self fileName] length] + [attrName length] + 1; + NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength]; + + if (count > 0) + { + [newFileName appendString:[components objectAtIndex:0]]; + } + + NSString *lastExt = @""; + + NSUInteger i; + for (i = 1; i < count; i++) + { + NSString *attr = [components objectAtIndex:i]; + if ([attr length] == 0) + { + continue; + } + + if ([attrName isEqualToString:attr]) + { + // Extension attribute already exists in file name + return; + } + + if ([lastExt length] > 0) + { + [newFileName appendFormat:@".%@", lastExt]; + } + + lastExt = attr; + } + + [newFileName appendFormat:@".%@", attrName]; + + if ([lastExt length] > 0) + { + [newFileName appendFormat:@".%@", lastExt]; + } + + [self renameFile:newFileName]; +} + +- (void)removeExtensionAttributeWithName:(NSString *)attrName +{ + // This method is only used on the iPhone simulator, where normal extended attributes are broken. + // See full explanation in the header file. + + if ([attrName length] == 0) return; + + // Example: + // attrName = "archived" + // + // "log-ABC123.txt" -> "log-ABC123.archived.txt" + + NSArray *components = [[self fileName] componentsSeparatedByString:@"."]; + + NSUInteger count = [components count]; + + NSUInteger estimatedNewLength = [[self fileName] length]; + NSMutableString *newFileName = [NSMutableString stringWithCapacity:estimatedNewLength]; + + if (count > 0) + { + [newFileName appendString:[components objectAtIndex:0]]; + } + + BOOL found = NO; + + NSUInteger i; + for (i = 1; i < count; i++) + { + NSString *attr = [components objectAtIndex:i]; + + if ([attrName isEqualToString:attr]) + { + found = YES; + } + else + { + [newFileName appendFormat:@".%@", attr]; + } + } + + if (found) + { + [self renameFile:newFileName]; + } +} + +#else + +- (BOOL)hasExtendedAttributeWithName:(NSString *)attrName +{ + const char *path = [filePath UTF8String]; + const char *name = [attrName UTF8String]; + + ssize_t result = getxattr(path, name, NULL, 0, 0, 0); + + return (result >= 0); +} + +- (void)addExtendedAttributeWithName:(NSString *)attrName +{ + const char *path = [filePath UTF8String]; + const char *name = [attrName UTF8String]; + + int result = setxattr(path, name, NULL, 0, 0, 0); + + if (result < 0) + { + NSLogError(@"DDLogFileInfo: setxattr(%@, %@): error = %i", attrName, self.fileName, result); + } +} + +- (void)removeExtendedAttributeWithName:(NSString *)attrName +{ + const char *path = [filePath UTF8String]; + const char *name = [attrName UTF8String]; + + int result = removexattr(path, name, 0); + + if (result < 0 && errno != ENOATTR) + { + NSLogError(@"DDLogFileInfo: removexattr(%@, %@): error = %i", attrName, self.fileName, result); + } +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Comparisons +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)isEqual:(id)object +{ + if ([object isKindOfClass:[self class]]) + { + DDLogFileInfo *another = (DDLogFileInfo *)object; + + return [filePath isEqualToString:[another filePath]]; + } + + return NO; +} + +- (NSComparisonResult)reverseCompareByCreationDate:(DDLogFileInfo *)another +{ + NSDate *us = [self creationDate]; + NSDate *them = [another creationDate]; + + NSComparisonResult result = [us compare:them]; + + if (result == NSOrderedAscending) + return NSOrderedDescending; + + if (result == NSOrderedDescending) + return NSOrderedAscending; + + return NSOrderedSame; +} + +- (NSComparisonResult)reverseCompareByModificationDate:(DDLogFileInfo *)another +{ + NSDate *us = [self modificationDate]; + NSDate *them = [another modificationDate]; + + NSComparisonResult result = [us compare:them]; + + if (result == NSOrderedAscending) + return NSOrderedDescending; + + if (result == NSOrderedDescending) + return NSOrderedAscending; + + return NSOrderedSame; +} + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDLog.h b/xmpp/Vendor/CocoaLumberjack/DDLog.h new file mode 100755 index 0000000..34c2b61 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDLog.h @@ -0,0 +1,615 @@ +#import + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * + * Otherwise, here is a quick refresher. + * There are three steps to using the macros: + * + * Step 1: + * Import the header in your implementation file: + * + * #import "DDLog.h" + * + * Step 2: + * Define your logging level in your implementation file: + * + * // Log levels: off, error, warn, info, verbose + * static const int ddLogLevel = LOG_LEVEL_VERBOSE; + * + * Step 3: + * Replace your NSLog statements with DDLog statements according to the severity of the message. + * + * NSLog(@"Fatal error, no dohickey found!"); -> DDLogError(@"Fatal error, no dohickey found!"); + * + * DDLog works exactly the same as NSLog. + * This means you can pass it multiple variables just like NSLog. +**/ + + +// Can we use Grand Central Dispatch? +// +// This question is actually composed of two parts: +// 1. Is it available to the compiler? +// 2. Is it available to the runtime? +// +// For example, if we are building a universal iPad/iPhone app, +// our base SDK may be iOS 4, but our deployment target would be iOS 3.2. +// In this case we can compile against the GCD libraries (which are available starting with iOS 4), +// but we can only use them at runtime if running on iOS 4 or later. +// If running on an iPad using iOS 3.2, we need to use runtime checks for backwards compatibility. +// +// The solution is to use a combination of compile-time and run-time macros. +// +// Note that when the minimum supported SDK supports GCD +// the run-time checks will be compiled out during optimization. + +#if TARGET_OS_IPHONE + + // Compiling for iPod/iPhone/iPad + + #if __IPHONE_OS_VERSION_MAX_ALLOWED >= 40000 // 4.0 supported + + #if __IPHONE_OS_VERSION_MIN_REQUIRED >= 40000 // 4.0 supported and required + + #define IS_GCD_AVAILABLE YES + #define GCD_MAYBE_AVAILABLE 1 + #define GCD_MAYBE_UNAVAILABLE 0 + + #else // 4.0 supported but not required + + #ifndef NSFoundationVersionNumber_iPhoneOS_4_0 + #define NSFoundationVersionNumber_iPhoneOS_4_0 751.32 + #endif + + #define IS_GCD_AVAILABLE (NSFoundationVersionNumber >= NSFoundationVersionNumber_iPhoneOS_4_0) + #define GCD_MAYBE_AVAILABLE 1 + #define GCD_MAYBE_UNAVAILABLE 1 + + #endif + + #else // 4.0 not supported + + #define IS_GCD_AVAILABLE NO + #define GCD_MAYBE_AVAILABLE 0 + #define GCD_MAYBE_UNAVAILABLE 1 + + #endif + +#else + + // Compiling for Mac OS X + + #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 // 10.6 supported + + #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 // 10.6 supported and required + + #define IS_GCD_AVAILABLE YES + #define GCD_MAYBE_AVAILABLE 1 + #define GCD_MAYBE_UNAVAILABLE 0 + + #else // 10.6 supported but not required + + #ifndef NSFoundationVersionNumber10_6 + #define NSFoundationVersionNumber10_6 751.00 + #endif + + #define IS_GCD_AVAILABLE (NSFoundationVersionNumber >= NSFoundationVersionNumber10_6) + #define GCD_MAYBE_AVAILABLE 1 + #define GCD_MAYBE_UNAVAILABLE 1 + + #endif + + #else // 10.6 not supported + + #define IS_GCD_AVAILABLE NO + #define GCD_MAYBE_AVAILABLE 0 + #define GCD_MAYBE_UNAVAILABLE 1 + + #endif + +#endif + +/* +// Uncomment for quick temporary test to see if it builds for older OS targets +#undef IS_GCD_AVAILABLE +#undef GCD_MAYBE_AVAILABLE +#undef GCD_MAYBE_UNAVAILABLE + +#define IS_GCD_AVAILABLE NO +#define GCD_MAYBE_AVAILABLE 0 +#define GCD_MAYBE_UNAVAILABLE 1 +*/ + +@class DDLogMessage; + +@protocol DDLogger; +@protocol DDLogFormatter; + +/** + * Define our big multiline macros so all the other macros will be easy to read. +**/ + +#define LOG_MACRO(isAsynchronous, lvl, flg, ctx, fnct, frmt, ...) \ + [DDLog log:isAsynchronous \ + level:lvl \ + flag:flg \ + context:ctx \ + file:__FILE__ \ + function:fnct \ + line:__LINE__ \ + format:(frmt), ##__VA_ARGS__] + + +#define LOG_OBJC_MACRO(async, lvl, flg, ctx, frmt, ...) \ + LOG_MACRO(async, lvl, flg, ctx, sel_getName(_cmd), frmt, ##__VA_ARGS__) + +#define LOG_C_MACRO(async, lvl, flg, ctx, frmt, ...) \ + LOG_MACRO(async, lvl, flg, ctx, __FUNCTION__, frmt, ##__VA_ARGS__) + +#define SYNC_LOG_OBJC_MACRO(lvl, flg, ctx, frmt, ...) \ + LOG_OBJC_MACRO( NO, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define ASYNC_LOG_OBJC_MACRO(lvl, flg, ctx, frmt, ...) \ + LOG_OBJC_MACRO(YES, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define SYNC_LOG_C_MACRO(lvl, flg, ctx, frmt, ...) \ + LOG_C_MACRO( NO, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define ASYNC_LOG_C_MACRO(lvl, flg, ctx, frmt, ...) \ + LOG_C_MACRO(YES, lvl, flg, ctx, frmt, ##__VA_ARGS__) + + +#define LOG_MAYBE(async, lvl, flg, ctx, fnct, frmt, ...) \ + do { if(lvl & flg) LOG_MACRO(async, lvl, flg, ctx, fnct, frmt, ##__VA_ARGS__); } while(0) + +#define LOG_OBJC_MAYBE(async, lvl, flg, ctx, frmt, ...) \ + LOG_MAYBE(async, lvl, flg, ctx, sel_getName(_cmd), frmt, ##__VA_ARGS__) + +#define LOG_C_MAYBE(async, lvl, flg, ctx, frmt, ...) \ + LOG_MAYBE(async, lvl, flg, ctx, __FUNCTION__, frmt, ##__VA_ARGS__) + +#define SYNC_LOG_OBJC_MAYBE(lvl, flg, ctx, frmt, ...) \ + LOG_OBJC_MAYBE( NO, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define ASYNC_LOG_OBJC_MAYBE(lvl, flg, ctx, frmt, ...) \ + LOG_OBJC_MAYBE(YES, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define SYNC_LOG_C_MAYBE(lvl, flg, ctx, frmt, ...) \ + LOG_C_MAYBE( NO, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +#define ASYNC_LOG_C_MAYBE(lvl, flg, ctx, frmt, ...) \ + LOG_C_MAYBE(YES, lvl, flg, ctx, frmt, ##__VA_ARGS__) + +/** + * Define the standard options. + * + * We default to only 4 levels because it makes it easier for beginners + * to make the transition to a logging framework. + * + * More advanced users may choose to completely customize the levels (and level names) to suite their needs. + * For more information on this see the "Custom Log Levels" page: + * http://code.google.com/p/cocoalumberjack/wiki/CustomLogLevels + * + * Advanced users may also notice that we're using a bitmask. + * This is to allow for custom fine grained logging: + * http://code.google.com/p/cocoalumberjack/wiki/FineGrainedLogging + * + * -- Flags -- + * + * Typically you will use the LOG_LEVELS (see below), but the flags may be used directly in certain situations. + * For example, say you have a lot of warning log messages, and you wanted to disable them. + * However, you still needed to see your error and info log messages. + * You could accomplish that with the following: + * + * static const int ddLogLevel = LOG_FLAG_ERROR | LOG_FLAG_INFO; + * + * Flags may also be consulted when writing custom log formatters, + * as the DDLogMessage class captures the individual flag that caused the log message to fire. + * + * -- Levels -- + * + * Log levels are simply the proper bitmask of the flags. + * + * -- Booleans -- + * + * The booleans may be used when your logging code involves more than one line. + * For example: + * + * if (LOG_VERBOSE) { + * for (id sprocket in sprockets) + * DDLogVerbose(@"sprocket: %@", [sprocket description]) + * } + * + * -- Async -- + * + * Defines the default asynchronous options. + * The default philosophy for asynchronous logging is very simple: + * + * Log messages with errors should be executed synchronously. + * After all, an error just occurred. The application could be unstable. + * + * All other log messages, such as debug output, are executed asynchronously. + * After all, if it wasn't an error, then it was just informational output, + * or something the application was easily able to recover from. + * + * -- Changes -- + * + * You are strongly discouraged from modifying this file. + * If you do, you make it more difficult on yourself to merge future bug fixes and improvements from the project. + * Instead, create your own MyLogging.h or ApplicationNameLogging.h or CompanyLogging.h + * + * For an example of customizing your logging experience, see the "Custom Log Levels" page: + * http://code.google.com/p/cocoalumberjack/wiki/CustomLogLevels +**/ + +#define LOG_FLAG_ERROR (1 << 0) // 0...0001 +#define LOG_FLAG_WARN (1 << 1) // 0...0010 +#define LOG_FLAG_INFO (1 << 2) // 0...0100 +#define LOG_FLAG_VERBOSE (1 << 3) // 0...1000 + +#define LOG_LEVEL_OFF 0 +#define LOG_LEVEL_ERROR (LOG_FLAG_ERROR) // 0...0001 +#define LOG_LEVEL_WARN (LOG_FLAG_ERROR | LOG_FLAG_WARN) // 0...0011 +#define LOG_LEVEL_INFO (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO) // 0...0111 +#define LOG_LEVEL_VERBOSE (LOG_FLAG_ERROR | LOG_FLAG_WARN | LOG_FLAG_INFO | LOG_FLAG_VERBOSE) // 0...1111 + +#define LOG_ERROR (ddLogLevel & LOG_FLAG_ERROR) +#define LOG_WARN (ddLogLevel & LOG_FLAG_WARN) +#define LOG_INFO (ddLogLevel & LOG_FLAG_INFO) +#define LOG_VERBOSE (ddLogLevel & LOG_FLAG_VERBOSE) + +#define LOG_ASYNC_ENABLED YES + +#define LOG_ASYNC_ERROR ( NO && LOG_ASYNC_ENABLED) +#define LOG_ASYNC_WARN (YES && LOG_ASYNC_ENABLED) +#define LOG_ASYNC_INFO (YES && LOG_ASYNC_ENABLED) +#define LOG_ASYNC_VERBOSE (YES && LOG_ASYNC_ENABLED) + +#define DDLogError(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_ERROR, ddLogLevel, LOG_FLAG_ERROR, 0, frmt, ##__VA_ARGS__) +#define DDLogWarn(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_WARN, ddLogLevel, LOG_FLAG_WARN, 0, frmt, ##__VA_ARGS__) +#define DDLogInfo(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_INFO, ddLogLevel, LOG_FLAG_INFO, 0, frmt, ##__VA_ARGS__) +#define DDLogVerbose(frmt, ...) LOG_OBJC_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__) + +#define DDLogCError(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_ERROR, ddLogLevel, LOG_FLAG_ERROR, 0, frmt, ##__VA_ARGS__) +#define DDLogCWarn(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_WARN, ddLogLevel, LOG_FLAG_WARN, 0, frmt, ##__VA_ARGS__) +#define DDLogCInfo(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_INFO, ddLogLevel, LOG_FLAG_INFO, 0, frmt, ##__VA_ARGS__) +#define DDLogCVerbose(frmt, ...) LOG_C_MAYBE(LOG_ASYNC_VERBOSE, ddLogLevel, LOG_FLAG_VERBOSE, 0, frmt, ##__VA_ARGS__) + +/** + * The THIS_FILE macro gives you an NSString of the file name. + * For simplicity and clarity, the file name does not include the full path or file extension. + * + * For example: DDLogWarn(@"%@: Unable to find thingy", THIS_FILE) -> @"MyViewController: Unable to find thingy" +**/ + +NSString *ExtractFileNameWithoutExtension(const char *filePath, BOOL copy); + +#define THIS_FILE (ExtractFileNameWithoutExtension(__FILE__, NO)) + +/** + * The THIS_METHOD macro gives you the name of the current objective-c method. + * + * For example: DDLogWarn(@"%@ - Requires non-nil strings") -> @"setMake:model: requires non-nil strings" + * + * Note: This does NOT work in straight C functions (non objective-c). + * Instead you should use the predefined __FUNCTION__ macro. +**/ + +#define THIS_METHOD NSStringFromSelector(_cmd) + + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDLog : NSObject + +#if GCD_MAYBE_AVAILABLE + +/** + * Provides access to the underlying logging queue. + * This may be helpful to Logger classes for things like thread synchronization. +**/ + ++ (dispatch_queue_t)loggingQueue; + +#endif + +#if GCD_MAYBE_UNAVAILABLE + +/** + * Provides access to the underlying logging thread. + * This may be helpful to Logger classes for things like thread synchronization. +**/ + ++ (NSThread *)loggingThread; + +#endif + +/** + * Logging Primitive. + * + * This method is used by the macros above. + * It is suggested you stick with the macros as they're easier to use. +**/ + ++ (void)log:(BOOL)synchronous + level:(int)level + flag:(int)flag + context:(int)context + file:(const char *)file + function:(const char *)function + line:(int)line + format:(NSString *)format, ...; + +/** + * Since logging can be asynchronous, there may be times when you want to flush the logs. + * The framework invokes this automatically when the application quits. +**/ + ++ (void)flushLog; + +/** + * Loggers + * + * If you want your log statements to go somewhere, + * you should create and add a logger. +**/ + ++ (void)addLogger:(id )logger; ++ (void)removeLogger:(id )logger; + ++ (void)removeAllLoggers; + +/** + * Registered Dynamic Logging + * + * These methods allow you to obtain a list of classes that are using registered dynamic logging, + * and also provides methods to get and set their log level during run time. +**/ + ++ (NSArray *)registeredClasses; ++ (NSArray *)registeredClassNames; + ++ (int)logLevelForClass:(Class)aClass; ++ (int)logLevelForClassWithName:(NSString *)aClassName; + ++ (void)setLogLevel:(int)logLevel forClass:(Class)aClass; ++ (void)setLogLevel:(int)logLevel forClassWithName:(NSString *)aClassName; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol DDLogger +@required + +- (void)logMessage:(DDLogMessage *)logMessage; + +/** + * Formatters may optionally be added to any logger. + * If no formatter is set, the logger simply logs the message as it is given in logMessage. + * Or it may use its own built in formatting style. +**/ +- (id )logFormatter; +- (void)setLogFormatter:(id )formatter; + +@optional + +/** + * Since logging is asynchronous, adding and removing loggers is also asynchronous. + * In other words, the loggers are added and removed at appropriate times with regards to log messages. + * + * - Loggers will not receive log messages that were executed prior to when they were added. + * - Loggers will not receive log messages that were executed after they were removed. + * + * These methods are executed in the logging thread/queue. + * This is the same thread/queue that will execute every logMessage: invocation. + * Loggers may use these methods for thread synchronization or other setup/teardown tasks. +**/ +- (void)didAddLogger; +- (void)willRemoveLogger; + +/** + * Some loggers may buffer IO for optimization purposes. + * For example, a database logger may only save occasionaly as the disk IO is slow. + * In such loggers, this method should be implemented to flush any pending IO. + * + * This allows invocations of DDLog's flushLog method to be propogated to loggers that need it. + * + * Note that DDLog's flushLog method is invoked automatically when the application quits, + * and it may be also invoked manually by the developer prior to application crashes, or other such reasons. +**/ +- (void)flush; + +#if GCD_MAYBE_AVAILABLE + +/** + * When Grand Central Dispatch is available + * each logger is executed concurrently with respect to the other loggers. + * Thus, a dedicated dispatch queue is used for each logger. + * Logger implementations may optionally choose to provide their own dispatch queue. +**/ +- (dispatch_queue_t)loggerQueue; + +/** + * If the logger implementation does not choose to provide its own queue, + * one will automatically be created for it. + * The created queue will receive its name from this method. + * This may be helpful for debugging or profiling reasons. +**/ +- (NSString *)loggerName; + +#endif + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol DDLogFormatter +@required + +/** + * Formatters may optionally be added to any logger. + * This allows for increased flexibility in the logging environment. + * For example, log messages for log files may be formatted differently than log messages for the console. + * + * For more information about formatters, see the "Custom Formatters" page: + * http://code.google.com/p/cocoalumberjack/wiki/CustomFormatters + * + * The formatter may also optionally filter the log message by returning nil, + * in which case the logger will not log the message. +**/ + +- (NSString *)formatLogMessage:(DDLogMessage *)logMessage; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@protocol DDRegisteredDynamicLogging + +/** + * Implement these methods to allow a file's log level to be managed from a central location. + * + * This is useful if you'd like to be able to change log levels for various parts + * of your code from within the running application. + * + * Imagine pulling up the settings for your application, + * and being able to configure the logging level on a per file basis. + * + * The implementation can be very straight-forward: + * + * + (int)ddLogLevel + * { + * return ddLogLevel; + * } + * + * + (void)ddSetLogLevel:(int)logLevel + * { + * ddLogLevel = logLevel; + * } +**/ + ++ (int)ddLogLevel; ++ (void)ddSetLogLevel:(int)logLevel; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The DDLogMessage class encapsulates information about the log message. + * If you write custom loggers or formatters, you will be dealing with objects of this class. +**/ + +@interface DDLogMessage : NSObject +{ + +// The public variables below can be accessed directly (for speed). +// For example: logMessage->logLevel + +@public + int logLevel; + int logFlag; + int logContext; + NSString *logMsg; + NSDate *timestamp; + const char *file; + const char *function; + int lineNumber; + mach_port_t machThreadID; + +// The private variables below are only calculated if needed. +// You should use the public methods to access this information. + +@private + NSString *threadID; + NSString *fileName; + NSString *methodName; +} + +// The initializer is somewhat reserved for internal use. +// However, if you find need to manually create logMessage objects, +// there is one thing you should be aware of. +// The initializer expects the file and function parameters to be string literals. +// That is, it expects the given strings to exist for the duration of the object's lifetime, +// and it expects the given strings to be immutable. +// In other words, it does not copy these strings, it simply points to them. + +- (id)initWithLogMsg:(NSString *)logMsg + level:(int)logLevel + flag:(int)logFlag + context:(int)logContext + file:(const char *)file + function:(const char *)function + line:(int)line; + +/** + * Returns the threadID as it appears in NSLog. + * That is, it is a hexadecimal value which is calculated from the machThreadID. +**/ +- (NSString *)threadID; + +/** + * Convenience method to get just the file name, as the file variable is generally the full file path. + * This method does not include the file extension, which is generally unwanted for logging purposes. +**/ +- (NSString *)fileName; + +/** + * Returns the function variable in NSString form. +**/ +- (NSString *)methodName; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * The DDLogger protocol specifies that an optional formatter can be added to a logger. + * Most (but not all) loggers will want to support formatters. + * + * However, writting getters and setters in a thread safe manner, + * while still maintaining maximum speed for the logging process, is a difficult task. + * + * To do it right, the implementation of the getter/setter has strict requiremenets: + * - Must NOT require the logMessage method to acquire a lock. + * - Must NOT require the logMessage method to access an atomic property (also a lock of sorts). + * + * To simplify things, an abstract logger is provided that implements the getter and setter. + * + * Logger implementations may simply extend this class, + * and they can ACCESS THE FORMATTER VARIABLE DIRECTLY from within their logMessage method! +**/ + +@interface DDAbstractLogger : NSObject +{ + id formatter; + +#if GCD_MAYBE_AVAILABLE + dispatch_queue_t loggerQueue; +#endif +} + +- (id )logFormatter; +- (void)setLogFormatter:(id )formatter; + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDLog.m b/xmpp/Vendor/CocoaLumberjack/DDLog.m new file mode 100755 index 0000000..bff5d45 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDLog.m @@ -0,0 +1,1491 @@ +#import "DDLog.h" + +#import +#import +#import +#import +#import + + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * +**/ + +// We probably shouldn't be using DDLog() statements within the DDLog implementation. +// But we still want to leave our log statements for any future debugging, +// and to allow other developers to trace the implementation (which is a great learning tool). +// +// So we use a primitive logging macro around NSLog. +// We maintain the NS prefix on the macros to be explicit about the fact that we're using NSLog. + +#define DD_DEBUG NO + +#define NSLogDebug(frmt, ...) do{ if(DD_DEBUG) NSLog((frmt), ##__VA_ARGS__); } while(0) + +// Specifies the maximum queue size of the logging thread. +// +// Since most logging is asynchronous, its possible for rogue threads to flood the logging queue. +// That is, to issue an abundance of log statements faster than the logging thread can keepup. +// Typically such a scenario occurs when log statements are added haphazardly within large loops, +// but may also be possible if relatively slow loggers are being used. +// +// This property caps the queue size at a given number of outstanding log statements. +// If a thread attempts to issue a log statement when the queue is already maxed out, +// the issuing thread will block until the queue size drops below the max again. + +#define LOG_MAX_QUEUE_SIZE 1000 // Should not exceed INT32_MAX + +#if GCD_MAYBE_AVAILABLE +struct LoggerNode { + id logger; + dispatch_queue_t loggerQueue; + struct LoggerNode * next; +}; +typedef struct LoggerNode LoggerNode; +#endif + + +@interface DDLog (PrivateAPI) + ++ (void)lt_addLogger:(id )logger; ++ (void)lt_removeLogger:(id )logger; ++ (void)lt_removeAllLoggers; ++ (void)lt_log:(DDLogMessage *)logMessage; ++ (void)lt_flush; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDLog + +#if GCD_MAYBE_AVAILABLE + + // All logging statements are added to the same queue to ensure FIFO operation. + static dispatch_queue_t loggingQueue; + + // Individual loggers are executed concurrently per log statement. + // Each logger has it's own associated queue, and a dispatch group is used for synchrnoization. + static dispatch_group_t loggingGroup; + + // A linked list is used to manage all the individual loggers. + // Each item in the linked list also includes the loggers associated dispatch queue. + static LoggerNode *loggerNodes; + + // In order to prevent to queue from growing infinitely large, + // a maximum size is enforced (LOG_MAX_QUEUE_SIZE). + static dispatch_semaphore_t queueSemaphore; + + // Minor optimization for uniprocessor machines + static unsigned int numProcessors; + +#endif + +#if GCD_MAYBE_UNAVAILABLE + + // All logging statements are queued onto the same thread to ensure FIFO operation. + static NSThread *loggingThread; + + // An array is used to manage all the individual loggers. + // The array is only modified on the loggingThread. + static NSMutableArray *loggers; + + // In order to prevent to queue from growing infinitely large, + // a maximum size is enforced (LOG_MAX_QUEUE_SIZE). + static int32_t queueSize; // Incremented and decremented locklessly using OSAtomic operations + static NSCondition *condition; // Not used unless the queueSize exceeds its max + static NSMutableArray *blockedThreads; // Not used unless the queueSize exceeds its max + +#endif + +/** + * The runtime sends initialize to each class in a program exactly one time just before the class, + * or any class that inherits from it, is sent its first message from within the program. (Thus the + * method may never be invoked if the class is not used.) The runtime sends the initialize message to + * classes in a thread-safe manner. Superclasses receive this message before their subclasses. + * + * This method may also be called directly (assumably by accident), hence the safety mechanism. +**/ ++ (void)initialize +{ + static BOOL initialized = NO; + if (!initialized) + { + initialized = YES; + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + NSLogDebug(@"DDLog: Using grand central dispatch"); + + loggingQueue = dispatch_queue_create("cocoa.lumberjack", NULL); + loggingGroup = dispatch_group_create(); + + loggerNodes = NULL; + + queueSemaphore = dispatch_semaphore_create(LOG_MAX_QUEUE_SIZE); + + // Figure out how many processors are available. + // This may be used later for an optimization on uniprocessor machines. + + host_basic_info_data_t hostInfo; + mach_msg_type_number_t infoCount; + + infoCount = HOST_BASIC_INFO_COUNT; + host_info(mach_host_self(), HOST_BASIC_INFO, (host_info_t)&hostInfo, &infoCount); + + unsigned int result = (unsigned int)(hostInfo.max_cpus); + unsigned int one = (unsigned int)(1); + + numProcessors = MAX(result, one); + + NSLogDebug(@"DDLog: numProcessors = %u", numProcessors); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSLogDebug(@"DDLog: GCD not available"); + + loggingThread = [[NSThread alloc] initWithTarget:self selector:@selector(lt_main:) object:nil]; + [loggingThread start]; + + loggers = [[NSMutableArray alloc] initWithCapacity:4]; + + queueSize = 0; + + condition = [[NSCondition alloc] init]; + blockedThreads = [[NSMutableArray alloc] init]; + + #endif + } + + #if TARGET_OS_IPHONE + NSString *notificationName = @"UIApplicationWillTerminateNotification"; + #else + NSString *notificationName = @"NSApplicationWillTerminateNotification"; + #endif + + [[NSNotificationCenter defaultCenter] addObserver:self + selector:@selector(applicationWillTerminate:) + name:notificationName + object:nil]; + } +} + +#if GCD_MAYBE_AVAILABLE + +/** + * Provides access to the logging queue. +**/ ++ (dispatch_queue_t)loggingQueue +{ + return loggingQueue; +} + +#endif + +#if GCD_MAYBE_UNAVAILABLE + +/** + * Provides access to the logging thread. +**/ ++ (NSThread *)loggingThread +{ + return loggingThread; +} + +#endif + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Notifications +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (void)applicationWillTerminate:(NSNotification *)notification +{ + [self flushLog]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Logger Management +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (void)addLogger:(id )logger +{ + if (logger == nil) return; + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t addLoggerBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self lt_addLogger:logger]; + + [pool drain]; + }; + + dispatch_async(loggingQueue, addLoggerBlock); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(lt_addLogger:) onThread:loggingThread withObject:logger waitUntilDone:NO]; + + #endif + } +} + ++ (void)removeLogger:(id )logger +{ + if (logger == nil) return; + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t removeLoggerBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self lt_removeLogger:logger]; + + [pool drain]; + }; + + dispatch_async(loggingQueue, removeLoggerBlock); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(lt_removeLogger:) onThread:loggingThread withObject:logger waitUntilDone:NO]; + + #endif + } +} + ++ (void)removeAllLoggers +{ + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t removeAllLoggersBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self lt_removeAllLoggers]; + + [pool drain]; + }; + + dispatch_async(loggingQueue, removeAllLoggersBlock); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(lt_removeAllLoggers) onThread:loggingThread withObject:nil waitUntilDone:NO]; + + #endif + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Master Logging +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (void)queueLogMessage:(DDLogMessage *)logMessage asynchronously:(BOOL)asyncFlag +{ + // We have a tricky situation here... + // + // In the common case, when the queueSize is below the maximumQueueSize, + // we want to simply enqueue the logMessage. And we want to do this as fast as possible, + // which means we don't want to block and we don't want to use any locks. + // + // However, if the queueSize gets too big, we want to block. + // But we have very strict requirements as to when we block, and how long we block. + // + // The following example should help illustrate our requirements: + // + // Imagine that the maximum queue size is configured to be 5, + // and that there are already 5 log messages queued. + // Let us call these 5 queued log messages A, B, C, D, and E. (A is next to be executed) + // + // Now if our thread issues a log statement (let us call the log message F), + // it should block before the message is added to the queue. + // Furthermore, it should be unblocked immediately after A has been unqueued. + // + // The requirements are strict in this manner so that we block only as long as necessary, + // and so that blocked threads are unblocked in the order in which they were blocked. + // + // Returning to our previous example, let us assume that log messages A through E are still queued. + // Our aforementioned thread is blocked attempting to queue log message F. + // Now assume we have another separate thread that attempts to issue log message G. + // It should block until log messages A and B have been unqueued. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // We are using a counting semaphore provided by GCD. + // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value. + // Everytime we want to queue a log message we decrement this value. + // If the resulting value is less than zero, + // the semaphore function waits in FIFO order for a signal to occur before returning. + // + // A dispatch semaphore is an efficient implementation of a traditional counting semaphore. + // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked. + // If the calling semaphore does not need to block, no kernel call is made. + + dispatch_semaphore_wait(queueSemaphore, DISPATCH_TIME_FOREVER); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + // We're going increment our queue size (in an atomic fashion). + // If the queue size would exceed our LOG_MAX_QUEUE_SIZE value, + // then we're going to take a lock, and add ourself to the blocked threads array. + // Then we wait for the logging thread to signal us. + // When it does, we automatically reaquire the lock, + // and check to see if we have been removed from the blocked threads array. + // When this occurs we are unblocked, and we can go ahead and queue our log message. + + int32_t newQueueSize = OSAtomicIncrement32(&queueSize); + if (newQueueSize > LOG_MAX_QUEUE_SIZE) + { + NSLogDebug(@"DDLog: Blocking thread %@ (newQueueSize=%i)", [logMessage threadID], newQueueSize); + + [condition lock]; + + NSString *currentThreadID = [logMessage threadID]; + [blockedThreads addObject:currentThreadID]; + + NSUInteger lastKnownIndex = [blockedThreads count] - 1; + + if (lastKnownIndex == 0) + { + NSLogDebug(@"DDLog: Potential edge case: First blocked thread -> Signaling condition..."); + + // Edge case: + // The loggingThread/loggingQueue acquired the lock before we did, + // but it immediately discovered the blockedThreads array was empty. + + [condition signal]; + } + + BOOL done = NO; + while (!done) + { + BOOL found = NO; + NSUInteger i; + NSUInteger count = [blockedThreads count]; + + for (i = 0; i <= lastKnownIndex && i < count && !found; i++) + { + NSString *blockedThreadID = [blockedThreads objectAtIndex:i]; + + // Instead of doing a string comparison, + // we can save CPU cycles by doing an pointer comparison, + // since we still have access to the string that we added the array. + + if (blockedThreadID == currentThreadID) + { + found = YES; + lastKnownIndex = i; + } + } + + // If our currentThreadID is still in the blockedThreads array, + // then we are still blocked, and we're not done. + + done = !found; + + if (!done) + { + [condition wait]; + } + } + + + [condition unlock]; + + NSLogDebug(@"DDLog: Unblocking thread %@", [logMessage threadID]); + } + + #endif + } + + // We've now sure we won't overflow the queue. + // It is time to queue our log message. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t logBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self lt_log:logMessage]; + + [pool drain]; + }; + + if (asyncFlag) + dispatch_async(loggingQueue, logBlock); + else + dispatch_sync(loggingQueue, logBlock); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(lt_log:) onThread:loggingThread withObject:logMessage waitUntilDone:!asyncFlag]; + + #endif + } +} + ++ (void)log:(BOOL)asynchronous + level:(int)level + flag:(int)flag + context:(int)context + file:(const char *)file + function:(const char *)function + line:(int)line + format:(NSString *)format, ... +{ + va_list args; + if (format) + { + va_start(args, format); + + NSString *logMsg = [[NSString alloc] initWithFormat:format arguments:args]; + DDLogMessage *logMessage = [[DDLogMessage alloc] initWithLogMsg:logMsg + level:level + flag:flag + context:context + file:file + function:function + line:line]; + + [self queueLogMessage:logMessage asynchronously:asynchronous]; + + [logMessage release]; + [logMsg release]; + + va_end(args); + } +} + ++ (void)flushLog +{ + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + dispatch_block_t flushBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [self lt_flush]; + + [pool drain]; + }; + + dispatch_sync(loggingQueue, flushBlock); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + [self performSelector:@selector(lt_flush) onThread:loggingThread withObject:nil waitUntilDone:YES]; + + #endif + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Registered Dynamic Logging +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (BOOL)isRegisteredClass:(Class)class +{ + SEL getterSel = @selector(ddLogLevel); + SEL setterSel = @selector(ddSetLogLevel:); + + Method getter = class_getClassMethod(class, getterSel); + Method setter = class_getClassMethod(class, setterSel); + + if ((getter != NULL) && (setter != NULL)) + { + return YES; + } + + return NO; +} + ++ (NSArray *)registeredClasses +{ + int numClasses, i; + + // We're going to get the list of all registered classes. + // The Objective-C runtime library automatically registers all the classes defined in your source code. + // + // To do this we use the following method (documented in the Objective-C Runtime Reference): + // + // int objc_getClassList(Class *buffer, int bufferLen) + // + // We can pass (NULL, 0) to obtain the total number of + // registered class definitions without actually retrieving any class definitions. + // This allows us to allocate the minimum amount of memory needed for the application. + + numClasses = objc_getClassList(NULL, 0); + + // The numClasses method now tells us how many classes we have. + // So we can allocate our buffer, and get pointers to all the class definitions. + + Class *classes = malloc(sizeof(Class) * numClasses); + + numClasses = objc_getClassList(classes, numClasses); + + // We can now loop through the classes, and test each one to see if it is a DDLogging class. + + NSMutableArray *result = [NSMutableArray arrayWithCapacity:numClasses]; + + for (i = 0; i < numClasses; i++) + { + Class class = classes[i]; + + if ([self isRegisteredClass:class]) + { + [result addObject:class]; + } + } + + free(classes); + + return result; +} + ++ (NSArray *)registeredClassNames +{ + NSArray *registeredClasses = [self registeredClasses]; + NSMutableArray *result = [NSMutableArray arrayWithCapacity:[registeredClasses count]]; + + for (Class class in registeredClasses) + { + [result addObject:NSStringFromClass(class)]; + } + + return result; +} + ++ (int)logLevelForClass:(Class)aClass +{ + if ([self isRegisteredClass:aClass]) + { + return [aClass ddLogLevel]; + } + + return -1; +} + ++ (int)logLevelForClassWithName:(NSString *)aClassName +{ + Class aClass = NSClassFromString(aClassName); + + return [self logLevelForClass:aClass]; +} + ++ (void)setLogLevel:(int)logLevel forClass:(Class)aClass +{ + if ([self isRegisteredClass:aClass]) + { + [aClass ddSetLogLevel:logLevel]; + } +} + ++ (void)setLogLevel:(int)logLevel forClassWithName:(NSString *)aClassName +{ + Class aClass = NSClassFromString(aClassName); + + [self setLogLevel:logLevel forClass:aClass]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Logging Thread +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if GCD_MAYBE_UNAVAILABLE + +/** + * Entry point for logging thread. +**/ ++ (void)lt_main:(id)ignore +{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + // We can't run the run loop unless it has an associated input source or a timer. + // So we'll just create a timer that will never fire - unless the server runs for 10,000 years. + [NSTimer scheduledTimerWithTimeInterval:DBL_MAX target:self selector:@selector(ignore:) userInfo:nil repeats:NO]; + + [[NSRunLoop currentRunLoop] run]; + + [pool drain]; +} + +#endif + +/** + * This method should only be run on the logging thread/queue. +**/ ++ (void)lt_addLogger:(id )logger +{ + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // Add to linked list of LoggerNode elements. + // Need to create loggerQueue if loggerNode doesn't provide one. + + LoggerNode *loggerNode = malloc(sizeof(LoggerNode)); + loggerNode->logger = [logger retain]; + + if ([logger respondsToSelector:@selector(loggerQueue)]) + { + // Logger may be providing its own queue + + loggerNode->loggerQueue = [logger loggerQueue]; + } + + if (loggerNode->loggerQueue) + { + dispatch_retain(loggerNode->loggerQueue); + } + else + { + // Automatically create queue for the logger. + // Use the logger name as the queue name if possible. + + const char *loggerQueueName = NULL; + if ([logger respondsToSelector:@selector(loggerName)]) + { + loggerQueueName = [[logger loggerName] UTF8String]; + } + + loggerNode->loggerQueue = dispatch_queue_create(loggerQueueName, NULL); + } + + loggerNode->next = loggerNodes; + loggerNodes = loggerNode; + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + // Add to loggers array + + [loggers addObject:logger]; + + #endif + } + + if ([logger respondsToSelector:@selector(didAddLogger)]) + { + [logger didAddLogger]; + } +} + +/** + * This method should only be run on the logging thread/queue. +**/ ++ (void)lt_removeLogger:(id )logger +{ + if ([logger respondsToSelector:@selector(willRemoveLogger)]) + { + [logger willRemoveLogger]; + } + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // Remove from linked list of LoggerNode elements. + // + // Need to release: + // - logger + // - loggerQueue + // - loggerNode + + LoggerNode *prevNode = NULL; + LoggerNode *currentNode = loggerNodes; + + while (currentNode) + { + if (currentNode->logger == logger) + { + if (prevNode) + { + // LoggerNode had previous node pointing to it. + prevNode->next = currentNode->next; + } + else + { + // LoggerNode was first in list. Update loggerNodes pointer. + loggerNodes = currentNode->next; + } + + [currentNode->logger release]; + currentNode->logger = nil; + + dispatch_release(currentNode->loggerQueue); + currentNode->loggerQueue = NULL; + + currentNode->next = NULL; + + free(currentNode); + + break; + } + + prevNode = currentNode; + currentNode = currentNode->next; + } + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + // Remove from loggers array + + [loggers removeObject:logger]; + + #endif + } +} + +/** + * This method should only be run on the logging thread/queue. +**/ ++ (void)lt_removeAllLoggers +{ + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // Iterate through linked list of LoggerNode elements. + // For each one, notify the logger, and deallocate all associated resources. + // + // Need to release: + // - logger + // - loggerQueue + // - loggerNode + + LoggerNode *nextNode; + LoggerNode *currentNode = loggerNodes; + + while (currentNode) + { + if ([currentNode->logger respondsToSelector:@selector(willRemoveLogger)]) + { + [currentNode->logger willRemoveLogger]; + } + + nextNode = currentNode->next; + + [currentNode->logger release]; + currentNode->logger = nil; + + dispatch_release(currentNode->loggerQueue); + currentNode->loggerQueue = NULL; + + currentNode->next = NULL; + + free(currentNode); + + currentNode = nextNode; + } + + loggerNodes = NULL; + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + // Notify all loggers. + // And then remove them all from loggers array. + + for (id logger in loggers) + { + if ([logger respondsToSelector:@selector(willRemoveLogger)]) + { + [logger willRemoveLogger]; + } + } + + [loggers removeAllObjects]; + + #endif + } +} + +/** + * This method should only be run on the logging thread/queue. +**/ ++ (void)lt_log:(DDLogMessage *)logMessage +{ + // Execute the given log message on each of our loggers. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + if (numProcessors > 1) + { + // Execute each logger concurrently, each within its own queue. + // All blocks are added to same group. + // After each block has been queued, wait on group. + // + // The waiting ensures that a slow logger doesn't end up with a large queue of pending log messages. + // This would defeat the purpose of the efforts we made earlier to restrict the max queue size. + + LoggerNode *currentNode = loggerNodes; + + while (currentNode) + { + dispatch_block_t loggerBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [currentNode->logger logMessage:logMessage]; + + [pool drain]; + }; + + dispatch_group_async(loggingGroup, currentNode->loggerQueue, loggerBlock); + + currentNode = currentNode->next; + } + + dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER); + } + else + { + // Execute each logger serialy, each within its own queue. + + LoggerNode *currentNode = loggerNodes; + + while (currentNode) + { + dispatch_block_t loggerBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [currentNode->logger logMessage:logMessage]; + + [pool drain]; + }; + + dispatch_sync(currentNode->loggerQueue, loggerBlock); + + currentNode = currentNode->next; + } + } + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + for (id logger in loggers) + { + [logger logMessage:logMessage]; + } + + #endif + } + + // If our queue got too big, there may be blocked threads waiting to add log messages to the queue. + // Since we've now dequeued an item from the log, we may need to unblock the next thread. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // We are using a counting semaphore provided by GCD. + // The semaphore is initialized with our LOG_MAX_QUEUE_SIZE value. + // When a log message is queued this value is decremented. + // When a log message is dequeued this value is incremented. + // If the value ever drops below zero, + // the queueing thread blocks and waits in FIFO order for us to signal it. + // + // A dispatch semaphore is an efficient implementation of a traditional counting semaphore. + // Dispatch semaphores call down to the kernel only when the calling thread needs to be blocked. + // If the calling semaphore does not need to block, no kernel call is made. + + dispatch_semaphore_signal(queueSemaphore); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + int32_t newQueueSize = OSAtomicDecrement32(&queueSize); + if (newQueueSize >= LOG_MAX_QUEUE_SIZE) + { + // There is an existing blocked thread waiting for us. + // When the thread went to queue a log message, it first incremented the queueSize. + // At this point it realized that was going to exceed the maxQueueSize. + // It then added itself to the blockedThreads list, and is now waiting for us to signal it. + + [condition lock]; + + while ([blockedThreads count] == 0) + { + NSLogDebug(@"DDLog: Edge case: Empty blocked threads array -> Waiting for condition..."); + + // Edge case. + // We acquired the lock before the blockedThread did. + // That is why the array is empty. + // Allow it to acquire the lock and signal us. + + [condition wait]; + } + + // The blockedThreads variable is acting as a queue. (FIFO) + // Whatever was the first thread to block can now be unblocked. + // This means that thread will block only until the count of + // prevoiusly queued plus previously reserved log messages before it have dropped below the maxQueueSize. + + NSLogDebug(@"DDLog: Signaling thread %@ (newQueueSize=%i)", [blockedThreads objectAtIndex:0], newQueueSize); + + [blockedThreads removeObjectAtIndex:0]; + [condition broadcast]; + + [condition unlock]; + } + + #endif + } +} + +/** + * This method should only be run on the background logging thread. +**/ ++ (void)lt_flush +{ + // All log statements issued before the flush method was invoked have now been executed. + // + // Now we need to propogate the flush request to any loggers that implement the flush method. + // This is designed for loggers that buffer IO. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + LoggerNode *currentNode = loggerNodes; + + while (currentNode) + { + if ([currentNode->logger respondsToSelector:@selector(flush)]) + { + dispatch_block_t loggerBlock = ^{ + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + [currentNode->logger flush]; + + [pool drain]; + }; + + dispatch_group_async(loggingGroup, currentNode->loggerQueue, loggerBlock); + } + currentNode = currentNode->next; + } + + dispatch_group_wait(loggingGroup, DISPATCH_TIME_FOREVER); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + for (id logger in loggers) + { + if ([logger respondsToSelector:@selector(flush)]) + { + [logger flush]; + } + } + + #endif + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Utilities +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +NSString *ExtractFileNameWithoutExtension(const char *filePath, BOOL copy) +{ + if (filePath == NULL) return nil; + + char *lastSlash = NULL; + char *lastDot = NULL; + + char *p = (char *)filePath; + + while (*p != '\0') + { + if (*p == '/') + lastSlash = p; + else if (*p == '.') + lastDot = p; + + p++; + } + + char *subStr; + NSUInteger subLen; + + if (lastSlash) + { + if (lastDot) + { + // lastSlash -> lastDot + subStr = lastSlash + 1; + subLen = lastDot - subStr; + } + else + { + // lastSlash -> endOfString + subStr = lastSlash + 1; + subLen = p - subStr; + } + } + else + { + if (lastDot) + { + // startOfString -> lastDot + subStr = (char *)filePath; + subLen = lastDot - subStr; + } + else + { + // startOfString -> endOfString + subStr = (char *)filePath; + subLen = p - subStr; + } + } + + if (copy) + { + return [[[NSString alloc] initWithBytes:subStr + length:subLen + encoding:NSUTF8StringEncoding] autorelease]; + } + else + { + // We can take advantage of the fact that __FILE__ is a string literal. + // Specifically, we don't need to waste time copying the string. + // We can just tell NSString to point to a range within the string literal. + + return [[[NSString alloc] initWithBytesNoCopy:subStr + length:subLen + encoding:NSUTF8StringEncoding + freeWhenDone:NO] autorelease]; + } +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDLogMessage + +- (id)initWithLogMsg:(NSString *)msg + level:(int)level + flag:(int)flag + context:(int)context + file:(const char *)aFile + function:(const char *)aFunction + line:(int)line +{ + if((self = [super init])) + { + logMsg = [msg retain]; + logLevel = level; + logFlag = flag; + logContext = context; + file = aFile; + function = aFunction; + lineNumber = line; + + timestamp = [[NSDate alloc] init]; + + machThreadID = pthread_mach_thread_np(pthread_self()); + } + return self; +} + +- (NSString *)threadID +{ + if (threadID == nil) + { + threadID = [[NSString alloc] initWithFormat:@"%x", machThreadID]; + } + + return threadID; +} + +- (NSString *)fileName +{ + if (fileName == nil) + { + fileName = [ExtractFileNameWithoutExtension(file, NO) retain]; + } + + return fileName; +} + +- (NSString *)methodName +{ + if (methodName == nil && function != NULL) + { + methodName = [[NSString alloc] initWithUTF8String:function]; + } + + return methodName; +} + +- (void)dealloc +{ + [logMsg release]; + [timestamp release]; + + [threadID release]; + [fileName release]; + [methodName release]; + + [super dealloc]; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDAbstractLogger + +- (id)init +{ + if ((self = [super init])) + { + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + const char *loggerQueueName = NULL; + if ([self respondsToSelector:@selector(loggerName)]) + { + loggerQueueName = [[self loggerName] UTF8String]; + } + + loggerQueue = dispatch_queue_create(loggerQueueName, NULL); + + #endif + } + } + return self; +} + +- (void)dealloc +{ + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + if (loggerQueue) dispatch_release(loggerQueue); + #endif + } + + [super dealloc]; +} + +- (void)logMessage:(DDLogMessage *)logMessage +{ + // Override me +} + +#if GCD_MAYBE_UNAVAILABLE + +- (void)lt_getLogFormatter:(NSMutableArray *)resultHolder +{ + // This method is executed on the logging thread. + + [resultHolder addObject:formatter]; + OSMemoryBarrier(); +} + +- (void)lt_setLogFormatter:(id )logFormatter +{ + // This method is executed on the logging thread. + + if (formatter != logFormatter) + { + [formatter release]; + formatter = [logFormatter retain]; + } +} + +#endif + +- (id )logFormatter +{ + // This method must be thread safe and intuitive. + // Therefore if somebody executes the following code: + // + // [logger setLogFormatter:myFormatter]; + // formatter = [logger logFormatter]; + // + // They would expect formatter to equal myFormatter. + // This functionality must be ensured by the getter and setter method. + // + // The thread safety must not come at a cost to the performance of the logMessage method. + // This method is likely called sporadically, while the logMessage method is called repeatedly. + // This means, the implementation of this method: + // - Must NOT require the logMessage method to acquire a lock. + // - Must NOT require the logMessage method to access an atomic property (also a lock of sorts). + // + // Thread safety is ensured by executing access to the formatter variable on the logging thread/queue. + // This is the same thread/queue that the logMessage method operates on. + // + // Note: The last time I benchmarked the performance of direct access vs atomic property access, + // direct access was over twice as fast on the desktop and over 6 times as fast on the iPhone. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // loggerQueue : Our own private internal queue that the logMessage method runs on. + // Operations are added to this queue from the global loggingQueue. + // + // loggingQueue : The queue that all log messages go through before they arrive in our loggerQueue. + // + // It is important to note that, while the loggerQueue is used to create thread-safety for our formatter, + // changes to the formatter variable are queued on the loggingQueue. + // + // Since this will obviously confuse the hell out of me later, here is a better description. + // Imagine the following code: + // + // DDLogVerbose(@"log msg 1"); + // DDLogVerbose(@"log msg 2"); + // [logger setFormatter:myFormatter]; + // DDLogVerbose(@"log msg 3"); + // + // Our intuitive requirement means that the new formatter will only apply to the 3rd log message. + // But notice what happens if we have asynchronous logging enabled for verbose mode. + // + // Log msg 1 starts executing asynchronously on the loggingQueue. + // The loggingQueue executes the log statement on each logger concurrently. + // That means it executes log msg 1 on our loggerQueue. + // While log msg 1 is executing, log msg 2 gets added to the loggingQueue. + // Then the user requests that we change our formatter. + // So at this exact moment, our queues look like this: + // + // loggerQueue : executing log msg 1, nil + // loggingQueue : executing log msg 1, log msg 2, nil + // + // So direct access to the formatter is only available if requested from the loggerQueue. + // In all other circumstances we need to go through the loggingQueue to get the proper value. + + if (dispatch_get_current_queue() == loggerQueue) + { + return formatter; + } + + __block id result; + + dispatch_sync([DDLog loggingQueue], ^{ + result = [formatter retain]; + }); + + return [result autorelease]; + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + + if ([NSThread currentThread] == loggingThread) + { + return formatter; + } + + NSMutableArray *resultHolder = [[NSMutableArray alloc] init]; + + [self performSelector:@selector(lt_getLogFormatter:) + onThread:loggingThread + withObject:resultHolder + waitUntilDone:YES]; + + OSMemoryBarrier(); + + id result = [[resultHolder objectAtIndex:0] retain]; + [resultHolder release]; + + return [result autorelease]; + + #endif + } +} + +- (void)setLogFormatter:(id )logFormatter +{ + // This method must be thread safe and intuitive. + // Therefore if somebody executes the following code: + // + // [logger setLogFormatter:myFormatter]; + // formatter = [logger logFormatter]; + // + // They would expect formatter to equal myFormatter. + // This functionality must be ensured by the getter and setter method. + // + // The thread safety must not come at a cost to the performance of the logMessage method. + // This method is likely called sporadically, while the logMessage method is called repeatedly. + // This means, the implementation of this method: + // - Must NOT require the logMessage method to acquire a lock. + // - Must NOT require the logMessage method to access an atomic property (also a lock of sorts). + // + // Thread safety is ensured by executing access to the formatter variable on the logging thread/queue. + // This is the same thread/queue that the logMessage method operates on. + // + // Note: The last time I benchmarked the performance of direct access vs atomic property access, + // direct access was over twice as fast on the desktop and over 6 times as fast on the iPhone. + + if (IS_GCD_AVAILABLE) + { + #if GCD_MAYBE_AVAILABLE + + // loggerQueue : Our own private internal queue that the logMessage method runs on. + // Operations are added to this queue from the global loggingQueue. + // + // loggingQueue : The queue that all log messages go through before they arrive in our loggerQueue. + // + // It is important to note that, while the loggerQueue is used to create thread-safety for our formatter, + // changes to the formatter variable are queued on the loggingQueue. + // + // Since this will obviously confuse the hell out of me later, here is a better description. + // Imagine the following code: + // + // DDLogVerbose(@"log msg 1"); + // DDLogVerbose(@"log msg 2"); + // [logger setFormatter:myFormatter]; + // DDLogVerbose(@"log msg 3"); + // + // Our intuitive requirement means that the new formatter will only apply to the 3rd log message. + // But notice what happens if we have asynchronous logging enabled for verbose mode. + // + // Log msg 1 starts executing asynchronously on the loggingQueue. + // The loggingQueue executes the log statement on each logger concurrently. + // That means it executes log msg 1 on our loggerQueue. + // While log msg 1 is executing, log msg 2 gets added to the loggingQueue. + // Then the user requests that we change our formatter. + // So at this exact moment, our queues look like this: + // + // loggerQueue : executing log msg 1, nil + // loggingQueue : executing log msg 1, log msg 2, nil + // + // So direct access to the formatter is only available if requested from the loggerQueue. + // In all other circumstances we need to go through the loggingQueue to get the proper value. + + dispatch_block_t block = ^{ + if (formatter != logFormatter) + { + [formatter release]; + formatter = [logFormatter retain]; + } + }; + + if (dispatch_get_current_queue() == loggerQueue) + block(); + else + dispatch_async([DDLog loggingQueue], block); + + #endif + } + else + { + #if GCD_MAYBE_UNAVAILABLE + + NSThread *loggingThread = [DDLog loggingThread]; + + if ([NSThread currentThread] == loggingThread) + { + [self lt_setLogFormatter:logFormatter]; + } + else + { + [self performSelector:@selector(lt_setLogFormatter:) + onThread:loggingThread + withObject:logFormatter + waitUntilDone:NO]; + } + + #endif + } +} + +#if GCD_MAYBE_AVAILABLE + +- (dispatch_queue_t)loggerQueue +{ + return loggerQueue; +} + +- (NSString *)loggerName +{ + return NSStringFromClass([self class]); +} + +#endif + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.h b/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.h new file mode 100755 index 0000000..c964fe9 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.h @@ -0,0 +1,49 @@ +#import + +#import "DDLog.h" + +/** + * Welcome to Cocoa Lumberjack! + * + * The Google Code page has a wealth of documentation if you have any questions. + * http://code.google.com/p/cocoalumberjack/ + * + * If you're new to the project you may wish to read the "Getting Started" page. + * http://code.google.com/p/cocoalumberjack/wiki/GettingStarted + * + * + * This class provides a logger for Terminal output or Xcode console output, + * depending on where you are running your code. + * + * As described in the "Getting Started" page, + * the traditional NSLog() function directs it's output to two places: + * + * - Apple System Log (so it shows up in Console.app) + * - StdErr (if stderr is a TTY, so log statements show up in Xcode console) + * + * To duplicate NSLog() functionality you can simply add this logger and an asl logger. + * However, if you instead choose to use file logging (for faster performance), + * you may choose to use only a file logger and a tty logger. +**/ + +@interface DDTTYLogger : DDAbstractLogger +{ + BOOL isaTTY; + + NSDateFormatter *dateFormatter; + + char *app; // Not null terminated + char *pid; // Not null terminated + + size_t appLen; + size_t pidLen; +} + ++ (DDTTYLogger *)sharedInstance; + +// Inherited from DDAbstractLogger + +// - (id )logFormatter; +// - (void)setLogFormatter:(id )formatter; + +@end diff --git a/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.m b/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.m new file mode 100755 index 0000000..76b8742 --- /dev/null +++ b/xmpp/Vendor/CocoaLumberjack/DDTTYLogger.m @@ -0,0 +1,173 @@ +#import "DDTTYLogger.h" + +#import +#import + + +@implementation DDTTYLogger + +static DDTTYLogger *sharedInstance; + +/** + * The runtime sends initialize to each class in a program exactly one time just before the class, + * or any class that inherits from it, is sent its first message from within the program. (Thus the + * method may never be invoked if the class is not used.) The runtime sends the initialize message to + * classes in a thread-safe manner. Superclasses receive this message before their subclasses. + * + * This method may also be called directly (assumably by accident), hence the safety mechanism. +**/ ++ (void)initialize +{ + static BOOL initialized = NO; + if (!initialized) + { + initialized = YES; + + sharedInstance = [[DDTTYLogger alloc] init]; + } +} + ++ (DDTTYLogger *)sharedInstance +{ + return sharedInstance; +} + +- (id)init +{ + if (sharedInstance != nil) + { + [self release]; + return nil; + } + + if ((self = [super init])) + { + isaTTY = isatty(STDERR_FILENO); + + if (isaTTY) + { + dateFormatter = [[NSDateFormatter alloc] init]; + [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4]; + [dateFormatter setDateFormat:@"yyyy-MM-dd HH:mm:ss:SSS"]; + + // Initialze 'app' variable (char *) + + NSString *appNStr = [[NSProcessInfo processInfo] processName]; + const char *appCStr = [appNStr UTF8String]; + + appLen = strlen(appCStr); + + app = (char *)malloc(appLen); + strncpy(app, appCStr, appLen); // Not null terminated + + // Initialize 'pid' variable (char *) + + NSString *pidNStr = [NSString stringWithFormat:@"%i", (int)getpid()]; + const char *pidCStr = [pidNStr UTF8String]; + + pidLen = strlen(pidCStr); + + pid = (char *)malloc(pidLen); + strncpy(pid, pidCStr, pidLen); // Not null terminated + } + } + return self; +} + +- (void)logMessage:(DDLogMessage *)logMessage +{ + if (!isaTTY) return; + + NSString *logMsg = logMessage->logMsg; + BOOL isFormatted = NO; + + if (formatter) + { + logMsg = [formatter formatLogMessage:logMessage]; + isFormatted = logMsg != logMessage->logMsg; + } + + if (logMsg) + { + const char *msg = [logMsg UTF8String]; + size_t msgLen = strlen(msg); + + if (isFormatted) + { + struct iovec v[2]; + + v[0].iov_base = (char *)msg; + v[0].iov_len = msgLen; + + v[1].iov_base = "\n"; + v[1].iov_len = (msg[msgLen] == '\n') ? 0 : 1; + + writev(STDERR_FILENO, v, 2); + } + else + { + // The following is a highly optimized verion of file output to std err. + + // ts = timestamp + + NSString *tsNStr = [dateFormatter stringFromDate:(logMessage->timestamp)]; + + const char *tsCStr = [tsNStr UTF8String]; + size_t tsLen = strlen(tsCStr); + + // tid = thread id + // + // How many characters do we need for the thread id? + // logMessage->machThreadID is of type mach_port_t, which is an unsigned int. + // + // 1 hex char = 4 bits + // 8 hex chars for 32 bit, plus ending '\0' = 9 + + char tidCStr[9]; + int tidLen = snprintf(tidCStr, 9, "%x", logMessage->machThreadID); + + // Here is our format: "%s %s[%i:%s] %s", timestamp, appName, processID, threadID, logMsg + + struct iovec v[10]; + + v[0].iov_base = (char *)tsCStr; + v[0].iov_len = tsLen; + + v[1].iov_base = " "; + v[1].iov_len = 1; + + v[2].iov_base = app; + v[2].iov_len = appLen; + + v[3].iov_base = "["; + v[3].iov_len = 1; + + v[4].iov_base = pid; + v[4].iov_len = pidLen; + + v[5].iov_base = ":"; + v[5].iov_len = 1; + + v[6].iov_base = tidCStr; + v[6].iov_len = MIN((size_t)8, tidLen); // snprintf doesn't return what you might think + + v[7].iov_base = "] "; + v[7].iov_len = 2; + + v[8].iov_base = (char *)msg; + v[8].iov_len = msgLen; + + v[9].iov_base = "\n"; + v[9].iov_len = (msg[msgLen] == '\n') ? 0 : 1; + + writev(STDERR_FILENO, v, 10); + } + } +} + +- (NSString *)loggerName +{ + return @"cocoa.lumberjack.ttyLogger"; +} + +@end diff --git a/xmpp/Vendor/KissXML/Categories/NSString+DDXML.h b/xmpp/Vendor/KissXML/Categories/NSString+DDXML.h new file mode 100644 index 0000000..f077f90 --- /dev/null +++ b/xmpp/Vendor/KissXML/Categories/NSString+DDXML.h @@ -0,0 +1,14 @@ +#import +#import + + +@interface NSString (DDXML) + +/** + * xmlChar - A basic replacement for char, a byte in a UTF-8 encoded string. +**/ +- (const xmlChar *)xmlChar; + +- (NSString *)stringByTrimming; + +@end diff --git a/xmpp/Vendor/KissXML/Categories/NSString+DDXML.m b/xmpp/Vendor/KissXML/Categories/NSString+DDXML.m new file mode 100644 index 0000000..eefb2be --- /dev/null +++ b/xmpp/Vendor/KissXML/Categories/NSString+DDXML.m @@ -0,0 +1,29 @@ +#import "NSString+DDXML.h" + + +@implementation NSString (DDXML) + +- (const xmlChar *)xmlChar +{ + return (const xmlChar *)[self UTF8String]; +} + +#ifdef GNUSTEP +- (NSString *)stringByTrimming +{ + return [self stringByTrimmingSpaces]; +} +#else +- (NSString *)stringByTrimming +{ + NSMutableString *mStr = [self mutableCopy]; + CFStringTrimWhitespace((CFMutableStringRef)mStr); + + NSString *result = [mStr copy]; + + [mStr release]; + return [result autorelease]; +} +#endif + +@end diff --git a/xmpp/Vendor/KissXML/DDXML.h b/xmpp/Vendor/KissXML/DDXML.h new file mode 100644 index 0000000..788d06d --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXML.h @@ -0,0 +1,91 @@ +#if TARGET_OS_IPHONE + +#import "DDXMLNode.h" +#import "DDXMLElement.h" +#import "DDXMLDocument.h" + +#ifndef NSXMLNode + #define NSXMLNode DDXMLNode +#endif +#ifndef NSXMLElement + #define NSXMLElement DDXMLElement +#endif +#ifndef NSXMLDocument + #define NSXMLDocument DDXMLDocument +#endif + +#ifndef NSXMLInvalidKind + #define NSXMLInvalidKind DDXMLInvalidKind +#endif +#ifndef NSXMLDocumentKind + #define NSXMLDocumentKind DDXMLDocumentKind +#endif +#ifndef NSXMLElementKind + #define NSXMLElementKind DDXMLElementKind +#endif +#ifndef NSXMLAttributeKind + #define NSXMLAttributeKind DDXMLAttributeKind +#endif +#ifndef NSXMLNamespaceKind + #define NSXMLNamespaceKind DDXMLNamespaceKind +#endif +#ifndef NSXMLProcessingInstructionKind + #define NSXMLProcessingInstructionKind DDXMLProcessingInstructionKind +#endif +#ifndef NSXMLCommentKind + #define NSXMLCommentKind DDXMLCommentKind +#endif +#ifndef NSXMLTextKind + #define NSXMLTextKind DDXMLTextKind +#endif +#ifndef NSXMLDTDKind + #define NSXMLDTDKind DDXMLDTDKind +#endif +#ifndef NSXMLEntityDeclarationKind + #define NSXMLEntityDeclarationKind DDXMLEntityDeclarationKind +#endif +#ifndef NSXMLAttributeDeclarationKind + #define NSXMLAttributeDeclarationKind DDXMLAttributeDeclarationKind +#endif +#ifndef NSXMLElementDeclarationKind + #define NSXMLElementDeclarationKind DDXMLElementDeclarationKind +#endif +#ifndef NSXMLNotationDeclarationKind + #define NSXMLNotationDeclarationKind DDXMLNotationDeclarationKind +#endif + +#ifndef NSXMLNodeOptionsNone + #define NSXMLNodeOptionsNone DDXMLNodeOptionsNone +#endif +#ifndef NSXMLNodeExpandEmptyElement + #define NSXMLNodeExpandEmptyElement DDXMLNodeExpandEmptyElement +#endif +#ifndef NSXMLNodeCompactEmptyElement + #define NSXMLNodeCompactEmptyElement DDXMLNodeCompactEmptyElement +#endif +#ifndef NSXMLNodePrettyPrint + #define NSXMLNodePrettyPrint DDXMLNodePrettyPrint +#endif + +// KissXML has rather straight-forward memory management. +// However, if the rules are not followed, +// it is often difficult to track down the culprit. +// +// Enabling this option will help you track down the orphaned subelement. +// More information can be found on the wiki page: +// http://code.google.com/p/kissxml/wiki/MemoryManagementThreadSafety +// +// Please keep in mind that this option is for debugging only. +// It significantly slows down the library, and should NOT be enabled for production builds. +// +// Note: Xcode projects created with Xcode 4 automatically define DEBUG via the project's preprocessor macros. +// If you're not using Xcode 4, or you created the project with a previous version of Xcode, +// you may need to add the DEBUG macro manually. +// +#if DEBUG + #define DDXML_DEBUG_MEMORY_ISSUES 1 +#else + #define DDXML_DEBUG_MEMORY_ISSUES 0 +#endif + +#endif \ No newline at end of file diff --git a/xmpp/Vendor/KissXML/DDXMLDocument.h b/xmpp/Vendor/KissXML/DDXMLDocument.h new file mode 100644 index 0000000..68f1b2e --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLDocument.h @@ -0,0 +1,67 @@ +#import +#import "DDXMLElement.h" +#import "DDXMLNode.h" + + +enum { + DDXMLDocumentXMLKind = 0, + DDXMLDocumentXHTMLKind, + DDXMLDocumentHTMLKind, + DDXMLDocumentTextKind +}; +typedef NSUInteger DDXMLDocumentContentKind; + +@interface DDXMLDocument : DDXMLNode +{ +} + +- (id)initWithXMLString:(NSString *)string options:(NSUInteger)mask error:(NSError **)error; +//- (id)initWithContentsOfURL:(NSURL *)url options:(NSUInteger)mask error:(NSError **)error; +- (id)initWithData:(NSData *)data options:(NSUInteger)mask error:(NSError **)error; +//- (id)initWithRootElement:(DDXMLElement *)element; + +//+ (Class)replacementClassForClass:(Class)cls; + +//- (void)setCharacterEncoding:(NSString *)encoding; //primitive +//- (NSString *)characterEncoding; //primitive + +//- (void)setVersion:(NSString *)version; +//- (NSString *)version; + +//- (void)setStandalone:(BOOL)standalone; +//- (BOOL)isStandalone; + +//- (void)setDocumentContentKind:(DDXMLDocumentContentKind)kind; +//- (DDXMLDocumentContentKind)documentContentKind; + +//- (void)setMIMEType:(NSString *)MIMEType; +//- (NSString *)MIMEType; + +//- (void)setDTD:(DDXMLDTD *)documentTypeDeclaration; +//- (DDXMLDTD *)DTD; + +//- (void)setRootElement:(DDXMLNode *)root; +- (DDXMLElement *)rootElement; + +//- (void)insertChild:(DDXMLNode *)child atIndex:(NSUInteger)index; + +//- (void)insertChildren:(NSArray *)children atIndex:(NSUInteger)index; + +//- (void)removeChildAtIndex:(NSUInteger)index; + +//- (void)setChildren:(NSArray *)children; + +//- (void)addChild:(DDXMLNode *)child; + +//- (void)replaceChildAtIndex:(NSUInteger)index withNode:(DDXMLNode *)node; + +- (NSData *)XMLData; +- (NSData *)XMLDataWithOptions:(NSUInteger)options; + +//- (id)objectByApplyingXSLT:(NSData *)xslt arguments:(NSDictionary *)arguments error:(NSError **)error; +//- (id)objectByApplyingXSLTString:(NSString *)xslt arguments:(NSDictionary *)arguments error:(NSError **)error; +//- (id)objectByApplyingXSLTAtURL:(NSURL *)xsltURL arguments:(NSDictionary *)argument error:(NSError **)error; + +//- (BOOL)validateAndReturnError:(NSError **)error; + +@end diff --git a/xmpp/Vendor/KissXML/DDXMLDocument.m b/xmpp/Vendor/KissXML/DDXMLDocument.m new file mode 100644 index 0000000..c408ac9 --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLDocument.m @@ -0,0 +1,122 @@ +#import "DDXMLPrivate.h" +#import "NSString+DDXML.h" + + +@implementation DDXMLDocument + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ ++ (id)nodeWithDocPrimitive:(xmlDocPtr)doc freeOnDealloc:(BOOL)flag +{ + return [[[DDXMLDocument alloc] initWithDocPrimitive:doc freeOnDealloc:flag] autorelease]; +} + +- (id)initWithDocPrimitive:(xmlDocPtr)doc freeOnDealloc:(BOOL)flag +{ + self = [super initWithPrimitive:(xmlKindPtr)doc freeOnDealloc:flag]; + return self; +} + ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes + NSAssert(NO, @"Use nodeWithDocPrimitive:freeOnDealloc:"); + + return nil; +} + +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use initWithDocPrimitive:freeOnDealloc:"); + + [self release]; + return nil; +} + +/** + * Initializes and returns a DDXMLDocument object created from an NSData object. + * + * Returns an initialized DDXMLDocument object, or nil if initialization fails + * because of parsing errors or other reasons. +**/ +- (id)initWithXMLString:(NSString *)string options:(NSUInteger)mask error:(NSError **)error +{ + return [self initWithData:[string dataUsingEncoding:NSUTF8StringEncoding] + options:mask + error:error]; +} + +/** + * Initializes and returns a DDXMLDocument object created from an NSData object. + * + * Returns an initialized DDXMLDocument object, or nil if initialization fails + * because of parsing errors or other reasons. +**/ +- (id)initWithData:(NSData *)data options:(NSUInteger)mask error:(NSError **)error +{ + if (data == nil || [data length] == 0) + { + if (error) *error = [NSError errorWithDomain:@"DDXMLErrorDomain" code:0 userInfo:nil]; + + [self release]; + return nil; + } + + // Even though xmlKeepBlanksDefault(0) is called in DDXMLNode's initialize method, + // it has been documented that this call seems to get reset on the iPhone: + // http://code.google.com/p/kissxml/issues/detail?id=8 + // + // Therefore, we call it again here just to be safe. + xmlKeepBlanksDefault(0); + + xmlDocPtr doc = xmlParseMemory([data bytes], [data length]); + if (doc == NULL) + { + if (error) *error = [NSError errorWithDomain:@"DDXMLErrorDomain" code:1 userInfo:nil]; + + [self release]; + return nil; + } + + return [self initWithDocPrimitive:doc freeOnDealloc:YES]; +} + +/** + * Returns the root element of the receiver. +**/ +- (DDXMLElement *)rootElement +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlDocPtr doc = (xmlDocPtr)genericPtr; + + // doc->children is a list containing possibly comments, DTDs, etc... + + xmlNodePtr rootNode = xmlDocGetRootElement(doc); + + if (rootNode != NULL) + return [DDXMLElement nodeWithElementPrimitive:rootNode freeOnDealloc:NO]; + else + return nil; +} + +- (NSData *)XMLData +{ + // Zombie test occurs in XMLString + + return [[self XMLString] dataUsingEncoding:NSUTF8StringEncoding]; +} + +- (NSData *)XMLDataWithOptions:(NSUInteger)options +{ + // Zombie test occurs in XMLString + + return [[self XMLStringWithOptions:options] dataUsingEncoding:NSUTF8StringEncoding]; +} + +@end diff --git a/xmpp/Vendor/KissXML/DDXMLElement.h b/xmpp/Vendor/KissXML/DDXMLElement.h new file mode 100644 index 0000000..8b50789 --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLElement.h @@ -0,0 +1,49 @@ +#import +#import "DDXMLNode.h" + + +@interface DDXMLElement : DDXMLNode +{ +} + +- (id)initWithName:(NSString *)name; +- (id)initWithName:(NSString *)name URI:(NSString *)URI; +- (id)initWithName:(NSString *)name stringValue:(NSString *)string; +- (id)initWithXMLString:(NSString *)string error:(NSError **)error; + +#pragma mark --- Elements by name --- + +- (NSArray *)elementsForName:(NSString *)name; +- (NSArray *)elementsForLocalName:(NSString *)localName URI:(NSString *)URI; + +#pragma mark --- Attributes --- + +- (void)addAttribute:(DDXMLNode *)attribute; +- (void)removeAttributeForName:(NSString *)name; +- (void)setAttributes:(NSArray *)attributes; +//- (void)setAttributesAsDictionary:(NSDictionary *)attributes; +- (NSArray *)attributes; +- (DDXMLNode *)attributeForName:(NSString *)name; +//- (DDXMLNode *)attributeForLocalName:(NSString *)localName URI:(NSString *)URI; + +#pragma mark --- Namespaces --- + +- (void)addNamespace:(DDXMLNode *)aNamespace; +- (void)removeNamespaceForPrefix:(NSString *)name; +- (void)setNamespaces:(NSArray *)namespaces; +- (NSArray *)namespaces; +- (DDXMLNode *)namespaceForPrefix:(NSString *)prefix; +- (DDXMLNode *)resolveNamespaceForName:(NSString *)name; +- (NSString *)resolvePrefixForNamespaceURI:(NSString *)namespaceURI; + +#pragma mark --- Children --- + +- (void)insertChild:(DDXMLNode *)child atIndex:(NSUInteger)index; +//- (void)insertChildren:(NSArray *)children atIndex:(NSUInteger)index; +- (void)removeChildAtIndex:(NSUInteger)index; +- (void)setChildren:(NSArray *)children; +- (void)addChild:(DDXMLNode *)child; +//- (void)replaceChildAtIndex:(NSUInteger)index withNode:(DDXMLNode *)node; +//- (void)normalizeAdjacentTextNodesPreservingCDATA:(BOOL)preserve; + +@end diff --git a/xmpp/Vendor/KissXML/DDXMLElement.m b/xmpp/Vendor/KissXML/DDXMLElement.m new file mode 100644 index 0000000..0461c9b --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLElement.m @@ -0,0 +1,774 @@ +#import "DDXMLPrivate.h" +#import "NSString+DDXML.h" + + +@implementation DDXMLElement + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ ++ (id)nodeWithElementPrimitive:(xmlNodePtr)node freeOnDealloc:(BOOL)flag +{ + return [[[DDXMLElement alloc] initWithElementPrimitive:node freeOnDealloc:flag] autorelease]; +} + +- (id)initWithElementPrimitive:(xmlNodePtr)node freeOnDealloc:(BOOL)flag +{ + self = [super initWithPrimitive:(xmlKindPtr)node freeOnDealloc:flag]; + return self; +} + ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes + NSAssert(NO, @"Use nodeWithElementPrimitive:freeOnDealloc:"); + + return nil; +} + +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use initWithElementPrimitive:freeOnDealloc:"); + + [self release]; + return nil; +} + +- (id)initWithName:(NSString *)name +{ + // Note: Make every guarantee that genericPtr is not null + + xmlNodePtr node = xmlNewNode(NULL, [name xmlChar]); + if (node == NULL) + { + [self release]; + return nil; + } + + return [self initWithElementPrimitive:node freeOnDealloc:YES]; +} + +- (id)initWithName:(NSString *)name URI:(NSString *)URI +{ + // Note: Make every guarantee that genericPtr is not null + + xmlNodePtr node = xmlNewNode(NULL, [name xmlChar]); + if (node == NULL) + { + [self release]; + return nil; + } + + DDXMLElement *result = [self initWithElementPrimitive:node freeOnDealloc:YES]; + [result setURI:URI]; + + return result; +} + +- (id)initWithName:(NSString *)name stringValue:(NSString *)string +{ + // Note: Make every guarantee that genericPtr is not null + + xmlNodePtr node = xmlNewNode(NULL, [name xmlChar]); + if (node == NULL) + { + [self release]; + return nil; + } + + DDXMLElement *result = [self initWithElementPrimitive:node freeOnDealloc:YES]; + [result setStringValue:string]; + + return result; +} + +- (id)initWithXMLString:(NSString *)string error:(NSError **)error +{ + DDXMLDocument *doc = [[DDXMLDocument alloc] initWithXMLString:string options:0 error:error]; + if (doc == nil) + { + [self release]; + return nil; + } + + DDXMLElement *result = [doc rootElement]; + [result detach]; + [doc release]; + + [self release]; + return [result retain]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Elements by name +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the child element nodes (as DDXMLElement objects) of the receiver that have a specified name. + * + * If name is a qualified name, then this method invokes elementsForLocalName:URI: with the URI parameter set to + * the URI associated with the prefix. Otherwise comparison is based on string equality of the qualified or + * non-qualified name. +**/ +- (NSArray *)elementsForName:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (name == nil) return [NSArray array]; + + // We need to check to see if name has a prefix. + // If it does have a prefix, we need to figure out what the corresponding URI is for that prefix, + // and then search for any elements that have the same name (including prefix) OR have the same URI. + // Otherwise we loop through the children as usual and do a string compare on the name + + NSString *prefix = [[self class] prefixForName:name]; + if ([prefix length] > 0) + { + xmlNodePtr node = (xmlNodePtr)genericPtr; + xmlNsPtr ns = xmlSearchNs(node->doc, node, [prefix xmlChar]); + if (ns != NULL) + { + NSString *uri = [NSString stringWithUTF8String:((const char *)ns->href)]; + return [self _elementsForName:name uri:uri]; + } + + // Note: We used xmlSearchNs instead of resolveNamespaceForName: because + // we want to avoid creating wrapper objects when possible. + } + + return [self _elementsForName:name uri:nil]; +} + +- (NSArray *)elementsForLocalName:(NSString *)localName URI:(NSString *)URI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (localName == nil) return [NSArray array]; + + // We need to figure out what the prefix is for this URI. + // Then we search for elements that are named prefix:localName OR (named localName AND have the given URI). + + NSString *prefix = [[self class] resolvePrefixForURI:URI atNode:(xmlNodePtr)genericPtr]; + if (prefix != nil) + { + NSString *name = [NSString stringWithFormat:@"%@:%@", prefix, localName]; + + return [self _elementsForName:name uri:URI]; + } + else + { + return [self _elementsForName:localName uri:URI]; + } +} + +/** + * Helper method elementsForName and elementsForLocalName:URI: so work isn't duplicated. + * The name parameter is required, URI is optional. +**/ +- (NSArray *)_elementsForName:(NSString *)name uri:(NSString *)uri +{ + // This is a private/internal method + + // Supplied: name, !uri : match: name + // Supplied: p:name, uri : match: p:name || (name && uri) + // Supplied: name, uri : match: name && uri + + NSMutableArray *result = [NSMutableArray array]; + + xmlNodePtr node = (xmlNodePtr)genericPtr; + + BOOL hasPrefix = [[[self class] prefixForName:name] length] > 0; + NSString *localName = [[self class] localNameForName:name]; + + xmlNodePtr child = node->children; + while (child != NULL) + { + if (child->type == XML_ELEMENT_NODE) + { + BOOL match = NO; + if (uri == nil) + { + match = xmlStrEqual(child->name, [name xmlChar]); + } + else + { + BOOL nameMatch = xmlStrEqual(child->name, [name xmlChar]); + BOOL localNameMatch = xmlStrEqual(child->name, [localName xmlChar]); + + BOOL uriMatch = NO; + if (child->ns != NULL) + { + uriMatch = xmlStrEqual(child->ns->href, [uri xmlChar]); + } + + if (hasPrefix) + match = nameMatch || (localNameMatch && uriMatch); + else + match = nameMatch && uriMatch; + } + + if (match) + { + [result addObject:[DDXMLElement nodeWithElementPrimitive:child freeOnDealloc:NO]]; + } + } + + child = child->next; + } + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Attributes +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)_hasAttributeWithName:(NSString *)name +{ + // This is a private/internal method + + xmlAttrPtr attr = ((xmlNodePtr)genericPtr)->properties; + if (attr != NULL) + { + const xmlChar *xmlName = [name xmlChar]; + + do + { + if (xmlStrEqual(attr->name, xmlName)) + { + return YES; + } + attr = attr->next; + + } while (attr != NULL); + } + + return NO; +} + +- (void)_removeAttribute:(xmlAttrPtr)attr +{ + // This is a private/internal method + + [[self class] removeAttribute:attr fromNode:(xmlNodePtr)genericPtr]; +} + +- (void)_removeAllAttributes +{ + // This is a private/internal method + + [[self class] removeAllAttributesFromNode:(xmlNodePtr)genericPtr]; +} + +- (void)_removeAttributeForName:(NSString *)name +{ + xmlAttrPtr attr = ((xmlNodePtr)genericPtr)->properties; + if (attr != NULL) + { + const xmlChar *xmlName = [name xmlChar]; + + do + { + if (xmlStrEqual(attr->name, xmlName)) + { + [self _removeAttribute:attr]; + return; + } + attr = attr->next; + + } while(attr != NULL); + } +} + +- (void)addAttribute:(DDXMLNode *)attribute +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // NSXML version uses this same assertion + DDXMLAssert([attribute _hasParent] == NO, @"Cannot add an attribute with a parent; detach or copy first"); + DDXMLAssert(IsXmlAttrPtr(attribute->genericPtr), @"Not an attribute"); + + [self _removeAttributeForName:[attribute name]]; + + // xmlNodePtr xmlAddChild(xmlNodePtr parent, xmlNodePtr cur) + // Add a new node to @parent, at the end of the child (or property) list merging + // adjacent TEXT nodes (in which case @cur is freed). If the new node is ATTRIBUTE, it is added + // into properties instead of children. If there is an attribute with equal name, it is first destroyed. + + xmlAddChild((xmlNodePtr)genericPtr, (xmlNodePtr)attribute->genericPtr); + + // The attribute is now part of the xml tree heirarchy + attribute->freeOnDealloc = NO; +} + +- (void)removeAttributeForName:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [self _removeAttributeForName:name]; +} + +- (NSArray *)attributes +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSMutableArray *result = [NSMutableArray array]; + + xmlAttrPtr attr = ((xmlNodePtr)genericPtr)->properties; + while (attr != NULL) + { + [result addObject:[DDXMLAttributeNode nodeWithAttrPrimitive:attr freeOnDealloc:NO]]; + + attr = attr->next; + } + + return result; +} + +- (DDXMLNode *)attributeForName:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + const xmlChar *attrName = [name xmlChar]; + + xmlAttrPtr attr = ((xmlNodePtr)genericPtr)->properties; + while (attr != NULL) + { + if (attr->ns && attr->ns->prefix) + { + // If the attribute name was originally something like "xml:quack", + // then attr->name is "quack" and attr->ns->prefix is "xml". + // + // So if the user is searching for "xml:quack" we need to take the prefix into account. + // Note that "xml:quack" is what would be printed if we output the attribute. + + if (xmlStrQEqual(attr->ns->prefix, attr->name, attrName)) + { + return [DDXMLAttributeNode nodeWithAttrPrimitive:attr freeOnDealloc:NO]; + } + } + else + { + if (xmlStrEqual(attr->name, attrName)) + { + return [DDXMLAttributeNode nodeWithAttrPrimitive:attr freeOnDealloc:NO]; + } + } + + attr = attr->next; + } + return nil; +} + +/** + * Sets the list of attributes for the element. + * Any previously set attributes are removed. +**/ +- (void)setAttributes:(NSArray *)attributes +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [self _removeAllAttributes]; + + NSUInteger i; + for (i = 0; i < [attributes count]; i++) + { + DDXMLNode *attribute = [attributes objectAtIndex:i]; + [self addAttribute:attribute]; + + // Note: The addAttributes method properly sets the freeOnDealloc ivar. + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Namespaces +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)_removeNamespace:(xmlNsPtr)ns +{ + // This is a private/internal method + + [[self class] removeNamespace:ns fromNode:(xmlNodePtr)genericPtr]; +} + +- (void)_removeAllNamespaces +{ + // This is a private/internal method + + [[self class] removeAllNamespacesFromNode:(xmlNodePtr)genericPtr]; +} + +- (void)_removeNamespaceForPrefix:(NSString *)name +{ + // If name is nil or the empty string, the user is wishing to remove the default namespace + const xmlChar *xmlName = [name length] > 0 ? [name xmlChar] : NULL; + + xmlNsPtr ns = ((xmlNodePtr)genericPtr)->nsDef; + while (ns != NULL) + { + if (xmlStrEqual(ns->prefix, xmlName)) + { + [self _removeNamespace:ns]; + break; + } + ns = ns->next; + } + + // Note: The removeNamespace method properly handles the situation where the namespace is the default namespace +} + +- (void)_addNamespace:(DDXMLNode *)namespace +{ + // NSXML version uses this same assertion + DDXMLAssert([namespace _hasParent] == NO, @"Cannot add a namespace with a parent; detach or copy first"); + DDXMLAssert(IsXmlNsPtr(namespace->genericPtr), @"Not a namespace"); + + xmlNodePtr node = (xmlNodePtr)genericPtr; + xmlNsPtr ns = (xmlNsPtr)namespace->genericPtr; + + // Beware: [namespace prefix] does NOT return what you might expect. Use [namespace name] instead. + + NSString *namespaceName = [namespace name]; + + [self _removeNamespaceForPrefix:namespaceName]; + + xmlNsPtr currentNs = node->nsDef; + if (currentNs == NULL) + { + node->nsDef = ns; + } + else + { + while (currentNs->next != NULL) + { + currentNs = currentNs->next; + } + + currentNs->next = ns; + } + + // The namespace is now part of the xml tree heirarchy + namespace->freeOnDealloc = NO; + + if ([namespace isKindOfClass:[DDXMLNamespaceNode class]]) + { + DDXMLNamespaceNode *ddNamespace = (DDXMLNamespaceNode *)namespace; + + // The xmlNs structure doesn't contain a reference to the parent, so we manage our own reference + [ddNamespace _setNsParentPtr:node]; + } + + // Did we just add a default namespace + if ([namespaceName isEqualToString:@""]) + { + node->ns = ns; + + // Note: The removeNamespaceForPrefix method above properly handled removing any previous default namespace + } +} + +- (void)addNamespace:(DDXMLNode *)namespace +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [self _addNamespace:namespace]; +} + +- (void)removeNamespaceForPrefix:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [self _removeNamespaceForPrefix:name]; +} + +- (NSArray *)namespaces +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSMutableArray *result = [NSMutableArray array]; + + xmlNsPtr ns = ((xmlNodePtr)genericPtr)->nsDef; + while (ns != NULL) + { + [result addObject:[DDXMLNamespaceNode nodeWithNsPrimitive:ns nsParent:(xmlNodePtr)genericPtr freeOnDealloc:NO]]; + + ns = ns->next; + } + + return result; +} + +- (DDXMLNode *)namespaceForPrefix:(NSString *)prefix +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // If the prefix is nil or the empty string, the user is requesting the default namespace + + if ([prefix length] == 0) + { + // Requesting the default namespace + xmlNsPtr ns = ((xmlNodePtr)genericPtr)->ns; + if (ns != NULL) + { + return [DDXMLNamespaceNode nodeWithNsPrimitive:ns nsParent:(xmlNodePtr)genericPtr freeOnDealloc:NO]; + } + } + else + { + xmlNsPtr ns = ((xmlNodePtr)genericPtr)->nsDef; + while (ns != NULL) + { + if (xmlStrEqual(ns->prefix, [prefix xmlChar])) + { + return [DDXMLNamespaceNode nodeWithNsPrimitive:ns nsParent:(xmlNodePtr)genericPtr freeOnDealloc:NO]; + } + ns = ns->next; + } + } + + return nil; +} + +- (void)setNamespaces:(NSArray *)namespaces +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [self _removeAllNamespaces]; + + NSUInteger i; + for (i = 0; i < [namespaces count]; i++) + { + DDXMLNode *namespace = [namespaces objectAtIndex:i]; + [self _addNamespace:namespace]; + + // Note: The addNamespace method properly sets the freeOnDealloc ivar. + } +} + +/** + * Recursively searches the given node for the given namespace +**/ ++ (DDXMLNode *)resolveNamespaceForPrefix:(NSString *)prefix atNode:(xmlNodePtr)nodePtr +{ + // This is a private/internal method + + if (nodePtr == NULL) return nil; + + xmlNsPtr ns = nodePtr->nsDef; + while (ns != NULL) + { + if (xmlStrEqual(ns->prefix, [prefix xmlChar])) + { + return [DDXMLNamespaceNode nodeWithNsPrimitive:ns nsParent:nodePtr freeOnDealloc:NO]; + } + ns = ns->next; + } + + return [self resolveNamespaceForPrefix:prefix atNode:nodePtr->parent]; +} + +/** + * Returns the namespace node with the prefix matching the given qualified name. + * Eg: You pass it "a:dog", it returns the namespace (defined in this node or parent nodes) that has the "a" prefix. +**/ +- (DDXMLNode *)resolveNamespaceForName:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // If the user passes nil or an empty string for name, they're looking for the default namespace. + if ([name length] == 0) + { + return [[self class] resolveNamespaceForPrefix:nil atNode:(xmlNodePtr)genericPtr]; + } + + NSString *prefix = [[self class] prefixForName:name]; + + if ([prefix length] > 0) + { + // Unfortunately we can't use xmlSearchNs because it returns an xmlNsPtr. + // This gives us mostly what we want, except we also need to know the nsParent. + // So we do the recursive search ourselves. + + return [[self class] resolveNamespaceForPrefix:prefix atNode:(xmlNodePtr)genericPtr]; + } + + return nil; +} + +/** + * Recursively searches the given node for a namespace with the given URI, and a set prefix. +**/ ++ (NSString *)resolvePrefixForURI:(NSString *)uri atNode:(xmlNodePtr)nodePtr +{ + // This is a private/internal method + + if (nodePtr == NULL) return nil; + + xmlNsPtr ns = nodePtr->nsDef; + while (ns != NULL) + { + if (xmlStrEqual(ns->href, [uri xmlChar])) + { + if (ns->prefix != NULL) + { + return [NSString stringWithUTF8String:((const char *)ns->prefix)]; + } + } + ns = ns->next; + } + + return [self resolvePrefixForURI:uri atNode:nodePtr->parent]; +} + +/** + * Returns the prefix associated with the specified URI. + * Returns a string that is the matching prefix or nil if it finds no matching prefix. +**/ +- (NSString *)resolvePrefixForNamespaceURI:(NSString *)namespaceURI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // We can't use xmlSearchNsByHref because it will return xmlNsPtr's with NULL prefixes. + // We're looking for a definitive prefix for the given URI. + + return [[self class] resolvePrefixForURI:namespaceURI atNode:(xmlNodePtr)genericPtr]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Children +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)addChild:(DDXMLNode *)child +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // NSXML version uses these same assertions + DDXMLAssert([child _hasParent] == NO, @"Cannot add a child that has a parent; detach or copy first"); + DDXMLAssert(IsXmlNodePtr(child->genericPtr), + @"Elements can only have text, elements, processing instructions, and comments as children"); + + xmlAddChild((xmlNodePtr)genericPtr, (xmlNodePtr)child->genericPtr); + + // The node is now part of the xml tree heirarchy + child->freeOnDealloc = NO; +} + +- (void)insertChild:(DDXMLNode *)child atIndex:(NSUInteger)index +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // NSXML version uses these same assertions + DDXMLAssert([child _hasParent] == NO, @"Cannot add a child that has a parent; detach or copy first"); + DDXMLAssert(IsXmlNodePtr(child->genericPtr), + @"Elements can only have text, elements, processing instructions, and comments as children"); + + NSUInteger i = 0; + + xmlNodePtr childNodePtr = ((xmlNodePtr)genericPtr)->children; + while (childNodePtr != NULL) + { + // Ignore all but element, comment, text, or processing instruction nodes + if (IsXmlNodePtr(childNodePtr)) + { + if (i == index) + { + xmlAddPrevSibling(childNodePtr, (xmlNodePtr)child->genericPtr); + child->freeOnDealloc = NO; + return; + } + + i++; + } + childNodePtr = childNodePtr->next; + } + + if (i == index) + { + xmlAddChild((xmlNodePtr)genericPtr, (xmlNodePtr)child->genericPtr); + child->freeOnDealloc = NO; + return; + } + + // NSXML version uses this same assertion + DDXMLAssert(NO, @"index (%u) beyond bounds (%u)", (unsigned)index, (unsigned)++i); +} + +- (void)removeChildAtIndex:(NSUInteger)index +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSUInteger i = 0; + + xmlNodePtr child = ((xmlNodePtr)genericPtr)->children; + while (child != NULL) + { + // Ignore all but element, comment, text, or processing instruction nodes + if (IsXmlNodePtr(child)) + { + if (i == index) + { + [DDXMLNode removeChild:child fromNode:(xmlNodePtr)genericPtr]; + return; + } + + i++; + } + child = child->next; + } +} + +- (void)setChildren:(NSArray *)children +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + [DDXMLNode removeAllChildrenFromNode:(xmlNodePtr)genericPtr]; + + NSUInteger i; + for (i = 0; i < [children count]; i++) + { + DDXMLNode *child = [children objectAtIndex:i]; + [self addChild:child]; + + // Note: The addChild method properly sets the freeOnDealloc ivar. + } +} + +@end diff --git a/xmpp/Vendor/KissXML/DDXMLNode.h b/xmpp/Vendor/KissXML/DDXMLNode.h new file mode 100644 index 0000000..cce0430 --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLNode.h @@ -0,0 +1,136 @@ +#import +#import + +@class DDXMLDocument; + + +enum { + DDXMLInvalidKind = 0, + DDXMLDocumentKind = XML_DOCUMENT_NODE, + DDXMLElementKind = XML_ELEMENT_NODE, + DDXMLAttributeKind = XML_ATTRIBUTE_NODE, + DDXMLNamespaceKind = XML_NAMESPACE_DECL, + DDXMLProcessingInstructionKind = XML_PI_NODE, + DDXMLCommentKind = XML_COMMENT_NODE, + DDXMLTextKind = XML_TEXT_NODE, + DDXMLDTDKind = XML_DTD_NODE, + DDXMLEntityDeclarationKind = XML_ENTITY_DECL, + DDXMLAttributeDeclarationKind = XML_ATTRIBUTE_DECL, + DDXMLElementDeclarationKind = XML_ELEMENT_DECL, + DDXMLNotationDeclarationKind = XML_NOTATION_NODE +}; +typedef NSUInteger DDXMLNodeKind; + +enum { + DDXMLNodeOptionsNone = 0, + DDXMLNodeExpandEmptyElement = 1 << 1, + DDXMLNodeCompactEmptyElement = 1 << 2, + DDXMLNodePrettyPrint = 1 << 17, +}; + + +//extern struct _xmlKind; + + +@interface DDXMLNode : NSObject +{ + // Every DDXML object is simply a wrapper around an underlying libxml node + struct _xmlKind *genericPtr; + + // Root nodes free the underlying libxml node on dealloc. + BOOL freeOnDealloc; +} + +//- (id)initWithKind:(DDXMLNodeKind)kind; + +//- (id)initWithKind:(DDXMLNodeKind)kind options:(NSUInteger)options; + +//+ (id)document; + +//+ (id)documentWithRootElement:(DDXMLElement *)element; + ++ (id)elementWithName:(NSString *)name; + ++ (id)elementWithName:(NSString *)name URI:(NSString *)URI; + ++ (id)elementWithName:(NSString *)name stringValue:(NSString *)string; + ++ (id)elementWithName:(NSString *)name children:(NSArray *)children attributes:(NSArray *)attributes; + ++ (id)attributeWithName:(NSString *)name stringValue:(NSString *)stringValue; + ++ (id)attributeWithName:(NSString *)name URI:(NSString *)URI stringValue:(NSString *)stringValue; + ++ (id)namespaceWithName:(NSString *)name stringValue:(NSString *)stringValue; + ++ (id)processingInstructionWithName:(NSString *)name stringValue:(NSString *)stringValue; + ++ (id)commentWithStringValue:(NSString *)stringValue; + ++ (id)textWithStringValue:(NSString *)stringValue; + +//+ (id)DTDNodeWithXMLString:(NSString *)string; + +#pragma mark --- Properties --- + +- (DDXMLNodeKind)kind; + +- (void)setName:(NSString *)name; +- (NSString *)name; + +//- (void)setObjectValue:(id)value; +//- (id)objectValue; + +- (void)setStringValue:(NSString *)string; +//- (void)setStringValue:(NSString *)string resolvingEntities:(BOOL)resolve; +- (NSString *)stringValue; + +#pragma mark --- Tree Navigation --- + +- (NSUInteger)index; + +- (NSUInteger)level; + +- (DDXMLDocument *)rootDocument; + +- (DDXMLNode *)parent; +- (NSUInteger)childCount; +- (NSArray *)children; +- (DDXMLNode *)childAtIndex:(NSUInteger)index; + +- (DDXMLNode *)previousSibling; +- (DDXMLNode *)nextSibling; + +- (DDXMLNode *)previousNode; +- (DDXMLNode *)nextNode; + +- (void)detach; + +- (NSString *)XPath; + +#pragma mark --- QNames --- + +- (NSString *)localName; +- (NSString *)prefix; + +- (void)setURI:(NSString *)URI; +- (NSString *)URI; + ++ (NSString *)localNameForName:(NSString *)name; ++ (NSString *)prefixForName:(NSString *)name; +//+ (DDXMLNode *)predefinedNamespaceForPrefix:(NSString *)name; + +#pragma mark --- Output --- + +- (NSString *)description; +- (NSString *)XMLString; +- (NSString *)XMLStringWithOptions:(NSUInteger)options; +//- (NSString *)canonicalXMLStringPreservingComments:(BOOL)comments; + +#pragma mark --- XPath/XQuery --- + +- (NSArray *)nodesForXPath:(NSString *)xpath error:(NSError **)error; +//- (NSArray *)objectsForXQuery:(NSString *)xquery constants:(NSDictionary *)constants error:(NSError **)error; +//- (NSArray *)objectsForXQuery:(NSString *)xquery error:(NSError **)error; + +@end diff --git a/xmpp/Vendor/KissXML/DDXMLNode.m b/xmpp/Vendor/KissXML/DDXMLNode.m new file mode 100644 index 0000000..d8183dd --- /dev/null +++ b/xmpp/Vendor/KissXML/DDXMLNode.m @@ -0,0 +1,2331 @@ +#import "DDXMLPrivate.h" +#import "NSString+DDXML.h" + +#import +#import + + +@implementation DDXMLNode + +static void MyErrorHandler(void * userData, xmlErrorPtr error); + +#if DDXML_DEBUG_MEMORY_ISSUES + +static CFMutableDictionaryRef zombieTracker; +static dispatch_queue_t zombieQueue; + +static void RecursiveMarkZombiesFromNode(xmlNodePtr node); +static void RecursiveMarkZombiesFromDoc(xmlDocPtr doc); + +static void MarkZombies(void *xmlPtr); +static void MarkBirth(void *xmlPtr, DDXMLNode *wrapper); +static void MarkDeath(void *xmlPtr, DDXMLNode *wrapper); + +#endif + ++ (void)initialize +{ + static BOOL initialized = NO; + if (!initialized) + { + initialized = YES; + + // Redirect error output to our own function (don't clog up the console) + initGenericErrorDefaultFunc(NULL); + xmlSetStructuredErrorFunc(NULL, MyErrorHandler); + + // Tell libxml not to keep ignorable whitespace (such as node indentation, formatting, etc). + // NSXML ignores such whitespace. + // This also has the added benefit of taking up less RAM when parsing formatted XML documents. + xmlKeepBlanksDefault(0); + + #if DDXML_DEBUG_MEMORY_ISSUES + + zombieTracker = CFDictionaryCreateMutable(NULL, 0, NULL, &kCFTypeDictionaryValueCallBacks); + zombieQueue = dispatch_queue_create("DDXMLZombieQueue", NULL); + + #endif + } +} + ++ (id)elementWithName:(NSString *)name +{ + return [[[DDXMLElement alloc] initWithName:name] autorelease]; +} + ++ (id)elementWithName:(NSString *)name stringValue:(NSString *)string +{ + return [[[DDXMLElement alloc] initWithName:name stringValue:string] autorelease]; +} + ++ (id)elementWithName:(NSString *)name children:(NSArray *)children attributes:(NSArray *)attributes +{ + DDXMLElement *result = [[[DDXMLElement alloc] initWithName:name] autorelease]; + [result setChildren:children]; + [result setAttributes:attributes]; + + return result; +} + ++ (id)elementWithName:(NSString *)name URI:(NSString *)URI +{ + return [[[DDXMLElement alloc] initWithName:name URI:URI] autorelease]; +} + ++ (id)attributeWithName:(NSString *)name stringValue:(NSString *)stringValue +{ + xmlAttrPtr attr = xmlNewProp(NULL, [name xmlChar], [stringValue xmlChar]); + + if (attr == NULL) return nil; + + return [[[DDXMLAttributeNode alloc] initWithAttrPrimitive:attr freeOnDealloc:YES] autorelease]; +} + ++ (id)attributeWithName:(NSString *)name URI:(NSString *)URI stringValue:(NSString *)stringValue +{ + xmlAttrPtr attr = xmlNewProp(NULL, [name xmlChar], [stringValue xmlChar]); + + if (attr == NULL) return nil; + + DDXMLAttributeNode *result = [[DDXMLAttributeNode alloc] initWithAttrPrimitive:attr freeOnDealloc:YES]; + [result setURI:URI]; + + return [result autorelease]; +} + ++ (id)namespaceWithName:(NSString *)name stringValue:(NSString *)stringValue +{ + // If the user passes a nil or empty string name, they are trying to create a default namespace + const xmlChar *xmlName = [name length] > 0 ? [name xmlChar] : NULL; + + xmlNsPtr ns = xmlNewNs(NULL, [stringValue xmlChar], xmlName); + + if (ns == NULL) return nil; + + return [[[DDXMLNamespaceNode alloc] initWithNsPrimitive:ns nsParent:NULL freeOnDealloc:YES] autorelease]; +} + ++ (id)processingInstructionWithName:(NSString *)name stringValue:(NSString *)stringValue +{ + xmlNodePtr procInst = xmlNewPI([name xmlChar], [stringValue xmlChar]); + + if (procInst == NULL) return nil; + + return [[[DDXMLNode alloc] initWithPrimitive:(xmlKindPtr)procInst freeOnDealloc:YES] autorelease]; +} + ++ (id)commentWithStringValue:(NSString *)stringValue +{ + xmlNodePtr comment = xmlNewComment([stringValue xmlChar]); + + if (comment == NULL) return nil; + + return [[[DDXMLNode alloc] initWithPrimitive:(xmlKindPtr)comment freeOnDealloc:YES] autorelease]; +} + ++ (id)textWithStringValue:(NSString *)stringValue +{ + xmlNodePtr text = xmlNewText([stringValue xmlChar]); + + if (text == NULL) return nil; + + return [[[DDXMLNode alloc] initWithPrimitive:(xmlKindPtr)text freeOnDealloc:YES] autorelease]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Init, Dealloc +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + ++ (id)nodeWithUnknownPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + if (kindPtr->type == XML_DOCUMENT_NODE) + { + return [DDXMLDocument nodeWithDocPrimitive:(xmlDocPtr)kindPtr freeOnDealloc:flag]; + } + else if (kindPtr->type == XML_ELEMENT_NODE) + { + return [DDXMLElement nodeWithElementPrimitive:(xmlNodePtr)kindPtr freeOnDealloc:flag]; + } + else if (kindPtr->type == XML_NAMESPACE_DECL) + { + // Todo: This may be a problem... + + return [DDXMLNamespaceNode nodeWithNsPrimitive:(xmlNsPtr)kindPtr nsParent:NULL freeOnDealloc:flag]; + } + else if (kindPtr->type == XML_ATTRIBUTE_NODE) + { + return [DDXMLAttributeNode nodeWithAttrPrimitive:(xmlAttrPtr)kindPtr freeOnDealloc:flag]; + } + else + { + return [DDXMLNode nodeWithPrimitive:kindPtr freeOnDealloc:flag]; + } +} + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + return [[[DDXMLNode alloc] initWithPrimitive:kindPtr freeOnDealloc:flag] autorelease]; +} + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + if ((self = [super init])) + { + genericPtr = kindPtr; + freeOnDealloc = flag; + + #if DDXML_DEBUG_MEMORY_ISSUES + MarkBirth(genericPtr, self); + #endif + } + return self; +} + +- (void)dealloc +{ +#if DDXML_DEBUG_MEMORY_ISSUES + MarkDeath(genericPtr, self); +#endif + + // We also check if genericPtr is NULL. + // This may be the case if, e.g., DDXMLElement calls [self release] from it's init method. + + if (freeOnDealloc && (genericPtr != NULL)) + { + if (IsXmlNsPtr(genericPtr)) + { + #if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(genericPtr); + #endif + xmlFreeNs((xmlNsPtr)genericPtr); + } + else if (IsXmlAttrPtr(genericPtr)) + { + #if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(genericPtr); + #endif + xmlFreeProp((xmlAttrPtr)genericPtr); + } + else if (IsXmlDtdPtr(genericPtr)) + { + #if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(genericPtr); + #endif + xmlFreeDtd((xmlDtdPtr)genericPtr); + } + else if (IsXmlDocPtr(genericPtr)) + { + xmlDocPtr doc = (xmlDocPtr)genericPtr; + + #if DDXML_DEBUG_MEMORY_ISSUES + RecursiveMarkZombiesFromDoc(doc); + #endif + xmlFreeDoc(doc); + } + else if (IsXmlNodePtr(genericPtr)) + { + xmlNodePtr node = (xmlNodePtr)genericPtr; + + #if DDXML_DEBUG_MEMORY_ISSUES + RecursiveMarkZombiesFromNode(node); + #endif + xmlFreeNode(node); + } + else + { + NSAssert1(NO, @"Cannot free unknown node type: %i", ((xmlKindPtr)genericPtr)->type); + } + } + [super dealloc]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Copying +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (id)copyWithZone:(NSZone *)zone +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (IsXmlDocPtr(genericPtr)) + { + xmlDocPtr copyDocPtr = xmlCopyDoc((xmlDocPtr)genericPtr, 1); + + if (copyDocPtr == NULL) return nil; + + return [[DDXMLDocument alloc] initWithDocPrimitive:copyDocPtr freeOnDealloc:YES]; + } + + if (IsXmlNodePtr(genericPtr)) + { + xmlNodePtr copyNodePtr = xmlCopyNode((xmlNodePtr)genericPtr, 1); + + if (copyNodePtr == NULL) return nil; + + if ([self isKindOfClass:[DDXMLElement class]]) + return [[DDXMLElement alloc] initWithElementPrimitive:copyNodePtr freeOnDealloc:YES]; + else + return [[DDXMLNode alloc] initWithPrimitive:(xmlKindPtr)copyNodePtr freeOnDealloc:YES]; + } + + if (IsXmlAttrPtr(genericPtr)) + { + xmlAttrPtr copyAttrPtr = xmlCopyProp(NULL, (xmlAttrPtr)genericPtr); + + if (copyAttrPtr == NULL) return nil; + + return [[DDXMLAttributeNode alloc] initWithAttrPrimitive:copyAttrPtr freeOnDealloc:YES]; + } + + if (IsXmlNsPtr(genericPtr)) + { + xmlNsPtr copyNsPtr = xmlCopyNamespace((xmlNsPtr)genericPtr); + + if (copyNsPtr == NULL) return nil; + + return [[DDXMLNamespaceNode alloc] initWithNsPrimitive:copyNsPtr nsParent:NULL freeOnDealloc:YES]; + } + + if (IsXmlDtdPtr(genericPtr)) + { + xmlDtdPtr copyDtdPtr = xmlCopyDtd((xmlDtdPtr)genericPtr); + + if (copyDtdPtr == NULL) return nil; + + return [[DDXMLNode alloc] initWithPrimitive:(xmlKindPtr)copyDtdPtr freeOnDealloc:YES]; + } + + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (DDXMLNodeKind)kind +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (genericPtr != NULL) + return genericPtr->type; + else + return DDXMLInvalidKind; +} + +- (void)setName:(NSString *)name +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // The xmlNodeSetName function works for both nodes and attributes + xmlNodeSetName((xmlNodePtr)genericPtr, [name xmlChar]); +} + +- (NSString *)name +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + const char *name = (const char *)((xmlStdPtr)genericPtr)->name; + + if (name == NULL) + return nil; + else + return [NSString stringWithUTF8String:name]; +} + +- (void)setStringValue:(NSString *)string +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (IsXmlNodePtr(genericPtr)) + { + xmlStdPtr node = (xmlStdPtr)genericPtr; + + // Setting the content of a node erases any existing child nodes. + // Therefore, we need to remove them properly first. + [[self class] removeAllChildrenFromNode:(xmlNodePtr)node]; + + xmlChar *escapedString = xmlEncodeSpecialChars(node->doc, [string xmlChar]); + xmlNodeSetContent((xmlNodePtr)node, escapedString); + xmlFree(escapedString); + } +} + +/** + * Returns the content of the receiver as a string value. + * + * If the receiver is a node object of element kind, the content is that of any text-node children. + * This method recursively visits elements nodes and concatenates their text nodes in document order with + * no intervening spaces. +**/ +- (NSString *)stringValue +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (IsXmlNodePtr(genericPtr)) + { + xmlChar *content = xmlNodeGetContent((xmlNodePtr)genericPtr); + + NSString *result = [NSString stringWithUTF8String:(const char *)content]; + + xmlFree(content); + return result; + } + + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Tree Navigation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the index of the receiver identifying its position relative to its sibling nodes. + * The first child node of a parent has an index of zero. +**/ +- (NSUInteger)index +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSUInteger result = 0; + + xmlStdPtr node = ((xmlStdPtr)genericPtr)->prev; + while (node != NULL) + { + result++; + node = node->prev; + } + + return result; +} + +/** + * Returns the nesting level of the receiver within the tree hierarchy. + * The root element of a document has a nesting level of one. +**/ +- (NSUInteger)level +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSUInteger result = 0; + + xmlNodePtr currentNode = ((xmlStdPtr)genericPtr)->parent; + while (currentNode != NULL) + { + result++; + currentNode = currentNode->parent; + } + + return result; +} + +/** + * Returns the DDXMLDocument object containing the root element and representing the XML document as a whole. + * If the receiver is a standalone node (that is, a node at the head of a detached branch of the tree), this + * method returns nil. +**/ +- (DDXMLDocument *)rootDocument +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + if (node == NULL || node->doc == NULL) + return nil; + else + return [DDXMLDocument nodeWithDocPrimitive:node->doc freeOnDealloc:NO]; +} + +/** + * Returns the parent node of the receiver. + * + * Document nodes and standalone nodes (that is, the root of a detached branch of a tree) have no parent, and + * sending this message to them returns nil. A one-to-one relationship does not always exists between a parent and + * its children; although a namespace or attribute node cannot be a child, it still has a parent element. +**/ +- (DDXMLNode *)parent +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + if (node->parent == NULL) + return nil; + else + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)node->parent freeOnDealloc:NO]; +} + +/** + * Returns the number of child nodes the receiver has. + * For performance reasons, use this method instead of getting the count from the array returned by children. +**/ +- (NSUInteger)childCount +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (!IsXmlDocPtr(genericPtr) && !IsXmlNodePtr(genericPtr) && !IsXmlDtdPtr(genericPtr)) + { + return 0; + } + + NSUInteger result = 0; + + xmlNodePtr child = ((xmlStdPtr)genericPtr)->children; + while (child != NULL) + { + result++; + child = child->next; + } + + return result; +} + +/** + * Returns an immutable array containing the child nodes of the receiver (as DDXMLNode objects). +**/ +- (NSArray *)children +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (!IsXmlDocPtr(genericPtr) && !IsXmlNodePtr(genericPtr) && !IsXmlDtdPtr(genericPtr)) + { + return nil; + } + + NSMutableArray *result = [NSMutableArray array]; + + xmlNodePtr child = ((xmlStdPtr)genericPtr)->children; + while (child != NULL) + { + [result addObject:[DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)child freeOnDealloc:NO]]; + + child = child->next; + } + + return [[result copy] autorelease]; +} + +/** + * Returns the child node of the receiver at the specified location. + * Returns a DDXMLNode object or nil if the receiver has no children. + * + * If the receive has children and index is out of bounds, an exception is raised. + * + * The receiver should be a DDXMLNode object representing a document, element, or document type declaration. + * The returned node object can represent an element, comment, text, or processing instruction. +**/ +- (DDXMLNode *)childAtIndex:(NSUInteger)index +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (!IsXmlDocPtr(genericPtr) && !IsXmlNodePtr(genericPtr) && !IsXmlDtdPtr(genericPtr)) + { + return nil; + } + + NSUInteger i = 0; + + xmlNodePtr child = ((xmlStdPtr)genericPtr)->children; + + if (child == NULL) + { + // NSXML doesn't raise an exception if there are no children + return nil; + } + + while (child != NULL) + { + if (i == index) + { + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)child freeOnDealloc:NO]; + } + + i++; + child = child->next; + } + + // NSXML version uses this same assertion + DDXMLAssert(NO, @"index (%u) beyond bounds (%u)", (unsigned)index, (unsigned)i); + + return nil; +} + +/** + * Returns the previous DDXMLNode object that is a sibling node to the receiver. + * + * This object will have an index value that is one less than the receiverÕs. + * If there are no more previous siblings (that is, other child nodes of the receiverÕs parent) the method returns nil. +**/ +- (DDXMLNode *)previousSibling +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + if (node->prev == NULL) + return nil; + else + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)node->prev freeOnDealloc:NO]; +} + +/** + * Returns the next DDXMLNode object that is a sibling node to the receiver. + * + * This object will have an index value that is one more than the receiverÕs. + * If there are no more subsequent siblings (that is, other child nodes of the receiverÕs parent) the + * method returns nil. +**/ +- (DDXMLNode *)nextSibling +{ + // Note: DDXMLNamespaceNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + if (node->next == NULL) + return nil; + else + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)node->next freeOnDealloc:NO]; +} + +/** + * Returns the previous DDXMLNode object in document order. + * + * You use this method to ÒwalkÓ backward through the tree structure representing an XML document or document section. + * (Use nextNode to traverse the tree in the opposite direction.) Document order is the natural order that XML + * constructs appear in markup text. If you send this message to the first node in the tree (that is, the root element), + * nil is returned. DDXMLNode bypasses namespace and attribute nodes when it traverses a tree in document order. +**/ +- (DDXMLNode *)previousNode +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // If the node has a previous sibling, + // then we need the last child of the last child of the last child etc + + // Note: Try to accomplish this task without creating dozens of intermediate wrapper objects + + xmlStdPtr node = (xmlStdPtr)genericPtr; + xmlStdPtr previousSibling = node->prev; + + if (previousSibling != NULL) + { + if (previousSibling->last != NULL) + { + xmlNodePtr lastChild = previousSibling->last; + while (lastChild->last != NULL) + { + lastChild = lastChild->last; + } + + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)lastChild freeOnDealloc:NO]; + } + else + { + // The previous sibling has no children, so the previous node is simply the previous sibling + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)previousSibling freeOnDealloc:NO]; + } + } + + // If there are no previous siblings, then the previous node is simply the parent + + // Note: rootNode.parent == docNode + + if (node->parent == NULL || node->parent->type == XML_DOCUMENT_NODE) + return nil; + else + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)node->parent freeOnDealloc:NO]; +} + +/** + * Returns the next DDXMLNode object in document order. + * + * You use this method to ÒwalkÓ forward through the tree structure representing an XML document or document section. + * (Use previousNode to traverse the tree in the opposite direction.) Document order is the natural order that XML + * constructs appear in markup text. If you send this message to the last node in the tree, nil is returned. + * DDXMLNode bypasses namespace and attribute nodes when it traverses a tree in document order. +**/ +- (DDXMLNode *)nextNode +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // If the node has children, then next node is the first child + DDXMLNode *firstChild = [self childAtIndex:0]; + if (firstChild) + return firstChild; + + // If the node has a next sibling, then next node is the same as next sibling + + DDXMLNode *nextSibling = [self nextSibling]; + if (nextSibling) + return nextSibling; + + // There are no children, and no more siblings, so we need to get the next sibling of the parent. + // If that is nil, we need to get the next sibling of the grandparent, etc. + + // Note: Try to accomplish this task without creating dozens of intermediate wrapper objects + + xmlNodePtr parent = ((xmlStdPtr)genericPtr)->parent; + while (parent != NULL) + { + xmlNodePtr parentNextSibling = parent->next; + if (parentNextSibling != NULL) + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)parentNextSibling freeOnDealloc:NO]; + else + parent = parent->parent; + } + + return nil; +} + +/** + * Detaches the receiver from its parent node. + * + * This method is applicable to DDXMLNode objects representing elements, text, comments, processing instructions, + * attributes, and namespaces. Once the node object is detached, you can add it as a child node of another parent. +**/ +- (void)detach +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + if (node->parent != NULL) + { + if (IsXmlNodePtr(genericPtr)) + { + [[self class] detachChild:(xmlNodePtr)node fromNode:node->parent]; + freeOnDealloc = YES; + } + } +} + +- (xmlStdPtr)XPathPreProcess:(NSMutableString *)result +{ + // This is a private/internal method + + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + + return (xmlStdPtr)genericPtr; +} + +- (NSString *)XPath +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSMutableString *result = [NSMutableString stringWithCapacity:25]; + + // Examples: + // /rootElement[1]/subElement[4]/thisNode[2] + // topElement/thisNode[2] + + xmlStdPtr node = [self XPathPreProcess:result]; + + // Note: rootNode.parent == docNode + + while ((node != NULL) && (node->type != XML_DOCUMENT_NODE)) + { + if ((node->parent == NULL) && (node->doc == NULL)) + { + // We're at the top of the heirarchy, and there is no xml document. + // Thus we don't use a leading '/', and we don't need an index. + + [result insertString:[NSString stringWithFormat:@"%s", node->name] atIndex:0]; + } + else + { + // Find out what index this node is. + // If it's the first node with this name, the index is 1. + // If there are previous siblings with the same name, the index is greater than 1. + + int index = 1; + xmlStdPtr prevNode = node->prev; + + while (prevNode != NULL) + { + if (xmlStrEqual(node->name, prevNode->name)) + { + index++; + } + prevNode = prevNode->prev; + } + + [result insertString:[NSString stringWithFormat:@"/%s[%i]", node->name, index] atIndex:0]; + } + + node = (xmlStdPtr)node->parent; + } + + return [[result copy] autorelease]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark QNames +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the local name of the receiver. + * + * The local name is the part of a node name that follows a namespace-qualifying colon or the full name if + * there is no colon. For example, ÒchapterÓ is the local name in the qualified name Òacme:chapterÓ. +**/ +- (NSString *)localName +{ + // Note: DDXMLNamespaceNode overrides this method + + // Zombie test occurs in [self name] + + return [[self class] localNameForName:[self name]]; +} + +/** + * Returns the prefix of the receiverÕs name. + * + * The prefix is the part of a namespace-qualified name that precedes the colon. + * For example, ÒacmeÓ is the local name in the qualified name Òacme:chapterÓ. + * This method returns an empty string if the receiverÕs name is not qualified by a namespace. +**/ +- (NSString *)prefix +{ + // Note: DDXMLNamespaceNode overrides this method + + // Zombie test occurs in [self name] + + return [[self class] prefixForName:[self name]]; +} + +/** + * Sets the URI identifying the source of this document. + * Pass nil to remove the current URI. +**/ +- (void)setURI:(NSString *)URI +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (IsXmlNodePtr(genericPtr)) + { + xmlNodePtr node = (xmlNodePtr)genericPtr; + if (node->ns != NULL) + { + [[self class] removeNamespace:node->ns fromNode:node]; + } + + if (URI) + { + // Create a new xmlNsPtr, add it to the nsDef list, and make ns point to it + xmlNsPtr ns = xmlNewNs(NULL, [URI xmlChar], NULL); + ns->next = node->nsDef; + node->nsDef = ns; + node->ns = ns; + } + } +} + +/** + * Returns the URI associated with the receiver. + * + * A nodeÕs URI is derived from its namespace or a documentÕs URI; for documents, the URI comes either from the + * parsed XML or is explicitly set. You cannot change the URI for a particular node other for than a namespace + * or document node. +**/ +- (NSString *)URI +{ + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (IsXmlNodePtr(genericPtr)) + { + xmlNodePtr node = (xmlNodePtr)genericPtr; + if (node->ns != NULL) + { + return [NSString stringWithUTF8String:((const char *)node->ns->href)]; + } + } + + return nil; +} + +/** + * Returns the local name from the specified qualified name. + * + * Examples: + * "a:node" -> "node" + * "a:a:node" -> "a:node" + * "node" -> "node" + * nil - > nil +**/ ++ (NSString *)localNameForName:(NSString *)name +{ + if (name) + { + NSRange range = [name rangeOfString:@":"]; + + if (range.length != 0) + return [name substringFromIndex:(range.location + range.length)]; + else + return name; + } + return nil; +} + +/** + * Extracts the prefix from the given name. + * If name is nil, or has no prefix, an empty string is returned. + * + * Examples: + * "a:deusty.com" -> "a" + * "a:a:deusty.com" -> "a" + * "node" -> "" + * nil -> "" +**/ ++ (NSString *)prefixForName:(NSString *)name +{ + if (name) + { + NSRange range = [name rangeOfString:@":"]; + + if (range.length != 0) + { + return [name substringToIndex:range.location]; + } + } + return @""; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Output +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)description +{ + // Zombie test occurs in XMLStringWithOptions: + + return [self XMLStringWithOptions:0]; +} + +- (NSString *)XMLString +{ + // Zombie test occurs in XMLStringWithOptions: + + return [self XMLStringWithOptions:0]; +} + +- (NSString *)XMLStringWithOptions:(NSUInteger)options +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // xmlSaveNoEmptyTags: + // Global setting, asking the serializer to not output empty tags + // as but . those two forms are undistinguishable + // once parsed. + // Disabled by default + + if (options & DDXMLNodeCompactEmptyElement) + xmlSaveNoEmptyTags = 0; + else + xmlSaveNoEmptyTags = 1; + + int format = 0; + if (options & DDXMLNodePrettyPrint) + { + format = 1; + xmlIndentTreeOutput = 1; + } + + xmlBufferPtr bufferPtr = xmlBufferCreate(); + if (IsXmlNsPtr(genericPtr)) + xmlNodeDump(bufferPtr, NULL, (xmlNodePtr)genericPtr, 0, format); + else + xmlNodeDump(bufferPtr, ((xmlStdPtr)genericPtr)->doc, (xmlNodePtr)genericPtr, 0, format); + + if ([self kind] == DDXMLTextKind) + { + NSString *result = [NSString stringWithUTF8String:(const char *)bufferPtr->content]; + + xmlBufferFree(bufferPtr); + + return result; + } + else + { + NSMutableString *resTmp = [NSMutableString stringWithUTF8String:(const char *)bufferPtr->content]; + CFStringTrimWhitespace((CFMutableStringRef)resTmp); + + xmlBufferFree(bufferPtr); + + return [[resTmp copy] autorelease]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark XPath/XQuery +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSArray *)nodesForXPath:(NSString *)xpath error:(NSError **)error +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlXPathContextPtr xpathCtx; + xmlXPathObjectPtr xpathObj; + + BOOL isTempDoc = NO; + xmlDocPtr doc; + + if (IsXmlDocPtr(genericPtr)) + { + doc = (xmlDocPtr)genericPtr; + } + else if (IsXmlNodePtr(genericPtr)) + { + doc = ((xmlNodePtr)genericPtr)->doc; + + if(doc == NULL) + { + isTempDoc = YES; + + doc = xmlNewDoc(NULL); + xmlDocSetRootElement(doc, (xmlNodePtr)genericPtr); + } + } + else + { + return nil; + } + + xpathCtx = xmlXPathNewContext(doc); + xpathCtx->node = (xmlNodePtr)genericPtr; + + xmlNodePtr rootNode = (doc)->children; + if(rootNode != NULL) + { + xmlNsPtr ns = rootNode->nsDef; + while(ns != NULL) + { + xmlXPathRegisterNs(xpathCtx, ns->prefix, ns->href); + + ns = ns->next; + } + } + + xpathObj = xmlXPathEvalExpression([xpath xmlChar], xpathCtx); + + NSArray *result; + + if(xpathObj == NULL) + { + if(error) *error = [[self class] lastError]; + result = nil; + } + else + { + if(error) *error = nil; + + int count = xmlXPathNodeSetGetLength(xpathObj->nodesetval); + + if(count == 0) + { + result = [NSArray array]; + } + else + { + NSMutableArray *mResult = [NSMutableArray arrayWithCapacity:count]; + + int i; + for (i = 0; i < count; i++) + { + xmlNodePtr node = xpathObj->nodesetval->nodeTab[i]; + + [mResult addObject:[DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)node freeOnDealloc:NO]]; + } + + result = mResult; + } + } + + if(xpathObj) xmlXPathFreeObject(xpathObj); + if(xpathCtx) xmlXPathFreeContext(xpathCtx); + + if (isTempDoc) + { + xmlUnlinkNode((xmlNodePtr)genericPtr); + xmlFreeDoc(doc); + + // xmlUnlinkNode doesn't remove the doc ptr + [[self class] recursiveStripDocPointersFromNode:(xmlNodePtr)genericPtr]; + } + + return result; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Private API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +// ---------- MEMORY MANAGEMENT ARCHITECTURE ---------- +// +// KissXML is designed to be read-access thread-safe. +// It is not write-access thread-safe as this would require significant overhead. +// +// What exactly does read-access thread-safe mean? +// It means that multiple threads can safely read from the same xml structure, +// so long as none of them attempt to alter the xml structure (add/remove nodes, change attributes, etc). +// +// This read-access thread-safety includes parsed xml structures as well as xml structures created by you. +// Let's walk through a few examples to get a deeper understanding. +// +// +// +// Example #1 - Parallel processing of children +// +// DDXMLElement *root = [[DDXMLElement alloc] initWithXMLString:str error:nil]; +// NSArray *children = [root children]; +// +// dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); +// dispatch_apply([children count], q, ^(size_t i) { +// DDXMLElement *child = [children objectAtIndex:i]; +// +// }); +// +// +// +// Example #2 - Safe vs Unsafe sub-element processing +// +// DDXMLElement *root = [[DDXMLElement alloc] initWithXMLString:str error:nil]; +// DDXMLElement *child = [root elementForName:@"starbucks"]; +// +// dispatch_async(queue, ^{ +// +// }); +// +// [root release]; <-------------- NOT safe! +// +// But why is it not safe? +// Does it have something to do with the child? +// Do I need to retain the child? +// Doesn't the child get retained automatically by dispatch_async? +// +// Yes, the child does get retainied automatically by dispatch_async, but that's not the problem. +// XML represents a heirarchy of nodes. For example: +// +// +// +// +// +// +// +// Each element within the heirarchy has references/pointers to its parent, children, siblings, etc. +// This is necessary to support the traversal strategies one requires to work with XML. +// This also means its not thread-safe to deallocate the root node of an element if +// you are still using/accessing a child node. +// So let's rewrite example 2 in a thread-safe manner this time. +// +// DDXMLElement *root = [[DDXMLElement alloc] initWithXMLString:str error:nil]; +// DDXMLElement *child = [root elementForName:@"starbucks"]; +// +// [child detach]; <-------------- Detached from root, and can safely be used even if we now dealloc root. +// +// dispatch_async(queue, ^{ +// +// }); +// +// [root release]; <-------------- Thread-safe thanks to the detach above. +// +// +// +// Example #3 - Building up an element +// +// DDXMLElement *coffee = [[DDXMLElement alloc] initWithName:@"coffee"]; +// DDXMLElement *starbucks = [[DDXMLElement alloc] initWithName:@"starbucks"]; +// DDXMLElement *root = [[DDXMLElement alloc] initWithName:@"root"]; +// +// At this point we have 3 root nodes (root, starbucks, coffee) +// +// [starbucks addChild:coffee]; +// +// At this point we have 2 root nodes (root, starbucks). +// The coffee node is now a child of starbucks, so it is no-longer a "root" node since +// it has a parent within the xml tree heirarchy. +// +// [coffee addChild:starbucks]; +// +// At this point we have only 1 root node (root). +// Again, the others are no-longer "root" nodes since they have a parent within the xml tree heirarchy. +// +// [coffee release]; coffee = nil; +// +// If you have a reference to a child node, you can safely release that reference. +// Since coffee is embedded in the tree heirarchy, the coffee node doesn't disappear. +// +// DDXMLElement *coffee2 = [starbucks elementForName:@"coffee"]; +// +// So the above will return a new reference to the coffee node. +// +// [root release]; root = nil; +// +// Now, we have just released the root node. +// This means that it is no longer safe to use starbucks or coffee2. +// +// [starbucks release]; starbucks = nil; +// +// Yes, this is safe. Just don't do anything else with starbucks besides release it. + +/** + * Returns whether or not the node has a parent. + * Use this method instead of parent when you only need to ensure parent is nil. + * This prevents the unnecessary creation of a parent node wrapper. +**/ +- (BOOL)_hasParent +{ + // This is a private/internal method + + // Note: DDXMLNamespaceNode overrides this method + + xmlStdPtr node = (xmlStdPtr)genericPtr; + + return (node->parent != NULL); +} + ++ (void)stripDocPointersFromAttr:(xmlAttrPtr)attr +{ + xmlNodePtr child = attr->children; + while (child != NULL) + { + child->doc = NULL; + child = child->next; + } + + attr->doc = NULL; +} + ++ (void)recursiveStripDocPointersFromNode:(xmlNodePtr)node +{ + xmlAttrPtr attr = node->properties; + while (attr != NULL) + { + [self stripDocPointersFromAttr:attr]; + attr = attr->next; + } + + xmlNodePtr child = node->children; + while (child != NULL) + { + [self recursiveStripDocPointersFromNode:child]; + child = child->next; + } + + node->doc = NULL; +} + +/** + * Detaches the given attribute from the given node. + * The attribute's surrounding prev/next pointers are properly updated to remove the attribute from the attr list. + * Then, if flag is YES, the attribute's parent, prev, next and doc pointers are destroyed. +**/ ++ (void)detachAttribute:(xmlAttrPtr)attr fromNode:(xmlNodePtr)node andNullifyPointers:(BOOL)flag +{ + // Update the surrounding prev/next pointers + if (attr->prev == NULL) + { + if (attr->next == NULL) + { + node->properties = NULL; + } + else + { + node->properties = attr->next; + attr->next->prev = NULL; + } + } + else + { + if (attr->next == NULL) + { + attr->prev->next = NULL; + } + else + { + attr->prev->next = attr->next; + attr->next->prev = attr->prev; + } + } + + if (flag) + { + // Nullify pointers + attr->parent = NULL; + attr->prev = NULL; + attr->next = NULL; + if(attr->doc != NULL) [self stripDocPointersFromAttr:attr]; + } +} + +/** + * Detaches the given attribute from the given node. + * The attribute's surrounding prev/next pointers are properly updated to remove the attribute from the attr list. + * Then the attribute's parent, prev, next and doc pointers are destroyed. +**/ ++ (void)detachAttribute:(xmlAttrPtr)attr fromNode:(xmlNodePtr)node +{ + [self detachAttribute:attr fromNode:node andNullifyPointers:YES]; +} + +/** + * Removes and free's the given attribute from the given node. + * The attribute's surrounding prev/next pointers are properly updated to remove the attribute from the attr list. +**/ ++ (void)removeAttribute:(xmlAttrPtr)attr fromNode:(xmlNodePtr)node +{ +#if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(attr); +#endif + + // We perform a bit of optimization here. + // No need to bother nullifying pointers since we're about to free the node anyway. + [self detachAttribute:attr fromNode:node andNullifyPointers:NO]; + + xmlFreeProp(attr); +} + +/** + * Removes and frees all attributes from the given node. + * Upon return, the given node's properties pointer is NULL. +**/ ++ (void)removeAllAttributesFromNode:(xmlNodePtr)node +{ + xmlAttrPtr attr = node->properties; + while (attr != NULL) + { + xmlAttrPtr nextAttr = attr->next; + + #if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(attr); + #endif + + xmlFreeProp(attr); + attr = nextAttr; + } + + node->properties = NULL; +} + +/** + * Detaches the given namespace from the given node. + * The namespace's surrounding next pointers are properly updated to remove the namespace from the node's nsDef list. + * Then the namespace's parent and next pointers are destroyed. +**/ ++ (void)detachNamespace:(xmlNsPtr)ns fromNode:(xmlNodePtr)node +{ + // Namespace nodes have no previous pointer, so we have to search for the node + + xmlNsPtr previousNs = NULL; + xmlNsPtr currentNs = node->nsDef; + + while (currentNs != NULL) + { + if (currentNs == ns) + { + if (previousNs == NULL) + node->nsDef = currentNs->next; + else + previousNs->next = currentNs->next; + + break; + } + + previousNs = currentNs; + currentNs = currentNs->next; + } + + if (node->ns == ns) + { + node->ns = NULL; + } + + // Nullify pointers + ns->next = NULL; +} + +/** + * Removes the given namespace from the given node. + * The namespace's surrounding next pointers are properly updated to remove the namespace from the nsDef list. + * Then the namespace is freed if it's no longer being referenced. + * Otherwise, it's nsParent and next pointers are destroyed. +**/ ++ (void)removeNamespace:(xmlNsPtr)ns fromNode:(xmlNodePtr)node +{ +#if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(ns); +#endif + + [self detachNamespace:ns fromNode:node]; + + xmlFreeNs(ns); +} + +/** + * Removes all namespaces from the given node. + * All namespaces are either freed, or their nsParent and next pointers are properly destroyed. + * Upon return, the given node's nsDef pointer is NULL. +**/ ++ (void)removeAllNamespacesFromNode:(xmlNodePtr)node +{ + xmlNsPtr ns = node->nsDef; + while (ns != NULL) + { + xmlNsPtr nextNs = ns->next; + + #if DDXML_DEBUG_MEMORY_ISSUES + MarkZombies(ns); + #endif + + xmlFreeNs(ns); + ns = nextNs; + } + + node->nsDef = NULL; + node->ns = NULL; +} + +/** + * Detaches the given child from the given node. + * The child's surrounding prev/next pointers are properly updated to remove the child from the node's children list. + * Then, if flag is YES, the child's parent, prev, next and doc pointers are destroyed. +**/ ++ (void)detachChild:(xmlNodePtr)child fromNode:(xmlNodePtr)node andNullifyPointers:(BOOL)flag +{ + // Update the surrounding prev/next pointers + if (child->prev == NULL) + { + if (child->next == NULL) + { + node->children = NULL; + node->last = NULL; + } + else + { + node->children = child->next; + child->next->prev = NULL; + } + } + else + { + if (child->next == NULL) + { + node->last = child->prev; + child->prev->next = NULL; + } + else + { + child->prev->next = child->next; + child->next->prev = child->prev; + } + } + + if (flag) + { + // Nullify pointers + child->parent = NULL; + child->prev = NULL; + child->next = NULL; + if(child->doc != NULL) [self recursiveStripDocPointersFromNode:child]; + } +} + +/** + * Detaches the given child from the given node. + * The child's surrounding prev/next pointers are properly updated to remove the child from the node's children list. + * Then the child's parent, prev, next and doc pointers are destroyed. +**/ ++ (void)detachChild:(xmlNodePtr)child fromNode:(xmlNodePtr)node +{ + [self detachChild:child fromNode:node andNullifyPointers:YES]; +} + +/** + * Removes the given child from the given node. + * The child's surrounding prev/next pointers are properly updated to remove the child from the node's children list. + * Then the child is recursively freed if it's no longer being referenced. + * Otherwise, it's parent, prev, next and doc pointers are destroyed. + * + * During the recursive free, subnodes still being referenced are properly handled. +**/ ++ (void)removeChild:(xmlNodePtr)child fromNode:(xmlNodePtr)node +{ +#if DDXML_DEBUG_MEMORY_ISSUES + RecursiveMarkZombiesFromNode(child); +#endif + + // We perform a bit of optimization here. + // No need to bother nullifying pointers since we're about to free the node anyway. + [self detachChild:child fromNode:node andNullifyPointers:NO]; + + xmlFreeNode(child); +} + +/** + * Removes all children from the given node. + * All children are either recursively freed, or their parent, prev, next and doc pointers are properly destroyed. + * Upon return, the given node's children pointer is NULL. + * + * During the recursive free, subnodes still being referenced are properly handled. +**/ ++ (void)removeAllChildrenFromNode:(xmlNodePtr)node +{ + xmlNodePtr child = node->children; + while (child != NULL) + { + xmlNodePtr nextChild = child->next; + + #if DDXML_DEBUG_MEMORY_ISSUES + RecursiveMarkZombiesFromNode(child); + #endif + + xmlFreeNode(child); + child = nextChild; + } + + node->children = NULL; + node->last = NULL; +} + +/** + * Returns the last error encountered by libxml. + * Errors are caught in the MyErrorHandler method within DDXMLDocument. +**/ ++ (NSError *)lastError +{ + NSValue *lastErrorValue = [[[NSThread currentThread] threadDictionary] objectForKey:DDLastErrorKey]; + if(lastErrorValue) + { + xmlError lastError; + [lastErrorValue getValue:&lastError]; + + int errCode = lastError.code; + NSString *errMsg = [[NSString stringWithFormat:@"%s", lastError.message] stringByTrimming]; + + NSDictionary *info = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey]; + + return [NSError errorWithDomain:@"DDXMLErrorDomain" code:errCode userInfo:info]; + } + else + { + return nil; + } +} + +static void MyErrorHandler(void * userData, xmlErrorPtr error) +{ + // This method is called by libxml when an error occurs. + // We register for this error in the initialize method below. + + // Extract error message and store in the current thread's dictionary. + // This ensure's thread safey, and easy access for all other DDXML classes. + + if (error == NULL) + { + [[[NSThread currentThread] threadDictionary] removeObjectForKey:DDLastErrorKey]; + } + else + { + NSValue *errorValue = [NSValue valueWithBytes:error objCType:@encode(xmlError)]; + + [[[NSThread currentThread] threadDictionary] setObject:errorValue forKey:DDLastErrorKey]; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Zombie Tracking +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#if DDXML_DEBUG_MEMORY_ISSUES + +// What is zombie tracking and how does it work? +// +// It is all explained in full detail here: +// http://code.google.com/p/kissxml/wiki/MemoryManagementThreadSafety +// +// But here's a quick overview in case you're on a plane right now +// (and the plane doesn't have internet access, or charges some ridiculous amount and you don't want to pay for it.) +// +// +// +// +// +// +// You have a reference to the latte node, and you release/dealloc the starbucks node. Uh oh! +// The latte node is now a zombie, since the xmlNode it was pointing to (wrapping) is now gone. +// If you attempt to read info from the latte node, you might get a crash. +// Or you might get junk results. +// And if you attempt to write info to the latte node, you might just wind up with some ugly heap corruption. +// And if this happens, well.. it's a huge P.I.T.A to track down. +// +// But I've been there before. And I feel your pain. That's where this debug option comes in. +// +// The debugging option keeps a dictionary where the keys are the xml pointers (xmlNodePtr, xmlAttrPtr, etc), +// and the values are mutable arrays. Any wrapper objects (DDXMLElement, DDXMLNode, etc) get added to the +// mutable array for which the wrapper is pointing. +// +// If the xml (xmlNodePtr, xmlAttrPtr, etc) is to be freed, it first removes its key from the dictionary, +// and in doing so destroys any associated mutable array. +// +// So a zombie check ensures that the xml structure the wrapper is referring to hasn't been freed. +// If it has an exception is thrown to help track down the problem. +// +// In other words, if you try to read info from the latte node, or attempt to alter the latte node +// (after you release/dealloc starbucks), you'll immediately get a helpful exception. +// (Goodbye junk values and heap corruption.) +// +// This is helpful in debugging, as it is sometimes easy to forget about the memory rules of the xml heirarchy. +// Or simply due to combinations of passing subelements around and using asynchronous operations. + + +static void RecursiveMarkZombiesFromNode(xmlNodePtr node) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + // Mark attributes + xmlAttrPtr attr = node->properties; + while (attr != NULL) + { + MarkZombies(attr); + attr = attr->next; + } + + // Mark namespaces + xmlNsPtr ns = node->nsDef; + while (ns != NULL) + { + MarkZombies(ns); + ns = ns->next; + } + if (node->ns) + { + MarkZombies(node->ns); + } + + // Recursively mark children + xmlNodePtr child = node->children; + while (child != NULL) + { + RecursiveMarkZombiesFromNode(child); + child = child->next; + } + + MarkZombies(node); +} + +static void RecursiveMarkZombiesFromDoc(xmlDocPtr doc) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + xmlNodePtr child = doc->children; + while (child != NULL) + { + RecursiveMarkZombiesFromNode(child); + + child = child->next; + } + + MarkZombies(doc); +} + +static void MarkZombies(void *xmlPtr) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + dispatch_async(zombieQueue, ^{ + + // NSLog(@"MarkZombies: %p", xmlPtr); + + CFDictionaryRemoveValue(zombieTracker, xmlPtr); + }); +} + +static void MarkBirth(void *xmlPtr, DDXMLNode *wrapper) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + const void *value = (void *)wrapper; + + dispatch_async(zombieQueue, ^{ + + // NSLog(@"MarkBirth: %p, %p", xmlPtr, value); + + CFMutableArrayRef values = (CFMutableArrayRef)CFDictionaryGetValue(zombieTracker, xmlPtr); + if (values == NULL) + { + values = CFArrayCreateMutable(NULL, /*MaxCapacity:*/0, /*ValueCallbacks:*/NULL); + CFArrayAppendValue(values, value); + + CFDictionarySetValue(zombieTracker, xmlPtr, values); + CFRelease(values); + } + else + { + CFArrayAppendValue(values, value); + } + }); +} + +static void MarkDeath(void *xmlPtr, DDXMLNode *wrapper) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + const void *value = (void *)wrapper; + + dispatch_async(zombieQueue, ^{ + + // NSLog(@"MarkDeath: %p, %p", xmlPtr, value); + + CFMutableArrayRef values = (CFMutableArrayRef)CFDictionaryGetValue(zombieTracker, xmlPtr); + if (values) + { + CFRange range = CFRangeMake(0, CFArrayGetCount(values)); + CFIndex index = CFArrayGetFirstIndexOfValue(values, range, value); + if (index >= 0) + { + CFArrayRemoveValueAtIndex(values, index); + } + } + }); +} + +BOOL DDXMLIsZombie(void *xmlPtr, DDXMLNode *wrapper) +{ + // This method only exists if DDXML_DEBUG_MEMORY_ISSUES is enabled. + + __block BOOL result; + + const void *value = (void *)wrapper; + + dispatch_sync(zombieQueue, ^{ + + CFMutableArrayRef values = (CFMutableArrayRef)CFDictionaryGetValue(zombieTracker, xmlPtr); + if (values) + { + CFRange range = CFRangeMake(0, CFArrayGetCount(values)); + CFIndex index = CFArrayGetFirstIndexOfValue(values, range, value); + + result = (index < 0); + } + else + { + result = YES; + } + }); + + return result; +} + +#endif + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDXMLNamespaceNode + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ ++ (id)nodeWithNsPrimitive:(xmlNsPtr)ns nsParent:(xmlNodePtr)parent freeOnDealloc:(BOOL)flag +{ + return [[[DDXMLNamespaceNode alloc] initWithNsPrimitive:ns nsParent:parent freeOnDealloc:flag] autorelease]; +} + +/** + * Returns a DDXML wrapper object for the given primitive node. + * The given node MUST be non-NULL and of the proper type. +**/ +- (id)initWithNsPrimitive:(xmlNsPtr)ns nsParent:(xmlNodePtr)parent freeOnDealloc:(BOOL)flag +{ + if ((self = [super initWithPrimitive:(xmlKindPtr)ns freeOnDealloc:flag])) + { + nsParentPtr = parent; + } + return self; +} + ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use nodeWithNsPrimitive:nsParent:freeOnDealloc:"); + + return nil; +} + +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use initWithNsPrimitive:nsParent:freeOnDealloc:"); + + [self release]; + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setName:(NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlNsPtr ns = (xmlNsPtr)genericPtr; + + xmlFree((xmlChar *)ns->prefix); + ns->prefix = xmlStrdup([name xmlChar]); +} + +- (NSString *)name +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlNsPtr ns = (xmlNsPtr)genericPtr; + if (ns->prefix != NULL) + return [NSString stringWithUTF8String:((const char*)ns->prefix)]; + else + return @""; +} + +- (void)setStringValue:(NSString *)string +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlNsPtr ns = (xmlNsPtr)genericPtr; + + xmlFree((xmlChar *)ns->href); + ns->href = xmlEncodeSpecialChars(NULL, [string xmlChar]); +} + +- (NSString *)stringValue +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return [NSString stringWithUTF8String:((const char *)((xmlNsPtr)genericPtr)->href)]; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Tree Navigation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSUInteger)index +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlNsPtr ns = (xmlNsPtr)genericPtr; + + // The xmlNsPtr has no prev pointer, so we have to search from the parent + + if (nsParentPtr == NULL) + { + return 0; + } + + NSUInteger result = 0; + + xmlNsPtr currentNs = nsParentPtr->nsDef; + while (currentNs != NULL) + { + if (currentNs == ns) + { + return result; + } + result++; + currentNs = currentNs->next; + } + + return 0; // Yes 0, not result, because ns wasn't found in list +} + +- (NSUInteger)level +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + NSUInteger result = 0; + + xmlNodePtr currentNode = nsParentPtr; + while (currentNode != NULL) + { + result++; + currentNode = currentNode->parent; + } + + return result; +} + +- (DDXMLDocument *)rootDocument +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlStdPtr node = (xmlStdPtr)nsParentPtr; + + if (node == NULL || node->doc == NULL) + return nil; + else + return [DDXMLDocument nodeWithDocPrimitive:node->doc freeOnDealloc:NO]; +} + +- (DDXMLNode *)parent +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (nsParentPtr == NULL) + return nil; + else + return [DDXMLNode nodeWithUnknownPrimitive:(xmlKindPtr)nsParentPtr freeOnDealloc:NO]; +} + +- (NSUInteger)childCount +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return 0; +} + +- (NSArray *)children +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)childAtIndex:(NSUInteger)index +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)previousSibling +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)nextSibling +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)previousNode +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)nextNode +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (void)detach +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + if (nsParentPtr != NULL) + { + [DDXMLNode detachNamespace:(xmlNsPtr)genericPtr fromNode:nsParentPtr]; + + freeOnDealloc = YES; + nsParentPtr = NULL; + } +} + +- (xmlStdPtr)XPathPreProcess:(NSMutableString *)result +{ + // This is a private/internal method + + xmlStdPtr parent = (xmlStdPtr)nsParentPtr; + + if (parent == NULL) + [result appendFormat:@"namespace::%@", [self name]]; + else + [result appendFormat:@"/namespace::%@", [self name]]; + + return parent; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark QNames +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (NSString *)localName +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // Strangely enough, the localName of a namespace is the prefix, and the prefix is an empty string + xmlNsPtr ns = (xmlNsPtr)genericPtr; + if (ns->prefix != NULL) + return [NSString stringWithUTF8String:((const char *)ns->prefix)]; + else + return @""; +} + +- (NSString *)prefix +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // Strangely enough, the localName of a namespace is the prefix, and the prefix is an empty string + return @""; +} + +- (void)setURI:(NSString *)URI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + // Do nothing +} + +- (NSString *)URI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Private API +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (BOOL)_hasParent +{ + // This is a private/internal method + + return (nsParentPtr != NULL); +} + +- (xmlNodePtr)_nsParentPtr +{ + // This is a private/internal method + + return nsParentPtr; +} + +- (void)_setNsParentPtr:(xmlNodePtr)parentPtr +{ + // This is a private/internal method + + nsParentPtr = parentPtr; +} + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@implementation DDXMLAttributeNode + ++ (id)nodeWithAttrPrimitive:(xmlAttrPtr)attr freeOnDealloc:(BOOL)flag +{ + return [[[DDXMLAttributeNode alloc] initWithAttrPrimitive:attr freeOnDealloc:flag] autorelease]; +} + +- (id)initWithAttrPrimitive:(xmlAttrPtr)attr freeOnDealloc:(BOOL)flag +{ + self = [super initWithPrimitive:(xmlKindPtr)attr freeOnDealloc:flag]; + return self; +} + ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use nodeWithAttrPrimitive:nsParent:freeOnDealloc:"); + + return nil; +} + +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag +{ + // Promote initializers which use proper parameter types to enable compiler to catch more mistakes. + NSAssert(NO, @"Use initWithAttrPrimitive:nsParent:freeOnDealloc:"); + + [self release]; + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Properties +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setStringValue:(NSString *)string +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + + if (attr->children != NULL) + { + xmlChar *escapedString = xmlEncodeSpecialChars(attr->doc, [string xmlChar]); + xmlNodeSetContent((xmlNodePtr)attr, escapedString); + xmlFree(escapedString); + } + else + { + xmlNodePtr text = xmlNewText([string xmlChar]); + attr->children = text; + } +} + +- (NSString *)stringValue +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + + if (attr->children != NULL) + { + return [NSString stringWithUTF8String:(const char *)attr->children->content]; + } + + return nil; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark Tree Navigation +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (DDXMLNode *)previousNode +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (DDXMLNode *)nextNode +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + return nil; +} + +- (void)detach +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + + if (attr->parent != NULL) + { + [[self class] detachAttribute:attr fromNode:attr->parent]; + freeOnDealloc = YES; + } +} + +- (xmlStdPtr)XPathPreProcess:(NSMutableString *)result +{ + // This is a private/internal method + + // Note: DDXMLNamespaceNode overrides this method + // Note: DDXMLAttributeNode overrides this method + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + xmlStdPtr parent = (xmlStdPtr)attr->parent; + + if (parent == NULL) + [result appendFormat:@"@%@", [self name]]; + else + [result appendFormat:@"/@%@", [self name]]; + + return parent; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark QNames +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +- (void)setURI:(NSString *)URI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + if (attr->ns != NULL) + { + // An attribute can only have a single namespace attached to it. + // In addition, this namespace can only be accessed via the URI method. + // There is no way, within the API, to get a DDXMLNode wrapper for the attribute's namespace. + xmlFreeNs(attr->ns); + attr->ns = NULL; + } + + if (URI) + { + // Create a new xmlNsPtr, and make ns point to it + xmlNsPtr ns = xmlNewNs(NULL, [URI xmlChar], NULL); + attr->ns = ns; + } +} + +- (NSString *)URI +{ +#if DDXML_DEBUG_MEMORY_ISSUES + DDXMLNotZombieAssert(); +#endif + + xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + if (attr->ns != NULL) + { + return [NSString stringWithUTF8String:((const char *)attr->ns->href)]; + } + + return nil; +} + +@end diff --git a/xmpp/Vendor/KissXML/Private/DDXMLPrivate.h b/xmpp/Vendor/KissXML/Private/DDXMLPrivate.h new file mode 100644 index 0000000..d0de6ae --- /dev/null +++ b/xmpp/Vendor/KissXML/Private/DDXMLPrivate.h @@ -0,0 +1,200 @@ +#import "DDXML.h" + + +// We can't rely solely on NSAssert, because many developers disable them for release builds. +// Our API contract requires us to keep these assertions intact. +#define DDXMLAssert(condition, desc, ...) \ + do{ \ + if(!(condition)) { \ + [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd \ + object:self \ + file:[NSString stringWithUTF8String:__FILE__] \ + lineNumber:__LINE__ \ + description:(desc), ##__VA_ARGS__]; \ + } \ + }while(NO) + + +// Create assertion to ensure xml node is not a zombie. +#if DDXML_DEBUG_MEMORY_ISSUES +#define DDXMLNotZombieAssert() \ + do{ \ + if(DDXMLIsZombie(genericPtr, self)) { \ + NSString *desc = @"XML node is a zombie - It's parent structure has been freed!"; \ + [[NSAssertionHandler currentHandler] handleFailureInMethod:_cmd \ + object:self \ + file:[NSString stringWithUTF8String:__FILE__] \ + lineNumber:__LINE__ \ + description:desc]; \ + } \ + }while(NO) +#endif + +#define DDLastErrorKey @"DDXML:LastError" + + + +/** + * DDXMLNode can represent several underlying types, such as xmlNodePtr, xmlDocPtr, xmlAttrPtr, xmlNsPtr, etc. + * All of these are pointers to structures, and all of those structures start with a pointer, and a type. + * The xmlKind struct is used as a generic structure, and a stepping stone. + * We use it to check the type of a structure, and then perform the appropriate cast. + * + * For example: + * if(genericPtr->type == XML_ATTRIBUTE_NODE) + * { + * xmlAttrPtr attr = (xmlAttrPtr)genericPtr; + * // Do something with attr + * } +**/ +struct _xmlKind { + void * ignore; + xmlElementType type; +}; +typedef struct _xmlKind *xmlKindPtr; + +/** + * Most xml types all start with this standard structure. In fact, all do except the xmlNsPtr. + * We will occasionally take advantage of this to simplify code when the code wouldn't vary from type to type. + * Obviously, you cannnot cast a xmlNsPtr to a xmlStdPtr. +**/ +struct _xmlStd { + void * _private; + xmlElementType type; + const xmlChar *name; + struct _xmlNode *children; + struct _xmlNode *last; + struct _xmlNode *parent; + struct _xmlStd *next; + struct _xmlStd *prev; + struct _xmlDoc *doc; +}; +typedef struct _xmlStd *xmlStdPtr; + + +NS_INLINE BOOL IsXmlAttrPtr(void *kindPtr) +{ + return ((xmlKindPtr)kindPtr)->type == XML_ATTRIBUTE_NODE; +} + +NS_INLINE BOOL IsXmlNodePtr(void *kindPtr) +{ + switch (((xmlKindPtr)kindPtr)->type) + { + case XML_ELEMENT_NODE : + case XML_PI_NODE : + case XML_COMMENT_NODE : + case XML_TEXT_NODE : + case XML_CDATA_SECTION_NODE : return YES; + default : return NO; + } +} + +NS_INLINE BOOL IsXmlDocPtr(void *kindPtr) +{ + return ((xmlKindPtr)kindPtr)->type == XML_DOCUMENT_NODE; +} + +NS_INLINE BOOL IsXmlDtdPtr(void *kindPtr) +{ + return ((xmlKindPtr)kindPtr)->type == XML_DTD_NODE; +} + +NS_INLINE BOOL IsXmlNsPtr(void *kindPtr) +{ + return ((xmlKindPtr)kindPtr)->type == XML_NAMESPACE_DECL; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDXMLNamespaceNode : DDXMLNode +{ + // The xmlNsPtr type doesn't store a reference to it's parent. + // This is here to fix the problem, and make this class more compatible with the NSXML classes. + xmlNodePtr nsParentPtr; +} + ++ (id)nodeWithNsPrimitive:(xmlNsPtr)ns nsParent:(xmlNodePtr)parent freeOnDealloc:(BOOL)flag; +- (id)initWithNsPrimitive:(xmlNsPtr)ns nsParent:(xmlNodePtr)parent freeOnDealloc:(BOOL)flag; + +- (xmlNodePtr)_nsParentPtr; +- (void)_setNsParentPtr:(xmlNodePtr)parentPtr; + +// Overrides several methods in DDXMLNode + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDXMLAttributeNode : DDXMLNode + ++ (id)nodeWithAttrPrimitive:(xmlAttrPtr)attr freeOnDealloc:(BOOL)flag; +- (id)initWithAttrPrimitive:(xmlAttrPtr)attr freeOnDealloc:(BOOL)flag; + +// Overrides several methods in DDXMLNode + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDXMLNode (PrivateAPI) + ++ (id)nodeWithUnknownPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag; + ++ (id)nodeWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag; +- (id)initWithPrimitive:(xmlKindPtr)kindPtr freeOnDealloc:(BOOL)flag; + +- (BOOL)_hasParent; + ++ (void)recursiveStripDocPointersFromNode:(xmlNodePtr)node; + ++ (void)detachAttribute:(xmlAttrPtr)attr fromNode:(xmlNodePtr)node; ++ (void)removeAttribute:(xmlAttrPtr)attr fromNode:(xmlNodePtr)node; ++ (void)removeAllAttributesFromNode:(xmlNodePtr)node; + ++ (void)detachNamespace:(xmlNsPtr)ns fromNode:(xmlNodePtr)node; ++ (void)removeNamespace:(xmlNsPtr)ns fromNode:(xmlNodePtr)node; ++ (void)removeAllNamespacesFromNode:(xmlNodePtr)node; + ++ (void)detachChild:(xmlNodePtr)child fromNode:(xmlNodePtr)node; ++ (void)removeChild:(xmlNodePtr)child fromNode:(xmlNodePtr)node; ++ (void)removeAllChildrenFromNode:(xmlNodePtr)node; + +BOOL DDXMLIsZombie(void *xmlPtr, DDXMLNode *wrapper); + ++ (NSError *)lastError; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDXMLElement (PrivateAPI) + ++ (id)nodeWithElementPrimitive:(xmlNodePtr)node freeOnDealloc:(BOOL)flag; +- (id)initWithElementPrimitive:(xmlNodePtr)node freeOnDealloc:(BOOL)flag; + +- (NSArray *)_elementsForName:(NSString *)name uri:(NSString *)URI; + ++ (DDXMLNode *)resolveNamespaceForPrefix:(NSString *)prefix atNode:(xmlNodePtr)nodePtr; ++ (NSString *)resolvePrefixForURI:(NSString *)uri atNode:(xmlNodePtr)nodePtr; + +@end + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +#pragma mark - +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +@interface DDXMLDocument (PrivateAPI) + ++ (id)nodeWithDocPrimitive:(xmlDocPtr)doc freeOnDealloc:(BOOL)flag; +- (id)initWithDocPrimitive:(xmlDocPtr)doc freeOnDealloc:(BOOL)flag; + +@end diff --git a/xmpp/Vendor/libidn/idn-int.h b/xmpp/Vendor/libidn/idn-int.h new file mode 100644 index 0000000..d51b5cd --- /dev/null +++ b/xmpp/Vendor/libidn/idn-int.h @@ -0,0 +1,524 @@ +/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ +/* Copyright (C) 2001-2002, 2004-2007 Free Software Foundation, Inc. + Written by Paul Eggert, Bruno Haible, Sam Steingold, Peter Burwood. + This file is part of gnulib. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program; if not, write to the Free Software Foundation, + Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* + * ISO C 99 for platforms that lack it. + * + */ + +#ifndef _GL_STDINT_H + +/* When including a system file that in turn includes , + use the system , not our substitute. This avoids + problems with (for example) VMS, whose includes + . */ +#define _GL_JUST_INCLUDE_SYSTEM_INTTYPES_H + +/* Get those types that are already defined in other system include + files, so that we can "#define int8_t signed char" below without + worrying about a later system include file containing a "typedef + signed char int8_t;" that will get messed up by our macro. Our + macros should all be consistent with the system versions, except + for the "fast" types and macros, which we recommend against using + in public interfaces due to compiler differences. */ + +#if 1 +# if defined __sgi && ! defined __c99 + /* Bypass IRIX's if in C89 mode, since it merely annoys users + with "This header file is to be used only for c99 mode compilations" + diagnostics. */ +# define __STDINT_H__ +# endif + /* Other systems may have an incomplete or buggy . + Include it before , since any "#include " + in would reinclude us, skipping our contents because + _GL_STDINT_H is defined. + The include requires a split double-inclusion guard. */ +# include +#endif + +#if ! defined _GL_STDINT_H && ! defined _GL_JUST_INCLUDE_SYSTEM_STDINT_H +#define _GL_STDINT_H + +/* defines some of the stdint.h types as well, on glibc, + IRIX 6.5, and OpenBSD 3.8 (via ). + AIX 5.2 isn't needed and causes troubles. + MacOS X 10.4.6 includes (which is us), but + relies on the system definitions, so include + after . */ +#if 1 && ! defined _AIX +# include +#endif + +/* Get LONG_MIN, LONG_MAX, ULONG_MAX. */ +#include + +#if 1 + /* In OpenBSD 3.8, includes , which defines + int{8,16,32,64}_t, uint{8,16,32,64}_t and __BIT_TYPES_DEFINED__. + also defines intptr_t and uintptr_t. */ +# include +#elif 0 + /* Solaris 7 has the types except the *_fast*_t types, and + the macros except for *_FAST*_*, INTPTR_MIN, PTRDIFF_MIN, PTRDIFF_MAX. */ +# include +#endif + +#if 0 && ! defined __BIT_TYPES_DEFINED__ + /* Linux libc4 >= 4.6.7 and libc5 have a that defines + int{8,16,32,64}_t and __BIT_TYPES_DEFINED__. In libc5 >= 5.2.2 it is + included by . */ +# include +#endif + +#if ! defined __cplusplus || defined __STDC_CONSTANT_MACROS + +/* Get WCHAR_MIN, WCHAR_MAX. */ +# if ! (defined WCHAR_MIN && defined WCHAR_MAX) +/* We don't need WCHAR_* in libidn, so to avoid problems with + missing wchar.h, don't include wchar.h here. */ +# endif + +#endif + +#undef _GL_JUST_INCLUDE_SYSTEM_INTTYPES_H + +/* Minimum and maximum values for a integer type under the usual assumption. + Return an unspecified value if BITS == 0, adding a check to pacify + picky compilers. */ + +#define _STDINT_MIN(signed, bits, zero) \ + ((signed) ? (- ((zero) + 1) << ((bits) ? (bits) - 1 : 0)) : (zero)) + +#define _STDINT_MAX(signed, bits, zero) \ + ((signed) \ + ? ~ _STDINT_MIN (signed, bits, zero) \ + : /* The expression for the unsigned case. The subtraction of (signed) \ + is a nop in the unsigned case and avoids "signed integer overflow" \ + warnings in the signed case. */ \ + ((((zero) + 1) << ((bits) ? (bits) - 1 - (signed) : 0)) - 1) * 2 + 1) + +/* 7.18.1.1. Exact-width integer types */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. */ + +#undef int8_t +#undef uint8_t +#define int8_t signed char +#define uint8_t unsigned char + +#undef int16_t +#undef uint16_t +#define int16_t short int +#define uint16_t unsigned short int + +#undef int32_t +#undef uint32_t +#define int32_t int +#define uint32_t unsigned int + +/* Do not undefine int64_t if gnulib is not being used with 64-bit + types, since otherwise it breaks platforms like Tandem/NSK. */ +#if LONG_MAX >> 31 >> 31 == 1 +# undef int64_t +# define int64_t long int +# define GL_INT64_T +#elif defined _MSC_VER +# undef int64_t +# define int64_t __int64 +# define GL_INT64_T +#elif 1 +# undef int64_t +# define int64_t long long int +# define GL_INT64_T +#endif + +#if ULONG_MAX >> 31 >> 31 >> 1 == 1 +# undef uint64_t +# define uint64_t unsigned long int +# define GL_UINT64_T +#elif defined _MSC_VER +# undef uint64_t +# define uint64_t unsigned __int64 +# define GL_UINT64_T +#elif 1 +# undef uint64_t +# define uint64_t unsigned long long int +# define GL_UINT64_T +#endif + +/* Avoid collision with Solaris 2.5.1 etc. */ +#define _UINT8_T +#define _UINT32_T +#define _UINT64_T + + +/* 7.18.1.2. Minimum-width integer types */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. Therefore the leastN_t types + are the same as the corresponding N_t types. */ + +#undef int_least8_t +#undef uint_least8_t +#undef int_least16_t +#undef uint_least16_t +#undef int_least32_t +#undef uint_least32_t +#undef int_least64_t +#undef uint_least64_t +#define int_least8_t int8_t +#define uint_least8_t uint8_t +#define int_least16_t int16_t +#define uint_least16_t uint16_t +#define int_least32_t int32_t +#define uint_least32_t uint32_t +#ifdef GL_INT64_T +# define int_least64_t int64_t +#endif +#ifdef GL_UINT64_T +# define uint_least64_t uint64_t +#endif + +/* 7.18.1.3. Fastest minimum-width integer types */ + +/* Note: Other substitutes may define these types differently. + It is not recommended to use these types in public header files. */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. Therefore the fastN_t types + are taken from the same list of types. Assume that 'long int' + is fast enough for all narrower integers. */ + +#undef int_fast8_t +#undef uint_fast8_t +#undef int_fast16_t +#undef uint_fast16_t +#undef int_fast32_t +#undef uint_fast32_t +#undef int_fast64_t +#undef uint_fast64_t +#define int_fast8_t long int +#define uint_fast8_t unsigned int_fast8_t +#define int_fast16_t long int +#define uint_fast16_t unsigned int_fast16_t +#define int_fast32_t long int +#define uint_fast32_t unsigned int_fast32_t +#ifdef GL_INT64_T +# define int_fast64_t int64_t +#endif +#ifdef GL_UINT64_T +# define uint_fast64_t uint64_t +#endif + +/* 7.18.1.4. Integer types capable of holding object pointers */ + +#undef intptr_t +#undef uintptr_t +#define intptr_t long int +#define uintptr_t unsigned long int + +/* 7.18.1.5. Greatest-width integer types */ + +/* Note: These types are compiler dependent. It may be unwise to use them in + public header files. */ + +#undef intmax_t +#if 1 && LONG_MAX >> 30 == 1 +# define intmax_t long long int +#elif defined GL_INT64_T +# define intmax_t int64_t +#else +# define intmax_t long int +#endif + +#undef uintmax_t +#if 1 && ULONG_MAX >> 31 == 1 +# define uintmax_t unsigned long long int +#elif defined GL_UINT64_T +# define uintmax_t uint64_t +#else +# define uintmax_t unsigned long int +#endif + +/* Verify that intmax_t and uintmax_t have the same size. Too much code + breaks if this is not the case. If this check fails, the reason is likely + to be found in the autoconf macros. */ +typedef int _verify_intmax_size[2 * (sizeof (intmax_t) == sizeof (uintmax_t)) - 1]; + +/* 7.18.2. Limits of specified-width integer types */ + +#if ! defined __cplusplus || defined __STDC_LIMIT_MACROS + +/* 7.18.2.1. Limits of exact-width integer types */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. */ + +#undef INT8_MIN +#undef INT8_MAX +#undef UINT8_MAX +#define INT8_MIN (~ INT8_MAX) +#define INT8_MAX 127 +#define UINT8_MAX 255 + +#undef INT16_MIN +#undef INT16_MAX +#undef UINT16_MAX +#define INT16_MIN (~ INT16_MAX) +#define INT16_MAX 32767 +#define UINT16_MAX 65535 + +#undef INT32_MIN +#undef INT32_MAX +#undef UINT32_MAX +#define INT32_MIN (~ INT32_MAX) +#define INT32_MAX 2147483647 +#define UINT32_MAX 4294967295U + +#undef INT64_MIN +#undef INT64_MAX +#ifdef GL_INT64_T +/* Prefer (- INTMAX_C (1) << 63) over (~ INT64_MAX) because SunPRO C 5.0 + evaluates the latter incorrectly in preprocessor expressions. */ +# define INT64_MIN (- INTMAX_C (1) << 63) +# define INT64_MAX INTMAX_C (9223372036854775807) +#endif + +#undef UINT64_MAX +#ifdef GL_UINT64_T +# define UINT64_MAX UINTMAX_C (18446744073709551615) +#endif + +/* 7.18.2.2. Limits of minimum-width integer types */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. Therefore the leastN_t types + are the same as the corresponding N_t types. */ + +#undef INT_LEAST8_MIN +#undef INT_LEAST8_MAX +#undef UINT_LEAST8_MAX +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define UINT_LEAST8_MAX UINT8_MAX + +#undef INT_LEAST16_MIN +#undef INT_LEAST16_MAX +#undef UINT_LEAST16_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define UINT_LEAST16_MAX UINT16_MAX + +#undef INT_LEAST32_MIN +#undef INT_LEAST32_MAX +#undef UINT_LEAST32_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define UINT_LEAST32_MAX UINT32_MAX + +#undef INT_LEAST64_MIN +#undef INT_LEAST64_MAX +#ifdef GL_INT64_T +# define INT_LEAST64_MIN INT64_MIN +# define INT_LEAST64_MAX INT64_MAX +#endif + +#undef UINT_LEAST64_MAX +#ifdef GL_UINT64_T +# define UINT_LEAST64_MAX UINT64_MAX +#endif + +/* 7.18.2.3. Limits of fastest minimum-width integer types */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits. Therefore the fastN_t types + are taken from the same list of types. */ + +#undef INT_FAST8_MIN +#undef INT_FAST8_MAX +#undef UINT_FAST8_MAX +#define INT_FAST8_MIN LONG_MIN +#define INT_FAST8_MAX LONG_MAX +#define UINT_FAST8_MAX ULONG_MAX + +#undef INT_FAST16_MIN +#undef INT_FAST16_MAX +#undef UINT_FAST16_MAX +#define INT_FAST16_MIN LONG_MIN +#define INT_FAST16_MAX LONG_MAX +#define UINT_FAST16_MAX ULONG_MAX + +#undef INT_FAST32_MIN +#undef INT_FAST32_MAX +#undef UINT_FAST32_MAX +#define INT_FAST32_MIN LONG_MIN +#define INT_FAST32_MAX LONG_MAX +#define UINT_FAST32_MAX ULONG_MAX + +#undef INT_FAST64_MIN +#undef INT_FAST64_MAX +#ifdef GL_INT64_T +# define INT_FAST64_MIN INT64_MIN +# define INT_FAST64_MAX INT64_MAX +#endif + +#undef UINT_FAST64_MAX +#ifdef GL_UINT64_T +# define UINT_FAST64_MAX UINT64_MAX +#endif + +/* 7.18.2.4. Limits of integer types capable of holding object pointers */ + +#undef INTPTR_MIN +#undef INTPTR_MAX +#undef UINTPTR_MAX +#define INTPTR_MIN LONG_MIN +#define INTPTR_MAX LONG_MAX +#define UINTPTR_MAX ULONG_MAX + +/* 7.18.2.5. Limits of greatest-width integer types */ + +#undef INTMAX_MIN +#undef INTMAX_MAX +#ifdef INT64_MAX +# define INTMAX_MIN INT64_MIN +# define INTMAX_MAX INT64_MAX +#else +# define INTMAX_MIN INT32_MIN +# define INTMAX_MAX INT32_MAX +#endif + +#undef UINTMAX_MAX +#ifdef UINT64_MAX +# define UINTMAX_MAX UINT64_MAX +#else +# define UINTMAX_MAX UINT32_MAX +#endif + +/* 7.18.3. Limits of other integer types */ + +/* ptrdiff_t limits */ +#undef PTRDIFF_MIN +#undef PTRDIFF_MAX +#define PTRDIFF_MIN \ + _STDINT_MIN (1, 32, 0) +#define PTRDIFF_MAX \ + _STDINT_MAX (1, 32, 0) + +/* sig_atomic_t limits */ +#undef SIG_ATOMIC_MIN +#undef SIG_ATOMIC_MAX +#define SIG_ATOMIC_MIN \ + _STDINT_MIN (1, 32, \ + 0) +#define SIG_ATOMIC_MAX \ + _STDINT_MAX (1, 32, \ + 0) + + +/* size_t limit */ +#undef SIZE_MAX +#define SIZE_MAX _STDINT_MAX (0, 32, 0ul) + +/* wchar_t limits */ +#undef WCHAR_MIN +#undef WCHAR_MAX +#define WCHAR_MIN \ + _STDINT_MIN (1, 32, 0) +#define WCHAR_MAX \ + _STDINT_MAX (1, 32, 0) + +/* wint_t limits */ +#undef WINT_MIN +#undef WINT_MAX +#define WINT_MIN \ + _STDINT_MIN (1, 32, 0) +#define WINT_MAX \ + _STDINT_MAX (1, 32, 0) + +#endif /* !defined __cplusplus || defined __STDC_LIMIT_MACROS */ + +/* 7.18.4. Macros for integer constants */ + +#if ! defined __cplusplus || defined __STDC_CONSTANT_MACROS + +/* 7.18.4.1. Macros for minimum-width integer constants */ +/* According to ISO C 99 Technical Corrigendum 1 */ + +/* Here we assume a standard architecture where the hardware integer + types have 8, 16, 32, optionally 64 bits, and int is 32 bits. */ + +#undef INT8_C +#undef UINT8_C +#define INT8_C(x) x +#define UINT8_C(x) x + +#undef INT16_C +#undef UINT16_C +#define INT16_C(x) x +#define UINT16_C(x) x + +#undef INT32_C +#undef UINT32_C +#define INT32_C(x) x +#define UINT32_C(x) x ## U + +#undef INT64_C +#undef UINT64_C +#if LONG_MAX >> 31 >> 31 == 1 +# define INT64_C(x) x##L +#elif defined _MSC_VER +# define INT64_C(x) x##i64 +#elif 1 +# define INT64_C(x) x##LL +#endif +#if ULONG_MAX >> 31 >> 31 >> 1 == 1 +# define UINT64_C(x) x##UL +#elif defined _MSC_VER +# define UINT64_C(x) x##ui64 +#elif 1 +# define UINT64_C(x) x##ULL +#endif + +/* 7.18.4.2. Macros for greatest-width integer constants */ + +#undef INTMAX_C +#if 1 && LONG_MAX >> 30 == 1 +# define INTMAX_C(x) x##LL +#elif defined GL_INT64_T +# define INTMAX_C(x) INT64_C(x) +#else +# define INTMAX_C(x) x##L +#endif + +#undef UINTMAX_C +#if 1 && ULONG_MAX >> 31 == 1 +# define UINTMAX_C(x) x##ULL +#elif defined GL_UINT64_T +# define UINTMAX_C(x) UINT64_C(x) +#else +# define UINTMAX_C(x) x##UL +#endif + +#endif /* !defined __cplusplus || defined __STDC_CONSTANT_MACROS */ + +#endif /* _GL_STDINT_H */ +#endif /* !defined _GL_STDINT_H && !defined _GL_JUST_INCLUDE_SYSTEM_STDINT_H */ diff --git a/xmpp/Vendor/libidn/libidn-1.15.tar.gz b/xmpp/Vendor/libidn/libidn-1.15.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e65bf82b53565dc9cd9b874a95a08d74c8931aa9 GIT binary patch literal 2635155 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

6|`d_iME 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⁣u0H#k^!t*J9ABAKwzOUc5~(;1jPqqRmEkx zx}mKdfGxX{I0m$GE@7sM^PkVC@M;bkfr}lag|~v^Y5|Po#laLf!8F%>`<522d&Z|O zuIt6oQ5SQy;1#$wcS_biGZ&d>lv`_B3;Jtre~I8#H{8gUXW8b5)8bAR7yN9+oSjCl z%HOK4oTqERb8gAha<_WARY$rA+x#4r)*+T6CrrM1+fHUJ>fc_ppN>yX)rP`9JKO;5 z4_`s}aPbI6Sy7weLKgA7bIP_eR&emKN>B!L%wwdP7A$q(>wb6y`h*%`2m?Jk;utF5 zgKAWN)ZCt(?Sw~i&O?6k=zDe3$d0&pbAe%B^K;CJplt~9ld#&;m(@823>qvy&{_;h zVYJ}G9HF;65rg(f=;NFFGyS%Bxo4Z1=3Z=XXx~<*>Tt|07W1+6_<*K7LmwOB>nxWE z57IU6dBSipmw5m({CNjZxw@%gm!={XEBjm^nbsD01Qhq?wQvcis3R%)mY9aEW;#`K z)}2x`gKYT5ks0af%qGL;`I0!r`9j#^xJ~PmaOEa?!^dP&14~pN+m9_)HM!RKM-a)> zv+Q>cV~H1?7qlg)7w&&#hg1($(pO-Y!a**bmpH`q61EL(HIh(os5BOSf`$~n3+86y zLQB}RUV4Hpnv7z}+O$dyX2@fEQ*v%$Ye`4pG%?MIwJ)a^PeEX4V@AQAh)n{=2riARF0C8|W3su}emx+~SUrEGjA0k6!Jz_;IFM)>bysB;NK zdHHhq;~BdAf5?C@cApa1g}EI>+|zEO0mnuIv#`X$VPlKjhd!Fnk2m339Dm=~HF!jX z)~{WDi;yXm7qV$_-%l3j0>s!ZIM6gGda5drpgfU6S|Uq<-?}iMjSb@Z8+V( zj_H5eE${&&9~6Oab_XY2{{E`rFnH0f)v%t?A7Ph5;r%NIDn9`;rD|c;6yk4Y-_#xH z4i6}D#;Ol9D~3|xmo?>d=qSs!V|qyaPja#x*0fy7d*ip?Jim{Z2AKi>!WEwGv~d$i zd^w$#7^N}q(HW-MGqJ?9TxxX(pQxWW++l=S1z-F`4%3qdV6T;YV52l6ikzP{oLen- zz;6G934uvRDL?7RN>=+sT#O&ZEqJl-Xao%y#ZUTC;suMOhPBZLQ5ezXv@{fMm+3X+mkxA?U@ZuN6r) z>rQza!beGqPl;oRV0N`3;}dpfkoG8%n2=&|Po;z98_lF(4jGwos?5kITvLv2!^LWW zK+^E&%ix;qrZ@z8qJNvJtf{dTWu4}Lkvx>lmb8;Txq=8}Hmp=2ywj1T{2a%o%>U?& z3&TzcW9t!%;}MJF5sPCV7DqH&ynFt_gb@pU6J994yFG}+-H`0cvFzA^UqH7)SPC1C zLJxC$SPD@SjsoLNcmT$v@TuN|9pom$0cZ3%5P0;dqaEWD&;|PNU->XI_|6_C3X7TBouT9oX6uCkYf72q-r^n`ja-mv_U21U=psLplXG; zoHiNCVg!Gqs^Gz^{;glBZ`@>7!#q+fG+?bcC=ua7kyoma>U&sYHJ4)i)>a&Dto#N= zCq@Na`mu%;m-z`FmE&23gYq81BNJf3&%d4bns5z1;D1Oq{9naDO!Vt!7==@cgOIY< z8o@p!cJ;17HI&!fQR_CyCTeTX#-ZHW;pO-$3T7W+GdCIqs!Ih>V1ppc537XFTc}aB z8ihfkd}Ef{B*3JGsmrd$_)OITNk1l4KnnF^>?SJvh+0^2BL5DIKUoNswpTQJH(K;A zjA?iCl}E=1Kb!=SY(oiT?_(iGBeU;Vu~XQI$Weo49xZTh4w`&j?aqPLMh2Ox6d7XS z@X(-1$(7xK(n846L` zm-{5r11$Ew`I)r8R2rl4Wop59vAHSBczq+h%XIl$)eP4<%3ako*Lmpspvj%+cg{)F zRQJN61$V#t^|d(doN}yNL6U4J%A+usr$f~DZq;126OP_U?!9Qr%jAa zlQmkX3Y8~LVYciE5}aYA^<(6CI;KUrBig6KdF`0I8&OZC#T>>Xo$)}X>rVrYS7GET zj+ZLElR%vrU*)i46ANZvw#4;Qn1%AUbk&rqEcq`*OMdH|=O^N~H6B@;^*HvC;-Ei( zKBCtJXrwtnwNBxjK3uK2KgMNDlIng5Rb#4IbEY~K)Fht~>s(MhONhD|V^J$(oRd28 zaa`s6Q3INV;|qi-`dCB@%f2t6LsD{m83wt$+T47XlQ)`8mD%ebkTNg<+T+a;V2V5# zM-%C^S0@-xrJk!PNwU8=H!c6yeWv>-uth(VJ)u=rK3XzM0tq_FlNx>1e0d zJ|C}Mmjc$xU^lt^wtJ+AgVU1bd284@_geVz?L5MJ!fiEqnP~(!9 z3W&;pY4&zFIWFA~!W(B1XfD>Iu+Q)xdn?m^|;$9VeE`cn;7@xE{vOXf;*R2 zSL3G$CzOK{VY{&NSh@z+%Ir2qE-HW2-aSMCYNRXI{MCPpJHNr*cX0t&!);b*@>v#V z@?}&FEHyW1SQG1MN6si zUBkr<74+jDRL{Rg`!=|;tp6J7@f{+3HZPAj!oP+`YR3-Y+a=PEyvUCgsE+)-b+>e* zE4;4F)eMZEVd!5hB8t~?CQU-4+;yX1sHkig4?hv-@Do`AgQS-oTKw5iH3gf=f~z)? zYY}TB9)FCf;_XCaNB%ydUZ=+3r)+pxUI!K%p)Rjw2Y zg^{U>)!5r!A`#n_Gdt~k>&XO>@VJrlc!3M2#%|(B&38Bujbjb& zUr!ZCqp47j#tRHHC4V;1XzTbQPl{0|sF`7@Y3(~ z%dkV)U@|H2svq=j2A_tI4;WI}BBZ5YpZb0v=do)^NiguQ-}j0C(GT8T-t@05hfq{5 z<&9^{J@70m1*+;B)bJMa#X7f>%@+UI?;7Tg-RgWQ_M{PH->;4RjBQ5HN;!XFXSkDpxT1L%Ck>AxenhjOAd^j!CFpzcM%wv`Y}z!@G|i7@6gW3W1f5yv!&C+wA=(pD8KkB)vUT-6Cc5wU%3zFSDdH3(}Wa5)Z+aFl_9m5L)k zNtA2{7v4+qY&m|o2YmCc_x#OC67wN{q*T&LiER~tu^ zn17W-h3XYdfbPx)5WLr6p=xhA{k8g9w7^4B1ij4|wCl$8t#y*Oi2!aeFB}$RYx9(o zo|b8{U8arKRl5a!5=8$@(eXNP1xbL-W|P7GWfBkLR5Ij$RjAg1cHDztL1d6Cd46`< zK70RGmrz3SZ7kj0){l{tZOXg}%e%8eAHc91^?VuhBb00UHfpJt1Q24w$Ok&y7h!7dQ{t}m&I(U%8#cPX?D_%c)2l|69B8=+mh++70 zGopV3T34i5| zjwh6APCPA^fyG?-k|y^TN+lnKF)mtxfl6C03#BDe(LY;%^rpK7OVE zJbmhb!`w+MhRIDIsO2&N|Bf+f2oybs0Bj+4kWO#-YXGu9dF%XClx7zA1~fN}Z9`Bz)sa!U@8_)gp62E22SF`_a9y*rEu=2$?Fbmwnf z=v7s~3cu-_<|&d;ZN$_^vg3eIU?DNdJ_l4(1Q3JhF5BxzAl-2tlV)tg6&HZQlUP%d z(bN9SVzC(CZFgyJ!BRNOi~RLdD(L@W_Af4G7(H7xzH@Y#7zp1rDgkLT{Zej^?$#e_caEC9uVkW>uv1qc6VKM2)6iI*UpN@I)^cYoXO#*!wHR2NxTa#w_+f_x7GTn~| zAmEymD{=neS)#eX?P#F3$GuE^$Ek$GEvKlJA)w3zCRriQ0oA6h0%Qid=+fd#F#7~? ztvi~ZLY$%1gDAdI=h2!Iy zm~y8lAJlJrrzC-E>I5Agj!sZAAe{h}=w>=WpuQjVSBU3Sk9T()z7E_`mvCG(mW^6d z{k!DQcWO%bgXT7s{=FW1@sqvmTl(T@RRDw_NIT>f4v{|?Je29rVj^x`TT|Rn@mxn);T_GP$q^~Wj-xTSzMWhX{kA4Whzn)YpXSf zZ36GMgM-cR0oH)i+f1il9R|ul+D=#~cuk6=7|{>APsrcG1b90T1*}lrRy8 zvO5u&o9xhlb`22(*@(%;C?Q%+RfNSY4vNAGj1}u{=nQSAq*;!qxS>Koju;L6pdFZ4 zxF8(i{QkxgMBz~q&sOzK`a;c1Gqz0HO{4U-bs17`Zk(d@j2O2T1{cTYN4=v@XFbe- zdIXInThZAa!d^aL^9i~Uw{Y7w0W(JuGL&H)(jln7Wj>+vKs>%JN=gZpZ`4^y9mmBh z8kIwz8RZbu2r3B(T>h90>I%ia6dS%iJni6*A%1s$F8Hy+?&a-M`8(kSz}O^~`0^=4 zBd5Y5&l|4p&4782Mp0ee5%1g5VE|XML`>r)5p_jTYbYHhv&J)O&O$9sWVMpfy|uo2 z^*2P&eyvPgbd8;`DN*4zRBw;pe>jciy^Bo4#}u8wZ~ELH>Fy$$bLuzaaRw?7zg&%H zqcYp;O2ch~QvoCO=}9-D$3s*+@F_`lC;?{bi^&tIDEJbed+lf&EDVVJiJj2P=e@gY zcMcXzPcaV_!)+T3lh_O6`=Y=Y%(<{b*9BQg(C3;YK`<5m;{SzmnWN1$6%*MV@qL>A z{LJoOK=ew`zzfCQ_k@rl8H8TYh=Z+<+-6M;z3g|Xq+hO$tkGD_S*^(f-r^y&eKb3k zt#5*DG%^&3!Y`XUi1NzF<-87(KviH~GuCPXGq**xAZK!M)Mw&`HxkVE>I-Vzm}0mk z7Q7-2;k390`DF7pn~m;Z*c>Uj9XcqVCOK%i@U__8Db_|ZX9*XPwVqbCs;=)}s4T5m zCxoz*DX6xOE>pLMhgkaqyEmt{nC=Z(=S^PHCXu_nTH;AZn{Q_r1RxCX2jpZUyzL5U z@hw`O$?x+Uf1L-Ej~ODo8x`i@gi|Y8lp}bqR2J0F?2)i(SK7bjVKL*m;Mv2I!16+) z{{{d6|Nrb=d2`c97XKT6iXO+5Y!gd~6EZb;yjwej1*Vdaf~ClAoWq9<+Sr!IvPl>w z``Py$ed(}eCkBSvEvkamYCW~OUw6N&-;V>%XMF@}G$&xt#2Ft#iIiMmJJ-t-u|w7w zkQQW92$h#(jTC}!dpyRR1L#}-cc>ErDlvuLR8SiE(#<7W4omNa7$|XOpCkvK)TdZ) z$1?^SK41kZ7Y2u=9)g!s-yad^aY5?acNh}xue%Ig>^>W+6XUplp>p8Uc*dZ~-w_Bg zND8wtj#AzI>9KpWX>cT^_l`0fVouF~F&C9=fMfki(ge2g7;%PlMjEktln+_@#j=b8Q6wZkPo zvt`8DfZrDv&yU_d#nbSjP7uYq05+XEZpX6V@a55~*I2J9e)_S(XDpcv*^KRi4d{=c z@1R`-L|Vr9v`-yl{R~*?CyChQw81^?p@}&OcwUrYB#!ZjGU#)Q*9?=GUrNWEDwL-tuUF8e^hd29wUrNxFu8W!VL9{vu`x?F97-t9j&4K+A#;29|<~ z{)jf0z5!u2*sV&xf{%p0H6C~b(xoJ=*Glh}u>id=Yk*em4?Ia4+ft1IdiCv2PqXZO z*_gBnHu6js>P!rAW<$IoPt30~m@@UPtsf1}ObCP54JiIlZ)}L^kl+sqv%zL-g~()P zq=bA1F2+3Nu!h$TA~dQ$QF4H^cjKDx7XBpcMhlsNugPqY8d(FZk{s*}@szhp)1nIl z>(Um8WrXYr%ZdlGEJ~^>53nUm(}6OSX7NbbAX0~sysGtPTS=!AX3EZQ5HC;+PN7{q zJa?;Jt9*LyomE?vmZ4aB*xG(b7#Iy{t$uxI8tG+!Py-R3V7V!Fd!{ZakOxN>3bZEk zNl;~1eg-#3{|1EbZ9W=jjhx(oa58j!ITP}@D!~JJx<|%5w1p~qwGDMMUpS4)q2HYM z@47tMs-T0NfFKL_{}V6jpeuCHLtjAf-abs1Cz>wMh3V0RHhi+ZZ7$GMISD#kkfksi z@|pT$)(c`!Z^Y9DB3roli6C&ID5ET;sm5TcIec0*`Sl(Zm(?|+-B1t$tdOQwg+r2Y zZ=Xf%$0=~AU1u7G0|IOVQK?3<5^we-97!CQNOI*;@JTUlh3dWVIx5To@JTaqhR&t8 zA`qZA3*TwsnhZ@di}3!z0U4S#s5^8@smxqh@m$vf{zS`c z(&kZMc(#Ng#6i3k%H-9&)X*)h(q}BWz5I{d<$D80dMv$p@eE#%NBu;tON*{6O1OOE zPk2mIyTyW_!4i9`)EkhU23KH16D_%=9xTU5;1d4Gm-E|nMP=5+8)!PleBM`-m~^bl zR8^h26uE>OCSR>;s%!N`_rov*o&M3yyb9XlJEG4mp=)}~pP~a54Ir~r znLkgz2$o%b5P`e%k9j|~D{w`G5lLuR^--4FMAa!eREfUo*zqx-#B96r^O7Z=YeiOv znJ&yWW$~=XWcxIHE^5t|hsbd2z>#fipgUAkvC;(#LHNB3dQ?s?la7&rii6#lttPd% z@BM7fZIm%gmw7u*WF-gjah6g{mAgzGPh#oz#;u&yFQ?}L$9a(_Xy5}04ga@$>2Rn_}#W;pDTw86$?f?q@2=+6}sg)YHoohyra7syV6e72pj>8qNBOf+?kFXvMG%q+wXofy6<`br3(Q zwL-S7CiC|{?V^wgI5@HU<`39z%k z4=-72f+RB0#X#r~4Ojjxw}X{k!>e&gl(E4`S)b^@8}hoiK&W(^;HXfh^)SlGAI&-+ z)I;f_TG?wp8`qK%pJ;F>knZjLUzR_a@t?ZV{3e7`*k0&rjpIEWwHUoEsnkoHB!($O zXlj5>A|b|SHh;}Ra*W51VNVV1rJ$=xGX|0ghK6L!`vlU%eT3{lv!ys`7<>nFxEj?K z%d*^T5FFnRr?>mti((k~G3X{LTakRHsp?#N zgo`fuHF2EW7r)!ZA2V7Bo-G`0)xVHE6I^~qRIz4!rdLN78_fkKu`w{V5&09P_Kr-j zO`N)niG(7FqxRiRG#o?BI8&7FsEEP2JeX9}nN-|dV3U-XR#>lYyR;&yT6IHthG{P4@)K2-w~l`YXIk*}yn{B6`Nozxojo-=uvs z)4T?qmcchC^Cf3h&9h@ak0lS%X1INcA~y)thqBK4_x)jZ`wHQ%csR2AR9IU|Y_XiwYk z5Gej!WbeMYNneV&OI(ONY$ZcO|8cN?v;4*I=#z7~V3-u_u^1Ej`J+Ni%V3&XV#t|F z+}oNd;$zo}?$|toW_Bt$Yzo5Erh&1=(MIM9o3ban*M+v8SpYDuFNs3s3IJAhuKt!!Q@35_Xj3T=&6>+=WC6|*gbTO2dLG#z;r8co|6;8 zR@QX|q4I4xME^TLdg16P;Zx+Qjcp;YgJxoMmUSPi)@w+mocfq_CeadYLd-qSI(?#4 zMT8hQ^*v;s|GLWqJ^v>j&KHxPkBVYA5PBqT{r;e}u0HLIc4SeCaZX3 zX8ErI&48Z5SD_|Wfs5L$@SuKF@k%kdW`%2mfjX;oFI>lTwnsIRG>YT0sI)gS8QjrP zw7S3tioB_=L(qxdGj7`)-TJ18V%=xC+SRp772IAWv%Om%d?=KRr`_sL$ix90uE9;t z2K?fc@!Eo8^`9}qgtO}fDA68%er`!&kq1Un)eNk51Ty!eNOvj>)4vTb)Hs(BfW}~L zN%*v&B_jM#>!cxRE`vV1G;@qf#h&bPZ-|#^R8?(rXKnrUOG3=nME}(unV_$mCTcq(mNg|aFeMQ1s zkzU`mRdF$4m?X$GlLK~shANP?#I559FeAA48;1Ad4pRk^{1)T|owplwp&m9)=Az+O z^X%Mw9>s38b8|XCqNlQ{!;zgE#FiwmYf4-Hb1sm+9;{e05$CO{C(f1KX#Su;%3Ek0 zd}~mJn=`&JTE4y+o~;uGJoc^xfh`87DGIyy4k+_2(djM$#@79)zl1Zz?|3(4mVQ!# z&5$CLeqiFS9*F*FV9X?Guhb;@ELluYK(%I+iGJ+?MSQ1x0H>}T9}2HkOrrzVD8YVk zY7BMwa|qLV;SO{A_2kc9>C<-8GWs@o$wGMhG=37u^fWbidvfmnSfv?I@r6YR)p4Ai z+LZ&$T#B^cBpT!Ao9dqN_W<5#{Gz--nw*5_i-HIr7Vw1?meXQOQi4CzkuFSJNXEiq zKP+sF-8He~?oRS1fCy@PG-YpG~v_E`|y9c8n~rd=GvlUrRb9Ibs<8TXukndY0gQZ;EO|4GUwu}?AV zpsLK5f%rHgg=|Q#=pfbpfu<=)Q>7-%Z}K90fbw= zxivwNPkLeFYYO@8_xD>m1@+R}sNnvuU(~nW|4eaLI-Yh&9Pq!LpA@Q_lFV~OU9tyf zAj%sLaSlzCD1S>OE9Ycl#Vr(%0R{S8`DWd$W4l|}B(%&4$hLJFxo|zZ8<~t|-`Lbz zwT>ViYvGwDlJMzRFP8%vsec>hs0d%hsTbA7VOnqjf-#fF0!IRyV95Ric`8fUp$Q_x z@5F@_M-P%`xynU`z-jl?<3(>aqp(TZv9_uX@x|P&T|VFyB%rB`sWdzcTD^+OB4tW8 z#{M)>%|`61yR`^5s8w;2sz4S8y_d@urbXCHi;Tv4M0&paXOKMGeNg%a8GIIU1_ zBYR7ts%V+-6B~P!4hF~qhqTnY;k4{JgkC^?*Qwm^qqH$z?2ofUHmuLHBywXz)NZG1 z&a`AQ_^CN4D0w>E{neylKCc|gZm$`*sRjxn zg@*)G=#g-i)FJ+4RIVJFm|g<$HI+JMes-ih`%W)l;*po%-+jnaj-Tm09=~34D1jVv zix@4^(hTW7U<-AfE0dJBnacEmH(haP)r(_x!`OzRC2YQ4p@MfEk^RMQW<8uJt>+Ciw03>} zPH~)vi^H8dx?}&^#2az|Y_wHsQ*`bhr*^-=39>z$0VdPvyWV!+vypt#dgg%9n|eKR zT^CjvE6Bx%-8^0WM_8w4dQ!d3wXm6b$jG@L4wr!0H9i+MTG z=n3rG!)yabU`h?onB*@N=#P17%oG3%YVY+q>KrRFtc(R=@TuYca}C#M*0RJWdnI8q%(a@EZ8$#cE>&e zLWEKkhU9E^Ys^F8HJV*3-0Jsn4C_J$7sgGJf`lqzqdt=sGdZMr1t}4vF_0!Pcp4(J z_e`4s*=(ZrxP~J>&GF?*Bd8hh^rU?Ke1dqMFg~G=EBnLi3J=#M^7cy`kq+L4(z7`M zTFa;22wpvx0R%#GT8FUxym5t+@nKlO=4VkY@LHbL37awOU;@d%_6z%8DPkE!?aNK= z%a>qy*U@+R0;|mua~AKN5kyt;Ae%j4J#gt<_r9bC4u_mKKvBh~5;3Iv1Z5l&jw)t# zt8fW3V{Ob39%kBogMpcpdO%ei3roc(ePBGk2#Q?z%a#xzmzq<*biD5L$%d(nkRc^Z zT0`1yJr|LVm~cM+qWC3jS`5@z8#EDG;XEfUwqg6K$v1$jKD~sIyRt1>t%AuEWypD2 z5+f+NQBz^N{EW~Fop||gPEIFc!R*a=^ z)L{}!5h6r_;W2XC8e8f$FdT(gRt;$(R4DVXxD4hFqMGrfmSYcT4mTef)?CcqG*B%M z2Prw*^YQPEoGp{Hkoi){(-D%|6*&H9VCFwgjY|ltdSdkUcUBOxf0ds9c!q?P{4E>k z7$EElYw3ggD)=afqjMiwmJj!7S&p-8(T34siWabADqun%F0KhdKE1OPSK2ySj`IkM zScWHytPO!SDZY>o+FynTMHT$5SGu}d12&@&f>Y(6iQyUBcE^!ww5zyMz@gf!GU?<0 zk!cgXb5MR?H!Y!>pWvbOoZxlY5HTZH&(3*rjM|ol=wBJcufFZs^65;yZOOUqn$a^2 zKbOtcnptXhSYJQYU34Ya$fLQ&`%rF@NigtRW=%8yY{|}AJmb!3) zYU`TH5>MCpB=l<`1^l5>`rTir9!faAC*+(7cWdV@HHSf&%-eTgnEpgjq#TyrV*N-q|dzQoRd+Z6`<)4UF5E$5wD45&wwRPEl=?I zTr|^#a7xl*Dn!FT5*Q{1*}6Xl z$8lJ{pDj*Ur><#I*-2g|bivYu4e~~%ypm)zrVO*y!ZeMBF)H@?k!^YjD5}2wUONW? zuXT)kC78M~ zXl89X-ArQMDxXeK@Y@Ihv!lO_-<(#!ajau5)tM`#I5s)w+09j5)fzi4L-%I|4Z9zK z8FW?~i^3?Z5U1+1ODz9NBEgrepqap9Mo@$4;b&u>})u63~ zT>tRH6xN_$K*!jEfYn+>hWhSc?voP#?%n z0+Dk{k&^f{v~vnC`mLy! zq=E{U;-Q4jr`FU@zdrv(KSoR}Ygky=JI`D2f&^g)J)90(yAIV=Jl+N056|BYFo&KR z7(t%cvY$X5-Qw$yjP8$)1#&?M;?B30#A2lgz8Z;uyUkwXrDB5$b*iFBVptWZ$N;5b zBBq2}SsvC0)p>X0c?70?EP0hI0rq;-0T8ubQqR3p5Ys9WQ`U@fMYy%;&Up6il z=b%FV(M13Vx+kK9FHM>p(X&HL9_~7+sQk(*Xp&OTe{#Ob%A*<6=`L6y^qy5S1ZWsl z)eD_3Th^d(ZO&gOX8&yV3zr4G z2!#~rYgkKpLsZ|s{V|4Jr6H`~Okr2MbE1MtllQPODlcP2noPMxSI@nug*28j2tpd~ zM8UXwA@vC<8o-S*0jW6(xAx^l11G1{D%pK58-wqEOu7H%CI8pkQKOe%G0=tFVhDx> zx;7W`uh1Jv0&{3x9$yD%R1w)I{#f$?{`R={_GaubvZ$@R8w6vI4npQ326@=ija$)m z9~o(J7>JaXe5Qu;!B)Pf&fHJ~PiXDa+u}hP><}dp-N|44+#w`y@`6@NS%V_bGMFse zglcADDq~75pL@F15vOz)E%d-pXzq0auT{!kjFEXcx_Cc4s3&3kGHNdX09;DXtCzoP z@?^0sa@{QO@o?@J>9_eVLWxt>EYErd33;Oz?fzkAF#p%$ua}F{!v}JOLqo}jjaMss zKufqW8UY6nuKf@R`W(AQkad!TB%#0Hycnj)oMpKCO2#gP*fNCv2{*mWhy$TuuqIJG z`H!~)+DC`!?6*5Jx{w_^(!_etB*_BJw`u{AyK>OTnA!nh$>iU^_Wz&>47~2!e7{oNO^M5x&cx|Rj&KiF6Vs4 z)Sa$uL!)z!)ykANOwf3}j3Ph%YyXk4tuK;w@sspih_={3y5Y9)m>>;ujnv2a4op@$ zbkPdx&hwxg&VPByKABXd3_48lr_*B&WEEO!%m!e5k_&9UMCq8YMWl2Nj>v?7%;n8+Scy$A|IuvP`Ekr{B(R?>_vXY-k;`d z7?vHWH}=$`Spa_9py;|!!L`suu#{YU%pnJuFE22f6?=5zBqiQjH9@#wfxyp&7#{FW z<)X9EYw0%0cpy<@zB5;VhtnbqEw7`cFfwlIsR_(PO`9t(WVf3k|<~u z)j~e$J^kA&;}*R(GsLaxHTJYg8hu{+LJs8?ji?y1{CGgk-Wi>mPeCScl`#(V56@`u zNCqr76O_5c_QR6GBj!P((L7iYs@ih@E z&h$*i@PH}}cr;-qsalK#P|;TZHps!IeZ#u3cmdRf$OWs%@cwos3<65wh8q7)4x3A4 z%P|T7=49Z}@wLonEnBnJyyZ3d17>dYlc1g{-$g9oyxmXNiZZ%6??tqXT+g%`sD*md zH@0&v6E#qQpvf&P?*n_YJgUS-?cA`1eZn04x(B-D4vF~3bp`hfG|eg+xYJ#8cG@7N zPZqL8NW*6|eNG=ZZc>|`SDA;$4)3ipYgIv{YPBL0QUr0&4Vx)kdL$oJOCa}aW`=5A zQMuZjQnciaBzcQw%G2<)7?yf!ZHH~hDefEN2cPsjx+phNp1Yd%`*xEY2eXLWCO}jr zMouk!w9&~GO50nZ*i2B)Wp7+6d3s;`zeM4*Y!E%XPcjUH0NXhdIxKG3J$~A9AXq}P zV5)UM*p-9B>vp!R7P`6fFEfEDTxOk<>Bpdak59VG58VC_>4i47M0??ly2R_}Ul*(# z>CVDrp)glv@Uj~Wxo8+U7L^f$4Sl>noonV6WGJ?{&uwFWubokGYP2qiha}{vrMwlj zwSHkVwKE&S?_2g_!%3MQaC}3~t^V`?Wlk4;lPx;?js9)hsz7ENSpCSpF@r+eW9v*G zg_Co&e=0M>r$42Io15!Vz+dJf8ZGwJ(dPe*%b`<-MNdY?k0_kGR45qjD zMScRs1&xxGQIXEm=hIFI~sic z(CW;_*>oDCHzz{RJp#)vknocODcT+qeqzySpu$6=CSBPC(a4|IV>kl9|F91k-SPcy33p!MG)U0MdgSzP$$L8!ZxjuefDuRkjWb#qvGh5sdCuXw&aG1(UQTz?^*g(CC4 z(%8?Rn`3tl*&^q!)L(qvb~d+GO)amQ~+!`)H)mpsqm{) zm3Pg%jVB>g4<{(#b=Zj026;6x+@7h*=;`3YrqgE?6aA14S8xy!5(*iIv85iaLZ9ag z1Kg^wx@WCSEF#Fm#Y|`8M#e;UOj#xm=sQel@B~vDZHbG9wW1X65#=noxj>8PPZaN; z=pp1wLWuZ_?OAq_X?^ks);!wt>Pbp*#S{@m(lI=>lXh;31p~28_#eGI z02GFC(>;_|`Ex_>GE{_RRv$4$_k>_GVQ$x-DO9`A>$bRY6MdFnSrpDdSk%ro0gsuK zb?V^K;^+(Do+_r|e94%-4b*eqAJPJlVOE1t({kTxVVBTKgWcz%>DTsP9;Eq}Z2FfFcsP={LUi%N{V^uOur6&GhvX;uU;L1XA`T%B(C5m(?X5Jmm^09Qn98=ul ztoiXI5o(F`jvG=NJ+s!f433ij9P{Xa^434l`;*mG92@H2h}v~WrO6z#Fr|tV;Y5>l zLD+gu-*|@B1c?MFT&Q3IDP-`UDUVUL0m`F zse7K!^ewW&d9+$`D`0lHpGq#=lqZUf!we@R51LIwK=q|PER-mIQzRb$G$j?iPso(S z3yCNGrFY_}?F%}1CcO{&#_K7z*h+fcM=JM9VpOdW;ZDYXK5Aj?dZDE@krBs0X*sQG zT0+QU>(7iXec}8gUIlxy$(VFBPVVfM^LJhzUwSyrODjy)=)s$S%X8QcT44>R0Y}pL zy}pgiI6>SCk^$s!s@G~jZE8}|23_;Tvaoq|-KIIiQ@Ftq1Ay~SU;?%R@fHzI@Mh70 z}PoRSC9CJ97ztfj9 zu7(A#@fG6EJW~zd-;JC#CRbDx7id#ZJOEG9|Qs zyOn&%pXBQ?;5Px$DYXC|n%#p2F57i$+4|ln`BRwXRuFp>6zJ!FD|(ncq}{>wPpnYB zFYnR}*}-h2b1;5J16R)XpmV_|dg}9r?oXa+>CS3`MM3L^x@sB6hr{?J&;5Vth5IG=@GR1xco6-?>&Jt-SYMRc4=%s* zttk6EF#yq&4fZPt0o=K{S%eBfZ~{D@F_jLRXO4eiV_yo`zBp!eV`9%RgJ_s7q6Cih zO3>Ye>LNT}>w;oDgnH4s(fvgi(hHJTs1*xH&K8Y(M$L!k40H%C)-%_y@%Nh1{Yd!B zIqI|Kl)&2(&YUGK!}EU&+LTp+7uhN}^cIKEs&enA&AW@~+bf&KGwUiVIl7uAo>rzD z4>Q09N6s{5a^8&t)(LLBZXS<;lb-xPXLp=iPhah9!FqeJcA`fTe*qL`c75O6ezmG~ zzq>vSZ;yZaD|2Cge_~f=#YV|~Jw04}?mu!-h2#7l~1Ti*8sLLQdHgt7}_e*T^f=Ykx*F@Z!CL~b(d^Hy4~H0hMI%-)bu z%U`wlh4dy_!ZZn-i?vi~1AG5zRkCzkRu(sDlN{{gr$Hy%&k{;!z;>?BtJzkiG^G-@ zUjEB8?MUloj%#}ncG5;$C-5(aB`grxjtYPe>e!6g6%S3+!luR)C5^=y1a8ue1_QTGvOeX$9N&; zhzAUbgVRbIyGbTW(R*ytiOAi%xKMu5FBk(Ihwoyb_SM`_$BRQG{rD%nRzA_u46b2qyQ(Y8e15mOtAV-E6 z&v<0w7UblCrIhY5$*ufTH;OxxN%($7n1+=e(FSye3S~ffDO;sb*+#?#>2iKQ2>PW6 z{mfeU6m`*+pXliv&6i3p*kalymyucn``HkAHnxM;JX}dK26+yij$F#tHL5-BG<+`y zK|VDgLzm4mU^Z<847M?HcSK=Ev&n6ASNYzA5$S?@7Krgb^52CRP!(;{Rj!HngrqXV z_m)qBAZ&v*`*z=&g@mk*Pgdm~L^9n%n<2)`SRanXL_{!iwWK7iZ9Z5!vCsGj&5G@J zO~UjE$QzM8@i%hlx3ygAMNa88rJ0JH zQuipBvB>i(UD;%o&m<2j1tiA?@OpgKPP%O`&|wC4a*}JVlQQZ{4|X1jQl83Dp7d4u z=7Y&3OobRUT~$hvo6QK7OVmjapO3kysXKs3t-b5v^EnsfP_!_-;d=Eb22X_oej_X@ z#{3l4?u1S;nQC~jl$wo|_a{=IH=I%m@7Q;#^s*rDv#-QtDO6~hhQ6opZRbe62qN1801Qo#uzJ_yjXA37 zEe|bQ^kh9+t7A@A_{YeLd0(5e`gI;_JmVJx({;SQA5JM6qZdl(Z#H#Bh81~mhjW=y z5jMXDy2Ja0lDO6jXV)JwM3sP07}?jQKvadcaOClQn9%*?HTgEtPnMTvdg>4YjkQ&< zdz;VBBU+vzHW?!&S|_#0Nh$6Vn~>S^iKtTPfyc5HB=T!F70b+;L?a~_OJ^J+cheE` ziLl}r%$F=Qbk~ou#~7UqG082DGHnYT$u;o^qN%PKv(r%}9HXvG2Xct-K>bJ&kqs{P ze1`omg;lthk;KpK@gtVb#|(7%am^W2sB_bhdA*NEg;pb)PJQzltek$VM_(go;`w5vHXocyp7U9*a_@N+>t8Spu5>03TfoNoGMDq zv9-R#cTZQgfdt2%(Blu%6H3>#sN9s3ZiWKI4X6kGB||0$)W=DW@rs3Vens@xAl>P3 z#d5E3FLJN3FE6t%F>*i6o(>Nlt}wWFAI4(`|wvlF`%MOBV12;A|dMkI_5j+btBtyM9LwD85-I{F53%Dc<#k{Xm+EIfa`cmO$o=*} z?u2SIv(N0p6%1#Le&~q_N@afq8d4=+dPr0Kpf{d!2xD6^)QjT07O4t0-t`EIJ^<$D zT{!rFV;E7I9*sW`Yj}V-iL$55^CD!@mG&<74h~)(J--c(9lsxUS9fn?5bK06e-CFq zow;e^qwk~|C0NII_slYtu}DrK#`Xnv)3@cktkLL&yUv$7$?S3x7}v$CeHw**tP?~b zj=T@AW0abPbs6B+7}91W!n`a6i+=3`&Oexy6K?Z<147ueTLtgT8k3epj8q)RhF^z) z3qy4RP@)uFJ(8TNgKCJp2Iz-wyDb{^_gipG*&Dnx(T7fz{FC!MgfgjMB`q(g!;4hg zwj6hcj=S}Xkin4XWyF$rxe5(VY1_{E;W)SFtviT%sSh`I&{2Y5m)3!~LAf$!{ALk2 zps9;s<}llOg&1?evZfZIrgXVEPURq-R)A#Gj(5Uz6Xhw$=^O9Ob2 z!QM;@H!I~^<36MUFPuUT`@q(YqsP&6+`EoO8zGA$#WXh!YQR}+Mzg2k^4Nif<{8zF z`rm|RT~^+GsxV^Pgitkl`B=gNkYJI z`q#u4;)BOyO^+djO%%wB21om*d#*R3vcr&#`v=mSUtpc&DB&}Dx#f}keBom$u5 z0Yv;mgQE`e8xfK?=`#r`pRXs3QSQke+hixxK#>c!52ZpBBuw$?*F)SOQU2rtkFNr> zaXN@=+AoUw=*ge?gg*JqBLg3#VDN1r?#b!=>!jG-MjS0#-B0mlj15gsr?bWxy(85u zx?9N6##U`CeIEucGIU`aH5(TI)}JuGgKcO#qCkoy}>q1Aulo8Dk>)rjbFH!8g}jh%`C{%juA z_^^{ZqhCcJhx4($I!VaJ{5~Z^-3zjHxzI>LXJIZ{py{hP&+NG5*Z* zZS-$fNyAotiIHt4G4Wy993TEVZ?is}p{%G?VHeB$y2NP@&dV*$&x?_Q6^xWcHp za~P~h6LKOTNr#sC7(e=-Sx zjG|5kph*TWkp(d3v;oK_Gw`n;m5BHk&_n0+N8|M8{Wt3q%smY6E~FOjV3UaK2O^Uv z6_Z!a+9UhfEctmsNcK9*#i$>c$`SpYMUjAHRSG*^fj-ORMase>MTL zVb1;wmcaiyDhQjs`5RS%B+g?3P=WnDtezHf=cRnh76=Inv2nVeLdp9LJkH_r`|}Xo z4*!X{|8&0rE^0Q9ZMYvnx2F!gi=xtemsPm*oT8O`<3hCWzExA0-bf!&&DQ@G+ymLt zp_@E>Z<5gjzTxB$;#Nwcx6l1*{ZTuY z|7pRP9j_lzQ!n#p&AdlCm%!E9c~hF~R!_2cS`Bzk-t~2h2C{ZZSsXP8Q+)7Efy@5mTj*?o!y5 zKIobH;=Fmup^}36vSaaUgC@af@dWJqj)7BS>5W4sN1v%Lw`uW=(EGx?)_Q9PTHn+| zxd-yGesXHxJ*UdoLyvg|uzUx$22=7SHXC!7P;5O(`!*3<&6t}>oHAqX2ex%(;7X?q zo;k9a*MP9QkDI}aeMg=RHG#&tx>N5ik*-LOA-M9Si#$!a9^kQKS(@s18Ws3J@Ax|dBS@qEh)gX36@ zxn&EiQLlSJuU`qqweNv3MCn~&!iU0bn%q~O*-!%)1mWTT!V_$J4^boq-_T*X+xz*> z4P1R0;-LAJ0)fM2WXl>=UwR>^HGjOzEZaT5wEJvO?3!G3UB+DBxtp6#!U$e@vflzI z`6C~~Xsa6}a`|l|X(^)E!GVi5Mlg{{7a?<+^}?q6xUSCDHEz|%Y`W}95wmIZlRw4; zr+r2JC7a(=MY;(>0>GD``qz(={D*w!rrF0$fm;HZTsIFoL~h*BbzRyB!6*QP1}jJy zbdx-T)a3yeP4vw5u{-`SMDPZDE0%v6$xAVkQ$Gq0F?&^1@m%%jHDvx7FGF`fz2wta zlNSggtJ-RfaP}BJetkTQIA&YS(YLUa^`oq!^Ez4 zZya(-E|uX2pb`=&)k@vruzx&~+g1ain_^`-Zm%$inV4d|7i|Ta5q)K|Mm_Z(mEgPz zcx9A;ivMdR#<8+H5WRbRSE~ZAfB{JqUiASNDP<;cjjw?LlC>cro~dW+r&$|{g<_ue zy`B0O*SE%x8*NtfjvcBp(`#&eTuV2Z_@iPHP{AmmlAc!~Ew4gaMv0`H3{mm_j+b+i zbpHRd$(M$ZT;u+RdoPi;wv3 zJxyiBc2(@%Q;FCfKC&t4Rv<5EOQK&owcc-9Z zhR9$f-fTwtOaAri8EP)(MAQ@?XaGYNDLCON_nxqGAH=}%2Qzh) z(D+XnY5J^DFjGoUEccmx8R6Kv#Pa}5^eDoCNVBF=q?axAzSi|hJS#aP-<1+jvGm>$ zE%$MAvZ{}!(r507nX@2f5KU%Xq^lxiI%&W!@le=nhy!S+ zfwCw*O&C1SvY~h*fws3zzMNfGR!tQK9)N(m5zEB-#V|55G9;FBXvqnqmWAdA}BXHg0lN8W$5D(24P(-G$>~5Vv;))Jo&^fLIhx?`b)!(QF&nn zB%KXe=Ls1YZ}>Z_?NPAJZh^hjwy(}%Y4?N(h)%$O})cT=ZmYJb@7N8c_Fq-fwZ_o?DEqdF62Do{BQ z$!>LTbiiSm;^?)Ciazjq@>Hl`wXxkBo(fqxEt$`5wqA!i;{@q1-`VKE_kGCb!Hot) zpMB1c#3&DyvTgK#C{3~qTTuB>Ql>=kZ zEt(9lyINIMtUgF}5$9BZKK`jw9F z)(sBtzjL@3?4Q5Yfi4K(PQ&u*{%l-hv7Rk@s{So9znv-sO+ys0UQmGRurWXJt@wk0)cqZ#c1Z`7 z+52w>tpE&32nS4n!%rlyo4*48#fQ;Xl>)w4o)ZVzEGUaFfye<^kPnLR`@=jx;RAA) z@*!(Rs`rU%zc4A%XceNGiwe;Uquj+2VY z_ym=o)f1ixFiMPU104ILjQEIOY};5~uK{4Rj`(R#EDW;>hCdAQZj3m>&?ZSI$gLYYi}A4?)uWK}01!O$`Doh=gZ84?Q?upWZm%A4o?wfD}eYL@_Q^vml(N zJdZpU?#^+zeh|v11Cze?pW*M{=i5c#}xuBTn zt^ql$GyB^c*cxVEDZ#CDEg>>7aXeiY_*^JmvvGi78N@lY(Xp#kkK4Q?40BNzJ;X2@ zXi(lHQs(q*34K_}NF4~%Yi2?}onX)@7m|0?5g~JB@3|YL%5Nxh)gdu*eB6@XX6Tez z?^M6SjG36p{*;MWq(%KH`h@Y~h%reY*Xv)0gFB_$){KZTB@sg?pcM%t6;r|mqo%Tn z@UpQwWy3tS=(mS;oSKoF6~k9DIs*r^{S0~8Ay5QWR0?|;1gtF&6*3yxsc}GTmfX0Q zE(Gj<{}nnKj+hdNJ|TJvz(|qQT3}Z0hnsypvSPs(Z9oUtb3LqA}bZc;+=K(u3#<};m0@(~&`ucl%Vhkb~c4gGsqV8b^ z)9W4m$?Cg31$3HBj-S-w$W8?2lQ&`f3@JgX@|-l@|J2SE@10HDh2cc)@c{%TrE|^y z?c=(?!nhY51Hle=ev`}!aP3NMOXZ{=-UR+VUc-v!a^4TaKj5EDaGHHjgw*N)bvO0F z82!Q#N~XRlD>wqBrE60GnXMgCf@U9)E&p)8uRy|^pibHTKLD~oO}{D+q%{qtF|*5S zR}Jd+BFX5rmYXJ-MpCQkJPRjW#)H+E(Lq-pr_#R~mGbVPRpibp>S1?GZ`seDx1keT zL;ntKJ-?Yw?*u@+gJ~Cc3wH7pD5X1?%=0g@n>mskA~LZV-F)oOdl07|#N`e!F+t@j~BwH*U(D#@Dbl3SV}E(KzgM1Ft>qzVXZi>47+{wXRhc z%gOZX1Yve|8H>5eY6-ZQct4q=fn-!F<=Pr)`IM`L(o4?mvsIC5xzCOr8n8Q2a0(&* z1@{Hl^gIF&7fe1O_I1>`};i?)F_QYXiMG@(X*)im;IS zqgUngIL3eE2e1i8w-fYJ8Ta(sFid57(duN?cJRgvUiJoW zGip2@ou(JnZuxDm=XEru?XE@9yxbR~QU?;KV^v{0_%!r2afxax&1WymrT^UA8em#_ z0z>C{LEsO2dP*`-+lARXiWo~fw|2!k#itr6BFA4Agtts9*ox1$fg9et`E9sP?C7Vy{qMXo<;XSi1IPtxb5TvMU6 z1-PP_xnt?jSrR;Me*Q)bGrka5QWaVaM5Kd4Rw-QC%`g*dawautxgk}>ttM{3kUc#6 zJ<3{k@|T#WFq_y+A)AFLa(86T*JH6(^JZ~dS$_{s`6^o@o(LO);{( z^JV$kzU;)7QTyfSu{*TWC0XS$)D?CWC@pIg2)8*=s)}PwFoh@GPRH|`$4@2Nn^y1C zYnraL{ge#qW(JupvU=Le_pX!Z<~W~5l6i~iBbxF7Ya@0>@H5vwT7_&)#Q3(+L#!ho zpcZ;K{jj|T5>no+{-N1AwGaRNkM7CRJzP?`G*7~uOYgA0Pt!V-MbmotRqmA?o>ShL+ElSr(s#6(I2jnri zS})0sqYzxj%qIW`rN9>|A8mf+N?G12~oXxuQQaPa>lVOzYbf#hSyml`f zjRUN52SFH6?>x^c@ikK?K0wBR3qPqL^WH0>B3$XBA~--2-4ut;v58lmG*D`r;yb6V z^UW`2CUxWSTo_tzj=Px7wCQLunoL4S6E3z04VRKDkM*Yey)2{D;zZnmX0=|&(4b{X zO5_;`(7`FUxKjI4759#xAc0^UUm_YdgLCgMXl#y5ZU!mv%L1Gvw@-HmZsX{L4Wfow zuZu};ld9a%nF6T-5i#0Vag5jY^Jx7o65Uy4SD986!-;@OEu;Aad>ivSydq3UfTI~i zJd)tjDHIcKr^tq5PT_)HM1v850>mp2I`zBn(0>k(;o3TRtHSUR*U>ay-a%)q)qLXR zS3HldCM&=~PTE7NCr_#UCx~M0!S!cc;dQhWnWU#a!(**>D40of9WoOb2;wT5k}-+m zYmzxMgG%YJXdtd#Vx?H8O^Jbo)4?tebUdupIkoM4;xhyft;u|GH9>o~1tRS^qJ9*c zB0o2@$L7KIQd;T2=x{UJ;5zKw*~lGSe}?UoRuB#y@Er)fV*z==$PQZJU^wm${83Zg z-ouLu%!fa!`+MV>;51st3%K`fu`rlLhdXqNmm%5K;HfIw)j>)J|9NhEOi#F}0m54= znICMr^Dj-&*5po~9=|+GaNIOw^_^qUgz@$KE{}nxr%}x`lFSegJEG&*RmZ`i=u@)dTbk}Z+{(>t6E;fwifVd-=AYvFEJk{dm5m5Fh`QUA`A z-@Rb1CCxIeZV|HX>)m8I{r$tgKk?gQjBrc>@9{z_+SfYydhl4MH$D-7Fh*qN0vl9& zjVFxl393AvR0slC?SHibM!4O&a7#8-^bZRPY}3ObtyPXQAq$r!1d@Z-#8S5`bIQ|! z%t;ynez0wR(hr4CTzJaA=ClR3-t*r$PFjeygxAtu_eI$E`uI=t_^Cn~wukR^TF^cT z6k5=Fi^)25G&T}rl5f%=Km1##c20*n$+yvZIwnlj)dx-=Z*9K?9wZwVB$b7$^ZZaeZ#X;GWgNSDLnWNF1l_`dB|NK>s@2^p zT*Vh(qIGx$TRrQVie#KC<@oU1>>5%xiXI>)>GUH+{$+zhL^K?8M z!DX0z_&Z#zmru(jhP8tB7>UdqsOjPn`d%(Er8HZ70RIht+@|R@$Yb@P{)uI`&+~w{ zT`Npn(*qnhiedTT688x9+iv`wQs>d4cY}(-gAHkAkYGdCaT070F+8blJT-FmR_~0; zK=Gy6%^98HPXGV_|NqooZExBz5dO}uh-f9$YJ}2hlZu3T zjI()T-mHglI*r&e;on@woQ?)ZCIINfom&@+P>!mJu7U5fz#|b9a^Q! zu7e^&#Ub=msxFlJBn5@|rRzlaDMsZ?@l?tLPh?EcM3e+g1)0KJ7?Lg+ti`i^ahuX-SLx@MmQ$~gZwmYboZYQN!+W`yj_%`H;5##k;LNt-u296H; z(_L+_98Ye_(ehV?;QIKXSWtd;JMaoSsA$29Z8+zWvg?nxOe`TO{y$`PLsIMbAJT;h-q{`;sj%1j}5bb!TuQkC7*ByoYgzXwvlMXrrcB-dg13td%7Rb zg#k58YMy&zHUTXgIzH)1Ti{_@Rj;1tRnn4$$k6#Xn$Dh;T0QUtl)MF;jc5hW|H0}9 z7TR|Z-~Ty!97BQ$U^DnVhj9L2B(96i60)mHpUIj7Ri|qXN3=tUpeA1w3!4*_%%{U) zG#KrYtRyBS2}^cc#xOm_h7}BptzWz#k$l)`o2JpQcV4$Z!xi%oimh+g*Ol+b+8^yx zO?*5`6Qf8EWZe^g+MEXEF8}}l|Nrb=&2GaW48Hd%5SO%5rQA2|Q0=h$UI1m8CRLi+ zXfid71%kY7XQWd7X(E)qz1$_TAqi~r~LOJJ}|A0&>fy~dw z5AtWGWs@FA&<1;0q&uQYhEJGWg_w`dN8fn_ZhVmk;Fa5Dhbv`t2fKaD8cHlvmux_9 zAU1cmHYB836nJJsWnDsVTl+bib8NH~eSYsTIYAos+z0je! z`c!!+pU?F$SwkKL#luw_?c&_8Nyz)n$*_Zy!_SCkK zT0mJQnu0HEOPspP)Y%wXDMg_n!;((Hf&Glo5U%u*&=9s71P#G-ibF%dc6MlpEa4x3 zhDfi9K|>&$b7%<4%R)o^q9_Ip0sA~O)X^lNAv6nIyWb2AWvtMg&=3l4AT;F3z9$fE z9MC24pRYwFWfhr!enr)FeRzGTai(qwNH^z5LHHgQLFf~5?##a6K{-na+ZXtju;Igs z>at2Ym}b_+dST+>hUL4d5_ZntI>a!i4afWQ2O346Pfay zOC|$6M$S*S*L`Ohpw4>vPX^ut?LCzI00030|I}SyPr@(|fA>=?=!?b~dGN{bfJ6x~ zVFtnM!KBQMpfTdYB$%k*-MhBewPPDy(mn75JFb83%C5im?pli2EbL0|kMG%Ob*CRH zkTCCaF;%2{!UwD1MKY@Vt#OZwWnGUFc>Lc^L7O8cgKCyS7dY z)@ud7(77OaxWxfMelboK4aM21#jNA#Rzq(F*W0$=^gXTCp~@b2A$<08qhX`e>^mZ7~v> zo#uJ*A@^iF>#^%$`KVV*%wyZ3CiIyomrsVkU*3p{NfE_?`O!w^TsHCNeWv2nE=q|g zlf3ZnUB>WwU7W&0TEsI1&4!k^oDWbeqfz zpp>BPXb_B_%=ju!Vt5Q_8GSar6J+ry+$L13FxD~qfC=?2TF0*<*Tl_M@;?9o0RR8& zU3+uWND}{>e2PJr0~_qv&KrW+A`h1Ag@j6+gQ}#;tJt!mMYfD3vB?47{knS|n$bwM zam)dA>{f(4>h5{Z^vrbsMlA7Oym@nU(B9K`j_C~EWiVc2GR*@=WACGQ6<)YqIz0WfxAz5~bo(g1iJM6A{b--RroJ&5 z;|`SSWVe__|K&00N%DW&-ejNI&Gu${a~)nrqYi&=u9ufs-rfd3M1)*8O68Eho7j)> z=sf=vfwC?r%x{)2U~W^vMYQRq=9|COkda<vp7U?fuh+Y7S22MgRj$pJsJleOh#^_unkJQv!@=28TGT*5u z=uTH*7(j<7H!@6CI3AFL+1`^UQw~EXGf%e4NVoh^#GEV5#o%4Ta>Urb;(2<`!}*AY zLA1PaxWyO+q)?M|SmqD|AG0x0DP$`1G{$;Cd}O++b78>r*oX?I-9{mAqaea| zn`#hA+myn#J4TOKiph{Rk#a&3@ihXjPRt_qiM4mJ@S~@=-^Aac#e6|0KZWh+UQo)L zkRSFN{5@sWh6eq3b-{}gzSr}&_4O{Q?wHEU~iZVpaB13B8Cck&v+^;ERcchkq8-x zZxFD$vB|!W2wvdBi-8tVC?gtT+6O={f1}T3PA*0l)duucm1*`2{y=Typ;ua<$!wfe zw{L<@yNwf|by|&$4to2Z8+Xv43N%BU)DL%G)A=>$ z4|f1-`y+1~PqR2%hbePahkD^Idq$MNWCt%gPt(Mo@qtc2r!4QC2acxu=2 zAgG~+iZf9X`$1F_Vrqk^U$578G3QMtBMYjO;HTKxp?_b9iVF-!&fUhnhyF*Ij zFirel9$ELnS7EkS0R@^2&HSMc^H%`%Go~>dgi!HBk{Kg|$rHB>$vlvc=;UK8wdhFM zZ^G9V$@mIV0i{`ixtDO}rBxfH88jXL|Eha-}omT1qQPlSwg}z z5ydX(oZby+98ts}ehS27PgAb?C%IIA$?3j$dK5H*4ILMw#NC;t*PC)r`4pv|FC zauvmXjC-~ck2mS{{Ei3FzV&#@F$Ps)7$unu{=T<|(V&00ufTi}C8B~;ao3A6EdywH zk`*eU^FFvu!MnqOhjk9^Jc3e7MrrN&MuvMyoQyp_Z{CxLd0oFBT@d_Ty|KEszOlKr z{Y1dvq0TN^7!H{=R(eoEa`u>QlrO5Q@UQ6Zh@S_8BFS1$2MvzEn@&1*uXcy*)tl=1 zJ7}J=Q$zaBRKFD6vft^bP6=HRe!?OU1bNgE*Q$+G>WHgr^)uW_ zVtn}gAVyYgM13^Ezy}|8mU6HO@#E(v`>><^xG#P}iJW>pv_}pZ_P<*Nea)|Yp*G-> zQI{I@a8*3;|HBcjRc(qBx6*wVs^$I_K05g5;={v74sgUaPJv@Z9+}*|Hc>xtajau~P-9Xs zANaK`gJ#6{(0MYz9;;h29En=g=o`>a%bvbwsq zwzXPc+uYt*-`d*Pu5TS3Nj(j9vmAmTNcSuFP8|$ldPH(>z}VptF*df>*EhG;*Xvtr zTlFU!8!&iooMV(tmhB81hR=awNmZ@1tI7 zvL?h@klme3%5$_3%te|FeRs^gD9vAS_xOaTCSHZKqQ`J`F{z$P`8h6wxMJ}r)`tSw zT+8D2%QA33x}f=8`B00usF{K4h)Ne5hcM^jMMkt2aqahFQt`U}M_*`bg_S*UZ>H6E zaqV&DymClVb~%}rptheqgWQ$bXNEtXKi7UdW4;Q9SE*)E2u4$bw3gGK|728CiYPIJ zCx&$K&DTHq8D<_uBH~D7Bp8tE7x{ILk@xQ1n;BBDXspy{^o8081fT$cO2@Z(>jotovY=tElWkiN+h-l zJ>xOOpb_)I%lP1w(jtR4AKGRIo>iIFkrXTFjIKLX!*1N5fw#?k&g(e!B;OuXi(HXB3#FBms8t+r$0VD+9KQXHdH_ zKx9S_Ikjj`O>q7+8%Ef%6)3ZyhsX>VVaHY=VN3DCw*q;#Oj!Qiv(}5&LAzyI7HRdV zK%UYH)tJ*7O#@GDX1z`|ZoT%j;N!e-qgvBIqh7V(f0e$1^+IMsL5{ct)RC!6d1plRQW-pApHwZbrX@8gLezi{#@=|4@cgl2;Ta&d)c zjkMVA!g~)-pP=VF`x}pp&g0Q@MHE_y6ezVxUM&P!3;0=nIW~R3=549J+(i;Ztz#aDeVK1cSws*3BaCXp|(w7Uk3fFoA!o(6BQ1e~9 zI`2n-RFi44-S_C?S=NbglPJw?N#wM=qb^D9M0W>N%Pk*6@5`t7mdf6o+Fou#Z56MO z%+l*}DQDXwd2#&v;ql9pwy3lTo#*ERWCXezfih|?eca%6z%h8F{ch7)mapWDNl1u+ zH}HmJ>#%%yyhldU%C;Asc>K7jFp+MEOv)fKT8RWa9$0Yq{F^4(0K*F!*{UEUg8FcS zcKT5<61b2e)qWwB`7xD~B}31Eo93mnd~=!4mW|3vpOy*BS=D*Be8Y|Wmqn3f&2vRz z=~luDoj$eB6+lTDduGmSO4MpCwZKkapFU<^R8mr3Rc`z{_axv$%lkNG$S0b~13dZk z65SoHv(HFsI>WF+`#V0r6eNn>Adq*JLMPy9*LV?nk+bp}B^K`O4H1~i5-%ES2BBb> z-8)?<2>v4+dBc+9R2+`N$=e!!DRsIPSa=;}9vP~3CkP`CXv+(la(2uBA#w(syt_W= zAX^PW>4}KjcX6&H^Y4w72H$0P>H0x}*32$+XmUO9qZkAwesoQqX}xhcU{TV+!=hdi zENOf6>Qv~{QaU=}aMw=a-gY|<+uPe4Pa4MH$4buO*$IYM8%~8e=dG93Z8;d?F}lSK z6G2IcE|;o}vOLcEqzW45|Jd*F6CYvqKO7}7H^;qPTVK6gt;65OI*fc!7zgL4Ck*#= z(^C%V5|Q*S8rt*5CjNjjR>6N&#FKd+@C;PwMe%6K!+NB& zHCbKv-b<|}kfhsT(8YNcq*jTX%vGTy%OXwdVz&^8H<^y-#OvOA#ddFtpj+q$_O zbfdA-5H0*o82RWzFJmWzVA2{rmyF!&h0U1C5epOxHrtFb3|p`tg+!NW#3t{Z8*zPo zjNbPHKW0~#Ynz)9q+$1RZEO7sM(!aCuhH8s>3hS0d%3o@qRpLp=_$Rz7-TMChhr_uzc5`o|lzU8i9Z9aMz(XZR7;K3&;xF;%ol zeT&U#*mcKUD8??q-WW&sMg!(UFSKADjZ?<{YP3@ANF78Uo*urdu#>ZwwT3PE!Gi+f zUecLCHqJ@2%RJnDU7bxXFXX9`WnV55%BAWRJh#18z7}Ea>sb^(kge7PWqmPPI?wV{ zT|FgJs5U|)ETU8j;vj`j$3w%UhhoYbV2<6 z@etKW?up$Q1xbW|OU|An=U>fhw$w%kn!R?rtohBBG`{kZRDHPqk!pk$q358^1bRzF zswTSE@exvC)=EP$YkgDh`<|0=+lBUD! zj}@2sa(>DdSQn0(*X;EDY0N&_7l(ajpzKy7_7ML6%mL;+_AsiISgllh_~)Dh8QQ_d zPpj$p^d&Fu%pf-_6Thx@x(^!%&4I^RtEl`fkjcd%N%BYtGf#B$Z-yf&hmo&>k(5j` zph$|WEEq&mNd3kbl4^+k=^-RlgIW-Rq$rszfTRdsBz|OmS6C2wq!2y{JW?Ymz>bvo zS~*-lFLLChVdvWcN6KQG2{%$N_ldBPU#*-j5ENUvDp+Gm>cgO*OQce*01HiA6Zouw zsr82mPyf;aui#KZCtkv#Ei8c{1FD_*IODY(CYOB$3jfp#+>hb7xuk)qesu%UIVz`*y`era1w*2ROl$l~)TG*CMIPNzmdDI<=^S$!K+ zs#V;{OyVjOzy!@^2JXo!PS9<0QUp_&(|Ruz>J8~aHM|zqBLKYYJwQ2;qBTg&hMw2; zV5z`aaa&>Rj(u^g)%7EkE5ZKsp&SGTUA(uF-%{3G7O;l$yZG63vc*zSqY0Mq(gFv} zITwBfNBnsuW?cece*TsggmSCg7!I)rtpZ=pRE?u1#XBfHMn(&?9*ah*JsL_#E+yhM z;u)|idv0;K-#$5Sy*Y=O`{1Rr8O-@)nGF`PbIZX(3EC~BSrlL1zp6o3Vj5SY&e$Kt z1t7knJ3=-Ed7G2x_H#~5D85B}J7gMXhf5A%7VB`!CeCJZ?zEW(5ghG{u`XK{_TF=L z%$&$-ZL#s~an-KHo7h&&2ImTHs-7}%M~<>!d(QOm{{jF2|NjD(HK1Yv)O3nB1Z{6m z&&f|p%&}4^uFM4%8`fM9DI=sgM^qIG5Uti+;A4*mWoZTg00960!jXQE3N#!l0HSr7 zhE|{fqXR8^krROunFB)r00030|J+?mYlJWm{wpE{^=5y-o@@_73rm%Pr(mnJLR-ql zzW#ml(oB+x)!po+NAs9TWHKa^%=dW~g6+oq&6G*XjfY<7z7EWxq5e$m&Pi3=mHXQ9 zX;!t@uVG?L--b%kgqQ-DnB12YJ2u>ubu$kF6y*-*bWy}7$KmPl`u@^KJY800*Mb;3 z{R=U6vGY=dUg7UP65aQd82yua>0Hc@!hw0J->Zw6forw9=b`KRw}3A!RTP+zb{r4G z!^hYYlBNVqm3_xbZI)#sr&xY|wg>p?YL%b~`)iWae@m>(V`QO&;s?4Y<&bk(u)!HJ z!{=DJ*5z&$&FTQzR+g=qHmT$C$L{!y@p^WAP8(uIVpFi;4Y)viOPKj<>VKLRxHT_)o1^k8L@7c zB=G(fl+Pfbi9Qe8icDNSgzH40?jb}cvOEV@6H2OIHJm|&)vyv%u5GkEm$Ht z%IbnP1Vf3uK!i*?9~kwK$uL26v%juTIvG&8N*Vp3WKmnyRK%|i*5>9dR3N@uo{KqA zb8_ICv+~sn1)KS5Wv_L7wPHHq`D%sO^Yhipnf?pDT4h(^_-e(!LHKG#d0@U;bWw!k ztNjH40RR8gT}w|JF%Z7yF+)UY?h_1Lfkw-V`{GQLGm@>Ug=)75 z3a&ttPv$tOT0$;MB5l$_Tf}Bn1vx8;oJkv1h_$K;a#IoslMbp7J0TKn z0XO^)*X=3$M=xo-|M|iACo@vON4>LC$k|EvN_dhIBEDJ3lFmY|+tc7fXv`>cC=}Tf z9;d~$Me;rtbF@u^udzuJnMJ|Ktnf}Prp=P4vY4ZO8vIh3H8ti@Au=yKT8nA(LEf3bPg) zRbp&OxIvQUcykne?f0QR3`bvky&-1iEg>L%Sx9IU>B)x3n74(5^i3h5VWejo>i4`O zB;qckgoaTbMjbcgV3L_q^~$uQi1G$*vS~{hHM-m$(~&YfmGO%3X?RIX!uRz(DBSqQ zV|gYjxMQxaeo-K}lGVPVeFhBEDELs}W0*oc)P?r@ns2DeRdun;?RLe!R^eFVVoPVA z4%wFGgVCU|PTfnrhP`k=mXya|u8+odo zbSGqe+wnnPeby7;^EmJK4{>9Tf4ZIF(UIzT(twcw%1yCO!v}Dz0Q*8#@ZG3Up!GTP z`@>_OPYKfx_3!6%*fHAtVadB>G2ZX+mxKhF^g<`zEyIo9G zyQNxP)9ch^>t&NZpByIkcN3ERRv`TY00960!l4@g00960jGVy^f-nq*UxgzkhA0pc ziC(#S@Cnd3LV{xC;Oo0?W$V^LxSIN{{YUM;5NAy2T#I+*tc>|)JYRwL<7~+&cvW@X zj@^$74Y$I%w4m?htjslYG$|7*<`jhbl;WHwNU9t9`yY)5oz}yLV=(?wB)~#yk7>O!H|P3}xL;OPe)MU0}f5ofmWV9<@O`M$>}rl8Dna(O$(Sxh>a<#h7) zi?f(!jHRenN|37AqLd1RQj$*1CYe;Al9EJfHff{+iIk*Jvqd01@epEc3k9HaS^4rG z00960>|I$;+dvS0&#$neNOdA4Le)be%0nmx(wagK(<@bgh(emPb_u1B|K6FMJ!X@& zopAI}!V})i?9LvZSz0kzN_3_7vbZFex=ZwsuGol4grv%u#cEZTmnH}rg& zvo!A;e<@CH%S_K+UwdiX@!23^{7>iQ7v5UU{$xgWF7vEBZh;@q z$8C%Is5k*cWdrq$Eh~D; zvvb=@YW!r5PP#nHEw4ZfzHT!y&#j0x0ZP23(I{9v6Bk^FXe#-wymycql*l?PY`?Rk zt>N&HCC9}DNr1)a!D1=VX)GpeB1X-cR2NZMV~nP^E~h!Y@r`=ej_hVQ;vko$3)YQjjf0yUEn+3w(& z3}LvU^%qs?9R&_@el{_x0U5>>Lh#OuVQAzVg)3T(kqB&P$jAmzx#Rin80z;5zF9Et z8b89=>!f_JQf}^vg%PE7z1P*3o4`7TK*dSuFiQ^srpzK-}=VTQ*zHvEZxi z02PRarcp1az@vF^blid^a(dSO*6H^8gW>lm{&7CK_<8vYfof_S&o-ZLZST}yybN|< z?d`vQ^Y&eM@czTcPfdwflda<6oj@PO-WGJ7L>a5@GEf*fYz|^G(F~_vMr_$SjXU!_ z=^R&?XO`-1sos|AZK>Y=2le*HG@Eig6jV#GM<2yAgrQFHWN0^WgGH~7Ch^>he!H^_ zz6+<)Ebl#-gwaXV{(AZOA?SbK7y~-=)Q{yN1|NL6hdYMyZD-dCWyzi0B;-oixj?hk zu#@etDdOMkUC&FyFcdz!zoL%8*lh*zGIkOM9t2SY4?+>$P^fOW_UQj^Uh?wt@~dl0 zrW1PWmM_gq+q`^9U%wZ&#&eT;@TPH+W-mok1Aoce^7};m7R|WQ+;XDW=^)f!LN{RN zf!s&z3exIWKL#q<2}7t=vo4kq?ynwe{J<&JJ%);Wrs zZy36=QT7=^w~^BFiI#6FMN{>Xnz6P6v9Q+vP{tCx_o5VTJunskjx#U@j=oEF$d2DH zFX*u_l3o*iChonb(^-a(R}NqDR8u=yNjW>CQk`?#g?N|ewC2TOj9fyC`B4dL5c?2!)&(OMI$0tkmStbpznB6!zvZcXy<}t z)252!fzCnU41(`?en2&QwWKEM{J%j>jz~7TT}aQ1t4oOW%?XJa6!#CS)%7D^m9-%+ zZvDU#@Xz+H1~M>^fq@JRWMCiz0~r{|z)6t-JEBC#X$Dk)ob2Ah_RX`HVAvc43aFJR zeqHbOD2S?mW)qWwW=voUN5qo0u2ZEjIciHQUKeNFw`Im})%*Cz8qo z(ac0Vd(l(>F4|3B3oi~$u$!GAy3VufKzv;guM);sj;oSdcm*zHf-)`gYqF3w85YbV z4za-)%m~f|d2BnpgyG0`miTN$h1l#CBmKd11v-Q!wg6cQ{V_BMgnzILM^hiu!>5z@ z7*W#0+GE(2#L{D-JC>XWi+eYj?zv7^Evx6y$-6n0k&Kq3U zX$`pc5Ib9jr7#rv>9H*^2U|7(H)RK-z-jO_#5=p~QJE}XT zR;E~XOkLh()v;<(*ip?f1^m8}W0^-bR2G$m zM`>noBVd6OV=iYe8FM>7V46f}?D6Rph;+LK&m5`|wJ$Z|q}2@$lWU5w&SM^W*DQ!U zH`w+i+C3vTYGZj?(lgU}{N;6{ciY)fA)QO!(y<2Pib%-hA0Q;(OaTkz%8m(Y+38pW za~hZ~T7o6uB?dK9yN;8Mx+bNpsYCZOG z;t*`44FM=iL)Du`2LJT%WW_yy?#rGpdNu0`rzG_}&S%(5UP#v7xMs92tgo<3 ze38m3?5az662YFPp)aHqCE%d@!MY|}HEZf*v23cCht140I52}mre%EcSK~dhK<%q zs&E>Kgxq8<^eAxKmdIhKQFEdM3vnH@`hp9NeM2o8ZSC8v=F}=>D%+7gFItNC-K(pZ z-}sUfkcp)ba}3t7WfY2QJ9C9lMxtF0`?l8;Sgru$w(R`JMx)pIi48iF{*aB|AyI?g zWYRlhJ@!X`@|JbF=aZgfL@fPBpwQF7&ZIKN?XU^*CBLOi9yu?yg4e64*FrdAIlbe+ zZEeH&yf94Pdf7W^3zd%!AU*5Wk#5J=VE6Yi1n5gs% zP*FCKTDw4PHb|}g10~Ua!#`G6#E~QnEolh<;d{-t-0H(Uw>04xv zQ(O*nlGCL9A&mYPjz-EWny5-;xHe5P%lyGv_ig65ZYbfkZ7rn z9oXp*5g>^*un=*7k;1N!6-Yq$Dqe3E5X>4mvT-}VT?M}9mktJJFH| z-@`I14|SR=hdsz+7V$I{^OHxn`E%W7uAH<){A}%c&jgdlLj+!XG0zZ|<2ZurQk;gLnyL4A8fP-c3CP0?_mIG+x zLi(EoY86L|*j*a45=|bQQQM~fyU+uO+T=0x@ECe{3_Xw!!TrTGSlpi(dT2IJD?<-& zDD?2^toOSNJrERZ2!>IIM1~z~vhg1hX=pvIiZq;*BMr^gXNMY&_DroGdBR8+yiS$l z8@Jw3J`!PWwC2Q%TcZ*i)wMjMT#UPbsH5;3H&AK%EE|aEqXfk2H6L~zFlpR2n$M)H zz&!~ai)!OFc^e*E6Q)Pg15J9MU&{}M3v0m5GIftph{q_zzZ8X_!+Doc2xVCl)R+$k9PFJTMBe)ve9pzboW7qF=zhGQzOQudM|64*&oF|Nlbk*y8E9BH4uB zBpUW`0qk90Z`v>re{Md77m!e^LAz?2Hc&LNl~!m~hal4))+u5@J47LfgqBt7cc1Uh zN$l83_@l0!v_7J4f`Dzs!}0)U~eL^|<)nI!5wc7QG^|tzeBSsPdPz z1M!MId=8m=a{4;{L>YWnzRyP%?}!d_)5rMettt^E$uHIPWJ!JMI5HGdX%{-Fr|b#Y z${AAGAms6%2rZwrE;e&6&cg@iu4$X3e^~?o=%J5yt`Pwc}}|1yBF zQzL$<<;me|(0duZadRek^?ch*>|&N}CUm33rt|g(x7BldkQaZ_>d^PMmE488WWQG8O$Px?ypJ2Vq}sCZ2=ilOwPyDgZDC zEFHN?0yhy}UJQc9+6aPWn*ly%`N%NJpx7Kvmr-!4aDUqEfMy=3Ue1(BmIj`gaxDO+ zV{@5MEa7L?VW;T19|Yqc99(=sIvfWOsAlf@34?BHF$SafMYTGb0ZBFFtH?X<8!#eV zlU1JxJWgO#cWQ>MV9N<*gC)n&c}^17vUpx77*(4K!}?7H_@=z{_s%%vu3A_rbq;W2Y7O^g!c$Z z2o5&z&zt3J%uBIwo1;UPTM7|s6BT?!`i8a4;iNkB2Q|ymYq>_VTd(u!3_g!=+CK9T zN$^-!RPaqX`O#I?8I==4y_+{*jG$IM){qiwtwIQ8Qsxij@PdaKLJ$KCxpLXVd~#i- zu!jAT!ABRk8R^eJSpE2oN)jUIFRp`{1>hYnr_*07hg}1#CiLr+kF71M^96^ZI($Kv z>AFzB^M3eKlJM4^3rfioHdIgk?eg;Q`vLpS-q-1HpF(QfI&grm|RhP22-7fRy(3Y0oM1Uk!#wohAoruhnUGo9^eXg|BM^Na2RSIJQzX zA`(kHqM%{*o*odt!iIPu9Xb@85EYKx+n{>^mX!(<4rs6pQTw4Vc?P@k2cifcgQvv& zDrSBdJ+!jK5PQUptvR)~Dj=43LCBVN9tXT|O~u3*4a*-r1z#Bz97Y*ti?+T~gfX3^I+j(U0%$p3Ivr z0BOE8@aCcXsHM>s8NuCb-ZM9GX~FDd=+eyAGk4mvu{B2jP2Z!KK9l7CAp@v`I_KW3 z^lV5~upLaIuB`e_4jRGZnn(4c5?c2TTS*EbKYv>;v?WldJ~>v8XOegQ1?@Lu@kL2} ze|?kowb{LBU!2uBl)++Q2Mk!!TSJ-~a?S{8sN-beVm!YwEh@2>-54G>9xU~iV38H; zSxQ2hG)ZfP%+f~8;F2s+J6YhH_dM=6yy|I%N+cpq>u6_kdYr?oOr8w!4 zI+bT!TS=2xv1go4dbpKoijo-fDnZs!9sl?4E)EhDDJyQ%X{UL}#3F#@0@(d<5c^^D z;`rdn-vNmv=)Dk;N|b;|KR@E(hr~nG;{QQ76smVy>eL8^!l3>-7D~fxhC-eAfswG& z@P!*a!I|e#=%6(>f8@qIW6XnH)ad7!gT8VbSs$yq7*7Xw_iEziF8q1jm!CcRm}tx0 ztnXfp4v~EbjLax#=>>JmXL>1Y^{0BsG=@xTey*3fAJ;z4%g6G7Ms*ABZLK73znKJd zZF@oJrKggw{A&GE{>C1Q|2DutCdWy$AkH0ty(Hu8)KV?8J7C+rZ8PX#9SJo7);}7X zuzWil@=wKM(v4X^CIyRS%mFfaF;iE7Q;-&hA_IQqpCDrIzu0>^9KYNf4Xp~->K7e4 z^epV~_N<}$MM@R;S70O~#T>0c9=ck9F*4roG-n##0 zYO1Dcdb+yzUcJy;mc8Ry`6#vTUqn4&tL}}(_sMI%2k$?`)1TJN)=a2-iMJq z_dBUe^KEpMmqundhx(dO07Zj0MXgK<3;BX0Aouwz*#=rr;sr5%molS?Q@Iw0s~yNw z9_}?amqWCg=au$bQ!8eYsXiOiITkP6{wOCR?@#W7I2Sm5p#qZyNiO_##u+b&E>D*; zw6_ut*>2#yH)5pp$VCkGd}Yu4 zf-EpXMv_j>Q;?`8=TLNI=2sj|lJLx7a1_v>SO8hUCuFFqU4*Lo^&;grj#{(c<1Ye3 zNgB$3e(EES%XGRJY~_cOf-orsjCO;wa5flStd=7g%z@wucca-kC4r>D0fB$ZR6=pr z!SAtr&5)q(!=o?`y11B%_W*690)(t3$lyC?NFC+pN zC{ZpBrzqS@A@)3f*J9@6?tZSh{H{6qciek_PMVfx zX6$}ly7D%!u~)C8tvRp8-)!Pp=?($lXZxd*?AjLc90}>&2xP@C@0Q#05p#qS3I`B= zThkfD?7A5?yG()!S8+(Aq%jR01O-{sGO`*GO0z;SLz>G#|FLDgAg0MVC9VJV?-L~kGk?*`u_P+0gLco2dO zAKw7lmo2p|k`hBgtw2}wB?LLhyQc$nR<+}KMFM*urWR{q)krzd^b#^;*rX^27`Val zgD$i@6C)=jBSl*4_UNGgd4n_y%d*cuK6NwnC^dnt&zHK*s@~)_#D_wbp)~ z32vYLqY%cEgEs%UfyMQKPOA;VP(!8uWku%qqfXrJW3zI|R!K7WOEMK+nzM++(=a-; z%ID0J)qgoHX(J0a;FzAwgSR?-@)&-G+)pPxDKG_$;+;y|h5KY6WI>c6AQ$<@A-(?7 z<5luaLBy;RS>lUEWt}-xC5)Aa(XAhErJGtxwU9oY(a;l5u0432JJNwKh4~PTvx$r{ znFz$Fot`hC-E9zAug^iw2G_sSZ_#qQvd}gc#^3FfXq`g|br`6uHYEwc_%}?I6ITl; zvK?;fkxe=knZ+?BAYP~uJ_;>Bl?E_jlxm?I_b8JMc$&sl8-3PD(9xkq2vL1p8|(;V z41qB?IkSB!dpt}aZ#&0!fTusm4cC!ZAV<+M-ufPXJx5zQ> z&jV5Kehb|^EgczI6HSLe75Yo)P^Gk4NUAh$F2u|k-I`NP!X^ z4peV`D}kH=p6X#ItX)Hve$y-`6byA#Q;hquWQjP&C&fq*?aT`iOxvn~RoPZMjD|kS zw3vqkzCCCkQflUTFrUi7%MlEVk4SQJXy6khQ#XpZqlx@b37WXY(PH)ZQfPPiUTi$P zRO3z^Q-<^ETEz}5lQbj@>JIbuAYEdvw^>{tQi$o6t8!g+k2F=#oee$3uPJSmHQHA^ z&@T0&9&};wG=?<^X;H@c@N4N1t0$F!Gem%*_aOx*!DS`U=&R&(Qc5fW8FQeHUXLIe zIKVSd|MIK?%hcHTd7;r6Iu0jiKoEp!t~$$sZphw$23&O76nO?sOTDnuIYfER?rKiT z3Fr>)0ZpzIAT>dOn%O4)3>dEPwfP+g(jVn(;k;OXwcs2kAL=Kk7;-z$+bL63_6V)w(s~71 zP?7iWv7{&M;qhPJenI~4M0Gvjf8`rM{I4~!iN{ym?>+y|*zX(u?~&jCfAjw-$!wLk zB#?e^zM*n}t*;5P+7viz%c)ln+%`f;(c8PWLt_$1F|E~8n^SQdNWWgM%Dl{;0&TOe z!>Vcyp~n+TSuZm#d_P2&Kdsk})A>F9ABMn9q0Ruf zoGf`|Rd7Vrl3!1{Ps`h58dx6;hoZJ=j&@G@ci2;vPh{(_NE{nQ>N1cDVR^O3FH4O4 z8dp5Mf5m^>^)O$qciZqB<3h@r>b8mlv{LKbKwA!At<&ECX zihcs01X>BNFH44um`jd`2up!@2teSCEIdxdt6c9Pco_o9F$?m2B6N-1gYb1Odg%-T zL01-YH-W8SG`=-9VIZCuHc(+U_j8nnj3#w1VKmQktF{LaWkH8oko4t7&O7KPhC@|1es??E0#4xWo4( zZPvdD$(AC_rO(Cj;0;!^xP2&QCGQ=wDdk6l`-@0AXO~Cs!wKNF>7=^{<_@N~l zA*avIA#v(C%pKU}AbrtwKwwNBx@k4PUHDRsZuqoe_ZSL4VjtIYIs*E>v6#OH-;~`S z(QD&dx+KYwo$+{CX6bg)JmaXnf%uga1EF@gEPVY3L=I1{4)?W}zYY7&r4Jip&;5EC z`r52@*V27$E$eMze3if2@MxeHJH+m^x{kfpvpQUKS-TgZry=k8K=E80&zVn-hC1TQ_XJE4q~%}ydE&14FCSlLbKKmn zPHrD>KPFucRmrx((UdHtyhMn|G@&T~9P%_~)d6#_q=KhgONn2Uj z`}BYSv+z;z9CufkBYtDLr_%0aZu@Sz3U>WXipBgtHBmst<4oPB9*!3YmTG~3Em<(R zC*Gu@Lzo9{^V&nsZC~(WA%%K!mP4hdSMwdZY#-Bj3y|r1>4vX}0{ZOGiPX8_2(Zq8v?(zbwv}THpHcbRrX!+toD|iTT^W_pnf&gMV zwRA|*mgg9G>5Y;Kp_jCtfYw^x%o3JN+8at_HfnUZ$@zQ`$U%w)8Q05311NPdyhMly z-o$Wx;k0v0J^@zA3(fnpCUXhRz7c;MJ#_4ItmJ$Z3T|PIX*`$UiC6W!R<^df+nXT! z)yp6#FM9h_?2SAA^}c4-ygDuu@)c~K$NYuO>@K)Wh{upAT2(mL2DCx~z(Z5Ed%+GKVBdk|039LeP@&~7m@qLK!&Vd6-wqm$?-!CQ+-NJ|I-)c{u_@hf z4{f1#eUs|-gG2c3P--^B*rDmRsA@K^26fpfDvZc}Ppza@D@?luz*9Cm-0%?FVuAR0 zIugS61E>uqsMl|k*W67%%SgnYQtdIo)*7rd#-ZQZV*kSa#o&hZOIsVq6aB3U!< zZOIz*F2~|aRHE4!ROA_KAQE7q?l(k-f@pBy^1QK9rrQ^PB*ZK{E>L*kcD{LW{XA!7 z^*8-f!O(JWZteoW@d)LW7Uoi4-?Vp5!T_;R)u8RSNtk)*dQe=;J*rS#OO=sjnF*5x z4ksMOq(Wy9A#(MvH*k}2QsvaKXtRA~%_X)iGqX}Wjkk`z)%#ZPzv7bI&BwsWSS*QF zKkHiET7$RDunTRD2Loi?#)Ff&%%Nl+v3S?cI{V{y)@IWyST=qEnHcOAA-}GM{Yob+ zneSm*M_>Vyv*VY|Vu;9bAZmJQ%*<8s#+xQo;1GVJ9(QoJFuN9NxThTG$U{!ry`0-k z2E|AA;efC-7pV?Ny1gpkUmOvVj>nT+{)FL6vTdvWzApc!l~BqA{maLFrxi{su7i_a zQsL~I=L8us9ve>9MtCq|H?cpU=-JspT>P4Yw&SVOje?HVQ9+mn>8FIrNcl>b-}4l> zlDu;dv?0Ta^T#u%XxLB20RcJP0G*f+<73_SUsO+zPsUmFZ`|WJ zV#jxcNpPlrv*mb~_6L?hF@h7E#c{-nNH~%eh^A2wYkGuffE`m*-NJFtB!?^TyA-TS zPg9GD>*ZFw&Wau{mi^jzPz>-GJ_;Z!hcFOmMIq}pZ&>Y&M)wCCc$(?dKArbaC8Spheo<2D+U-P`cNt290sR? zj_RD0Zi9FN^L(D2T7r(f6^8-VjcpJP7Pnb;!Al4!VsYL2^m-~KDbWAYDYfBczCujH zPjQ_~rQKs7Ye3rV*%M7w9au%?w7qk?^F5EN?;u8#9?ajfTM1A9sH$mqfLnBDcLf62q>fH)gJU{um%f10S=Ah*5{tge(5 zBUviy)D zg@Mabl=U9-@f@Bq3Z0*R9))C*`6fnz!6gB-$mviqzC+>)M<(IsY^!H?5BV(xctv~Cn43b`AA1Kf6ceRca* z=*PaOh{5w-jo;OIK89I;AuuW&P7p?C(#|_nWm5mX*5hyjT7>_a88v1>W>mw^sVWo% z85L?RO~)R`wqwbC>y@)^mw%8FjRV0qZke83HM305&H5d}2p__%SS_~!1-OW>-<7&y z+bF#Obgv5kr`oanGg^w@uZ&|HY+Hs}N>|iVJGzgK`OVkeSvbHSA(wy7>hWz#Ty3igU~nnGJy>JroSQ6H7comDZDVFx-8^Y_*wQ)$!_-f zTblIJywtS7EYu$}Cf*P}ImA;z?}1<`$pou80{pr?2aLBU?(quo-%6P2akiMDw`xGV z-qe32`<(Z-`*5a=<@x)dPI|Sb2JMnt-JS2xsN~aYF3D+p{04Z+KcH_2wZa^5HT+%Z ziRS(zO2RXVI4a`&r6kev*bpju+H=*tR)LBP8lrD5WGo{RVfwOLxP8J_&PfJ4-SZ$< zYLr@SA8G*pWFXhc-M7ka=Lyb&9Ij+ve4n>I1d00Bt;Yv;y+7PArYzu8Ep{StT!zW? zDdn?14Q0B5rtDFE+Zl3_<^@n13D}s2L5-S$9B2lLPlBc!tkafpwIbaxp4@21!bQkW zb6ZZkb-l^y%Ej24ioYoQxTZ<_sa&YxRcAHjP-}33z1m30V$^5zKssU{{WA=P{`T1MAG+yI+Ktv!b-lsVVWNOcgTifv!O)yMUoR6sHrf;Ja$ zx2=1bH9*}pyl<;b8?5>;D{8f_iqqf_l}!y12myBe8EE{+Cg!9r=d(wimff=Uo9SuvPqa#oY#Tg)@?{ zSs0gy0hgsk)ot2#T19{b^&N}6dknGjTon9~3{b>lKoQrd4mbuRbmBo+-!;HpIGl6f zVt8c))0&$vA7{jeNV(cbEbq~Y^AT7`{(qtcf@%9ySv!f*F2iH7>pSd8Mc+la_~x6!P^b7@dA@-e;mJA$Mj2icLMN^ftzbmC znp%zS0*iD)@620Oy}|hTPd9}B2JHeAX{bf8P^e=;2!kHRiB1w)38EDmB+o2J|82Q( z6cWm&2n$8h^1rtG_csuhAx`c3ziX_Tb#dw!L$wBM>`XX^5jz_TPOXN2Pm55w|KDl( zpO?$lJBsjlPGWY=@M(j9KNq><`u2$+C+9l#G*u%lxt7g@gp-7uCg10?u^988w*-XL zn$03NXquVke+f&ux4F0aer+*67lSb$$2gJtG{8&bAX6PSHhIjDJ^d~DhQk$*!HE__S2qla%; zjqlNK7D&-M$Af^+3Gu*;H%l2HIE0(*3L$^-$S}FHvyR5MacUgU`!k}g=fOA4?JQY< z(`|qvLU2Wur-~0a+kaBpluvQ6buaf7;^6fCmxTW z&#N&aZigb74HUltFjnQW!#9h+FS;Q;;27xx1ZcdF=4n@%AU=}}Q;UvEkV2UX`oR=A zfJQ%9x&VH#Se5%#S12_Kw-KfK#1?Mo2LWbJvQtoqCY}? zH4qJ_C;KxrQuZIMscEc+`jLsJuSE@EqG3NtH++zYV#bgadgzmrS`ldFj=jicx94_t z&Aoc;>$Dq{py2yG)-bdt$lbiuQpP(VI3a5qV8k72$U>%7EF*>L_z0vbX9xwMj zx;*!B?rw6L<#LuzUj(P#t82Nu?q1yYxEV@IWJ3Kc>7&I4{}vV0^%kuY+6+=LP!a8K z6ws^}3R9`?++v;beFi(nF}kz|R#I{As3-E2f}A%?fD}yavTp$7<^Z~=3o3?RUKb$@ zt%w^c@`^RX?_(n-j0eF%!3roHDSk$XUh1QN82V)T8&$Rw#ZpZO0H37|9y_$QeCtmTt^11?^DncX(TkfNFXA=}nemAhXQ$@UX=YkgjvWlM!^Ps?_l~mV_fk zfW`OH@Z`h~&<{4WCBQ-RaeTScLGQ+Yo=zw?dw9JK!xfeZdRlv-6;m6 zUKqbokgXbh!FX;V^hq>U?)2H%;q6}>xQC2lmmjif8(gP6EE-RW#e&r7!7GUbiO;MQ z!ZPj}aH%#OpFs0#3fk8@#)kl}Jf>TFous-7=a%#07mGu+D84bwtO}TsDZNEsc2?`a z9ZQ#2Avn>?YNwJEL&HiOu8d1!MMgSmt|eL_=4B@9D;4mJv28ecpI;?}Tzyi!xT>bt zqFsjw&bzh1MEKZLWi*-#BNJL(Z*vlwp!iHvq#x4?R94*4Pg(X(g;PM}T1Jdl?WyHt3^f-?@8o|Hb} zj9}&~O3qY#tvx)aRO5lmr#Tsw2%gjlhk!;{%-TO}aTh|-oEy5B0_IW+sC>FVqCE{X zavVz3APnk{bsoPvoLtW8Jzgk0YijE1+S-V=>IK2)aV1z&W^@M+%FlxVQQqb=6}W`- z2=;^o#-jkJgs^j-oBPES^>|&p-e&16NOqJsgsM$^aJ3tQ4C0!=gsWT$8Pwk^2O*Vx zK@5X+;fZjiHi-5Rfp&{ZKPSOtgLb2JaUSFLXb&iY!}#dITn9v^{M2tWmGgutL`7AQ z;6W$iV7@fu&oe*{YK%!V)7weOg_rW?h~|hp2OyfLBaY%_{&-#Lhdhl32ri8h_$h3e zRUr;5QeoSmiRp$#ized}<+cO;3E8FFu82?3&b_-SmZhRo!zi)PqG97k>=*v^Jv;WT zU)L9RQ6J1Jzn%KuEVWOQ-#3Zs=xzPMb2gOC8um{aq6a!36p<)J%T~~@yK(}VzAWDz zdg_}~L?f$%5c;Yf-&l+kwv{K58$n~*Ps6k8*Os7ZF#U7W%m*=uJ@0l7VrIw7+wW=r zc8U6Ay}&bv`Z&1Bm-|VTvZM>)@@@2Ar~#{9ge^UI5<7J3J>Fl^OTIVrv`DCsqBNb{ z&}JS=6k`@1!L5;7EpkbG(UF4kOZ98fwA|~fASVR!`p5-}fz1R9wtj}GHCu$l;*PEm z>Hxoo&ta7Jmi+smMkvw)%g2>0GcQ-Fe>>e+PQ1!uy94n+U8Qs~r4A;TY8-DiuHYr9 z)Z0!_5X#G4X?7<9cX=tZZXzg8-9@ZO57_Odb~t%7?$qYn`_9YkZPm-fr~BbISSS3! z-7FO@i~A}Ymutfok1bW0QLVZ2?^Df&z2evrkoAf`R(7q4-*;&UPcCX&!+2?K2>kG7C0=F zkJ38szj!vG?S>>)I)g*<@k74#VoD+*)Nfo2j94sN)63CH>WiEO^=iLqzcgm3$CNo` zq4>#*Q!Kd*CU5ZJ0s>A#`6tqr!`sZ8p$5SBvF_|8>wQ1XN|WB#<<-3`R6AlJX-AZ@ zKPSxWQNDLZSsh@WtmFXb4Wrsvut(x;uLqa|`d0g6l{|bWZ#c1Ag6hUv0Dt`b4Whpx zvP2-Cj4QN-{~1Do!-M!>3Feu(K34Wl_=&u7k&@}sS{J8M6HN3*Z?}`}oz9P4rdZ1A zs1Ix0htO0dutO2c!f1^pAp&2$j1V}@DPD~3AsNE6JE#0c#L{I3HSB%*gH{*Fb1ZJD zA1xT)+xvB$!hJsigca|VT#@F@Be#1#OY|V|IXqt8@9x6=l62e)s*ego$PmH}N#np` zn0j;)L{km~rcAB{m1_{)is3WxM9l&%MkX|gUTc_=(^gsl=$o#k=t-|I?=xyJ^#!1H zdU&N>Mmqb1u5+N!&&>I z<61c-YRD|=!H`1l{xzEr1`cE;TwZWoH;dEXmPtcuGaCeXX-3(u!-SV?JZ(6rw)cue ztLU^F5-)cZp#Y0*gqzdMWQ{2%13Cri3CZcGbb0Q+Q@K62kbtK+n|1k|E4XR$L*fq;uq7Hh6}bleZZ%K8-RF?I7wS(@m_xHS(dE!=>5TBv2TD-F=v z0`)}+P<@eT&Jot+?LVoWc~6w<7}K?{gcdD@IyUPRRw;HrMFb^co^k7*>IiiXpxic! zGqqh(Y11R>iq&Sauic<){w{Oxx-gvQ*yila|S* z$PFVzvu)0(hw)c6g@F$dknuafd5j@JOq3VKCpb&=kX8QzIPtunM5;d0vk^+^hHQ8t z8`LNkuZN!@0o&3wIfdD7o#8q!mI9dT-Dwoz+={kQ!-?YOiUw{T z|8GE*@tGQJyv zB9b-dSgnx)^FGKIRvv1{5-R#C*tqvVW>vd8#w;bqzL?p{nV+zl7^X5aNKrg6s>dO7 zBOmFn-WG!~`)|y*&g=uN?WiwDB6#kyxSDgeF^@h};P%X+6X-E_cEBBK*b)yU} zMs`ZSj^kliBU;q&696Asy{1Gz`}y#Al2(#uNd#huTM9t;Yz zK3gojF1eaa!boOj!QYg?vDf)!c>{<%M@cvoSf>zp3{P9RK~YV zXAHZ$Tc|Oy-^EW9XJ}DbA+t1Q>#2FRg7UzS}c6_?kU6w@4idD4ZBIl)Fud~w@+G4bOr10HhTv4zt(W5!mv<+6GpESZ4dJQf5^Px)El z#bG-_X(Dlrq`k~1=s@i*7Z=P9M1c)~&^SRuJi7<)JNlluJJT!KffcF1<(UXopbRUT zjKa_&umgAEf4y$hqMB`S%1%>HIUX7|)x+mJZ1`)ovR;6pI7cm%V}H`|9h@4SzjDy4 z@ILeGCe+3$6914NHjV1pBfUd{eRuW`I;yH^cl@2Br$9+3R{Bt}mr2PeEmA5CAP1nz z@SnBe#6aQ&AZ4C1W;SZd7{8?iBUqdwzvcYw?xDuO1P4?m$8{qeejz#FT4NxVA$;JI z^QK8kg;T;+HRx`j$xZWq7$9MlhZv!AUB0o4qlvj|HtSX9pb5syPy?O%#0%#XF~za-fQ8d0cs^V_z_6|; zZeQ)+ltT}W*(Ln`3DVB*+x)$`O%3in!0UQnb|!=VLq_e_1zE$ueHGnl5<85>=Po?1 zUL8XRrL?#gdj`cI(hNf}w~`Eu1uClWJ9}kuz%$jMZ-sewd>BWo^0Fs2El*o9e1p>=S`4m{!T<(-v6_}6)6Qtn>haTebyWF_sDK>l zpV?JEwEM>(T?v&}llNOI5M4f9v-TuVJjeKj18Mf7q9v#v6VwYXjDapAj-S=vv}kcp zC>_{unpD3@z%IPuF{Kep&k8)Dy+b!6WWhK+DtXl~+b2Ntk!~Ga31hfZhVwzQ{I+D5 zfO}|5`O5&8E3P2)^?+4^Q?fv{jeu>qPH6-aFbjDM6*QZFuRUg?tC!8E!~&h)WEmy_ zX)XkuJhHgn*F7q|Qi+dsF3>jeWb;teVtungfQ`XG1tkX6)&?y>AeEhe0ut&6)$Ny* zME3Rw7jv{!a+E}r7}OY37*jxQ7SWT0C((wzlm!5WA}LX*Qi$rFlx;)Vf?^-0qWIEt z!jtm-4`5B!-LP8{K=Fy~GeRLMk;X||d{Cf30%?$t;874HO=XeA5#V5yQf^)JJIi%8 ze^ernm$fqI$vv6XoeSu7c@!F{DPLw|Rlxz^$8mNi-2FU#dGcbTs1g*{`0AA=L=ANYIolk?j5U3LJ+*T<_e z05GG_sdf%H%#i9sASACgv{$%%-jQXZvY|TKn3=YV0^HNB>xkJFR{|@HnegZRSlS_o z=vvh=jLl@|9kvlLI-9gl+>XsptKOsDe^i|@Sx7KAbev@+QYQm=R*f-;_a>{rUpU4L z@I@PIB{oxMidTBDr*=TB))m7JS4PKCd!H)!TQAb5yPg9nyMs>Aer93{@oM3;kk)0u z-)=DkM?cS$u;j{#ikgr?A}`nJurVQbFnukqs|(XV*Lo;5@JtO##Ps@_xcHtPE zB3U^U0oQCqH6>{7eZpUzc_Q`2`5fJt_e)-dw%EBp>O~7Jl9azn)lJF2?(8`uiuo>f z2&HiR;&k9`W#g)YFKhH&&T?pWn%+m<(G?nE0`|B^BLLt*Ugjx9XYbRmXlZdq%xv4x zOmlCoeig!4*g9G7!++96hH?k$z;TKT%RQ=lh4B#d$#qu2&Q0cb2CRMo01adnmOak2 zl(p7qT0n6?3$)WmDW53FKdI`J)FrvIj<4N+APE*==v{5te0i0rX+GT|bhjW!hi_cG z7TA|svMwv|%2Z=&l=^Y`U(8lirdseL&&jfOtznxoh7JhZASUwkHG20^sIG|{+)w)3 zVwG7Kze%>jwc`@6DXF7Q$QefG(T@v_7isr*6u&_~y)oNF*zu~gj14`E?qsKEtxVr3 z3h<{L8o%XxndD?N_Xj|dc%2fwKHS`S0X~;0@`1}iRP^_tO6EYzA!k-K1VM1`Stepl zu{|n3Ap(gJ6p6~M;~dCE9b2fy-zAfkbunY!m2u9P-JlEjL~J(HUdt=k^+O_2 zbhHu^CYY>)fnO3!klxjB%=%cp7`}-C9e#da4#D$7L14jVt-@dN4qf5BIW&^T5|Z(n zX05GB)YT$y{%Y?ZPAx26uZdS8+91)H%`Ez{Wya-}INh})R!*bNM5C-^OYg6A4;u|| z;xE}LjHi&>s&!8UlVJToEb5ZvpY>yX+nf)eiWp|lPmS(v%-_Fj#YO(gYu_Y)M(;7( zS!6$|LkJ3hU{9?AQf0)?S-m!SA9?T*_>spHYA1_Xk!&>i;EByq;eo%`>ANy*n*uV* zYR1akfBz34YHx(*nU@+A$mmppF@XXq`2^JB31K74@^2n5#nOgU zfZoloRRM&?d|SvcIC8WM$j!Bct>qLLD=Rf6BftsS)@+O%SYHZO8Ow(&L8uLjh>j;% z$0DOnZV#!p7*vI!0z{V9<13F=6w-SS##0xN2O@?ZLB4E`;PzG&FfpJW*n&n$xyaU# zcAi~u@@~e#KR)3gPmyx?4`L2{f{d^n|0i1h2R$qG+e};tG%FXtmI2Td)UzF+7}Q)7 z8Ej!Lrw*wv5>|v#f#$4&-cSxkTAmj;f|l&dQ8T2S7R4zAM8Q}vN)E%p7c;6)mz2aK zvnM5V1$FmJ4{+ffOq)m)Gs=9~#xl*Hz}HF;`JS~!v$=e#ZEAZ6YhMqvzz zaL*QQgP@Z8dB;h{r3?S{5d80>igRY{f*4@N?s!B|R1Zb)4Up#Qr`+gJs8qE`OM`u$ z8qN3iVsU{&sxRgKm9FW*9BvQJ5I8pH4#=+wMtp_ozXyEN!0GUj?uuocjRoZ!G_NW{ z>5%yO{%-^iyL?=SarJ~&HV;OBaHL1x4C%)5aF0QNN=g>lCXw@tJB=#T%hc{-3Ki$W z+IUqKd%hbcKg~WCoe0pu%^q^H%NPuZ8Y<{^=<)@zzQ~Y^25)|bw<^hBwG-VEU=znl zbGcLsP0J%kzLt+X_C9z#ukAQH<4kr#E~y2u>B|@oPfT}*RdcqnQnk9KNpb)Y=IZF> zxwFUMY$be}SKg*jB0l*%)*Qb`mBOdMZj!1TpFxq8XSYhdlktjXdhK&qyxi^fzUTE9 z=A(#=U$!R#bAgM8LheQx%xRk&$HD4a!DqA0fZ@G0P#O@|IyJ;eeO2@nt)AwR=h@CV zMZYqhkxt%Us_o_5ot_HAfFpfOCJ>XK%LU^5X606@F_?A=2#9^u zz~)9+>*k+#&GqsGh&Si;{Oe+tFzQZl3LKu|N5P`%x}g7sEk#jwJuohByP>I-1?KEr zQJTr(#y%_F6+p44H1iUjEn82=mF*|u?wV|@=P;0kFEbSJXWtp0kNBle^=rfp#2y|j74;w}?Oc9o4r(V4xc{{R4 z{x&BKTiN}t84$S9ApJ&tX^qp!6OK4RU>>@IhS){qw2VdwPagP#e=*Wa9xzs{qVC=U zo^V~h)F1pQLHA$9TKA{t39Jit^HeX@-UPH?bJjON{s z*z?}1)%?o_7FG56Y8}vwVOS*6-;@YJhN&g!5rsiIu$CIWl#I&3zYs<0ey_wA2Ptf?bRk`nvmtYB5Q%`3nh`GyPO#wi2E0{Ox@N`sH^zu@OTQagt2niJMt#r z>AMGu$2@vXF)NcHlxYR=BbB_T-Z`CBKRTgGJYJd>`=vSOqSHT*y4r9yW;h&%*@Dtd zP%jQ4{d3SjVZbVjFBaQF!qHus=kTXhD{r_8Vw&lEPb@w;8(tc%0>6mDDW8sV`a?pz zj`s3JaF^rMghj~%Jikb4oaOYUtF40*E#qcwxgK_i8{PZL zjpspZF!F~tEsYA}hul|*7g!%W2)$yYJoHYeo!_gX!RzFbiY5O*Njp2rJW)R--Gl1` zuHCb4c?1;ihKua~*Pu=7^1=r)Amn_~OQ53*9_81H;cA2{vN0OY&j`Sf{rH6VDr%kM z0=lBUQ@FFd-tTt(I?r@2v?EK7XQw#v;l)lo)pyb_3aVCQCK|{YpS#s(^gp~9dJPKX zzJNk=ru${BotebW zQzeLEB}M~j+Nv6lI$_5m+nM7k?J6WuZ#377(BWl5O^68k=$4AHq38r9E%bEj0}H_% zY*WLyW^Cr>s2$Q&-akvCDs5W!d1dwIIjPbCvCbQMDF>PsE`!=q-)58ME#YpC|j@Q`i1@9w!N*Z{ZBKE;=9{dU#O;8WoTPW z2#F=o1R_XWzrc6hcBg~G4e4kk)HRSB7=JX(ceZ}t;f;?Z_uc{{a%bH3cp>G|=i-IG ztE1oZ>K$A_T4~3VTaysGO`)c{SDwqB-nP~mfhPTN&^Or54fpM|x&M!(s4$)51M8D( zgzD;adL~^ieICX+9Al1pmFVH)aFZ9xItHblvfy`|H|~SqN#1Azm*@2Ha$etBXPy?F zfv^Fpli^{KUVp)Wf%GRkl$Z`mklesJ)P(O%4BS?eSz6KsLarZ|)#z?Isq~kChbld^ zZr+rS0$9h#`rA6tLlSF-Gu;J7F0-qtr82 z;H)?asvKj~N>yO-R-eTm_WnACz*l)R!uLKNp<{Peu#9-pJaW|<8q7w+T=VMPhNGvB zHH8Rsh?r(><;oiIcSqF{B23*yGz@Qws;IhgC9EY^Rw)|17pb?Z)WsTaYCDpOXywp} zFFZNEB^rUKXKCca;3kMu;Zp3Y!vceQMp#gty>MC+h)jEs!`oL)^b18sta#RgT@w^D27^ zYXac}Fp;Rt>3Mc9gY}@)GLQNO8G(_I1S(}OQ=D!>BZ)YTXMs|v#9nL`X&_B1<7)l* z@)#XyvvdBjJ7=x>Wjuxarho6FBeq%08ynQ`E0C}ME8T&1n2Z8V!}v)k{jc5*yJcj( zSvfmY+2Hu8{OdHp@2vdkZUJp!TH4yebnFzfGcvO>)nPggg){-rf#xT+Df5HDrIhl0 zngRJ@d--zZ6j1v?l2o;#<6Y?|>FHiT@2VGv?r4#|fI1tv7(sb+i0W|E1E>Hqiet?I z(H7mDXScl#pm8)h7iixeA5fEh3Q~c9Y2cgbyEz&fF;r}XO zz0W8?G$&XidH!X;FkOhStW^Q32O>H#QiEU%kkc(X>*r-QYlD75sfq*g3E|AZoON@> z*TUS*?W_lk@I8q}=M{Q>$T^Pk0CD7%BgW-EdZo+bHj_6z<*Ho}>z>%$qL^O4?@>_v z1~!2CPg0eqBQLO&pQ?Y?WV*Zzkb-b$>tA_)8-{IpfM)|8kPd2X8(Iuxib4?kh=~o} zeOo~qP^Bd22&`5TLpTFoN)6tq5>9k#QqJR>7Cm5$zZ*`};|D@E`wWu7<{+$#Df%5p zw!olQzkkdk&ycg45sLF{n1LXN20I=)0Tj$I`TSAVhm_lW=Y=3rE|vYnRP7na`( zb*Ltt1qD18-DJ1jXPAQxM6!Y*bkq0fiJ1iwAYN`7W;M+4g7ydJL^fJc#WH?no*h|; z?*YK*(};g~zkX{db405qJzsu3clA#h-CcgdU-F%kO%KLG&8uL1j}g@ShYv>u9%Q~7 zG6r~q4G8!c1>yzl<-zg`H1fSVwVH8k3XlAZp%Y~Wq2dfg*KvPLt+61Hl(EQ^a4yyt2`(aJoEt4N6rUY^P`M7jd#J}Xlmt;HgUGMhridVa zw3#oJEr2Xsznm(h5ii`aWti;l6VA?ldqiyNK;5;F{UAV!Q|alnk_pw2&=R7niCJe4 zli5s~60rjnp9DHvNik#A^o%)m&d9fQP2L(>agR%0uT>Y}S^y9d z6wlbn7SdU-9z?olbg3QA7p!I<{QO_neXYA^zbOFYJExDhU}4+RSkbK}V}z8&rixWq zeh3I@iauVuVI1uXQf- z#C*R92Cb^Xtv~p;kE$6}*M-oPMa)3}D`s^JL0i7M0I-Q{=C9An|pAmB`|Zw5gj&()33?as1^(WZ_RlAc0Ho zaF&4AQpHc9M(4XUCUoK?7CWfW+~UaDClibt)ZqnBXfSD6JJLRfwcVPny{OisfxnJU zzY(%h9=w^cfAZ|ThMGLQof8r{W~&~`rDnZYi;Hs$cqQv#XR~CWLefi*4;2*#JI!6@ zo0CgTBPy~X7(^;oR^gS>yWA2ss(o~Y^9gjgsocEUhfl0jr_GW**EJR9M+| zvlH5$Y;3diBHr@5s=f|=z>-(Wi(^l1dgh}Hy&X*POAj@_fTSdH^#%NvJolT*&39N) zCrH`U{fUQOlH{9*|)xH{YN&VR2z{Bi2S`R4{e{mXB40^b13uF?APs`_&DYO5+MMs?*|N;3;f_|y`A&4Wi!I)Z7@aXLa`-ivq(<2Ok{L>4C=gWC760}ZuuiM z)1$7#<$P_HbL{aryE2z79Q6G%0R(&_@+G|q=?DsWPOJLNE*;@pgWuIE>*Tie4E&c$zigO+!ix8WXhjfvJdC?6fE>633vT65Lmkx&-dPD9CzhwDsdf;BkKqeN zi7bc!d({xdK|u<~_eS=a$558|5&@#@$G;Hs5;CXFHDMY}#MNgi(PB-Gc-mY=<916f z&5l^Jxwr=SsfkvRRJdAMSk2_HavX1+pgk39r01a6s*guArh%oxR?dJa#^<#15ZsIc zy$gXPK_K(IA?J0hc^zy100030|Lh%IZ`?NWeSd{cUYxIPxo!_Qpg^!a7>?U(uWbq^ zZC(OwWQnWQSxf39tz|dKf4`aGw^my3y1tx&%R}N7MUKef%y5RB;e3)cpJdIUvZnX) z{rkv}yH$e-M?+EwzPS_&l_DFy3)7tPN@d;#iDadUnmC}xH$>yHyND;KSC_wD%+15MXFtBYm>(Y<8&tb0 zSQylr9CX%Xr50Z0gnQqZ6G$uXBKiUP=NZkE%zTIB+Z#q877wS#0DC>U?7dT#n4gjD z{AdzN&VQW!cCk3ec<5iwU;Olon+H{9XF@-2&4pi0%|=l3G3Vp_=#S3EHiW??YBypu zj#IP)E7}azs0d$xx%nW&JAg7a!S1b^V$vTjHv-nsa>3)N4n4Xeifc!seD!-lm_}%6AKRHul!s&Rl6`^ zj3}wm=UCQY8>pdA#q9K$4n6$nALX<5Q^(9_m}@hX(|er!-wUI6@Nd?C>p8&GD#A>C zyJ=x%%%BidHKF2sI@svh5Q?X^)kNi0Ih>rgp>7fOa20Ru{FNf8 zO;U?UY}Qwtq$B3yfPZb$h_7ZVeHiqoNTmZhU6@3L@$4k_o{mANp8xagy9-lv9G`+r zZ0Z!H2f|dx?N!aI*$U`(S=_F&de*KhUwZjU`pL;j^leg<$^mIJ*59#j08ND2yW_1C z?}2H?d*}M*=hgN4sqUL})rhMIP3s%K_1G8o8}b?!Js%nr9X42}32$*io~Eo*nQ`yo z1E{$$HTUEKzsWQ0c4cc>&pePu?}hx#&lwhNVFcZeRdQ<&0xrP808|8IfB_BG_~qqg z&?}z{wLI+CKvy}!p+iZpO8=n#ppu~0Q1 zq~A^S#k}UQ1e6T(6SWMl_?`Lv!H#MY{V$V{r&Tp@z3w(%d`oBGtulAa&9h^d&MNmO z4;=y4)ON+;3&3`FwibZlDj_x84%V7Sw{h&#wPMJms&E!wUtC_kxLoMNve?b(fs5Hb zguDdni8J!Jtyv4@^RK^r7)uO6+KWS|;X*ZBV8g}NUw%x68AQR8=bs_0jk42VH^ce%|nKI!l>jGD9Y-Q8f0O1Hl4+;45MfkhEZnlHTW)7D%DE zSC1MVdyVM>^iT5_TC9_n-Tn2tS0bb+p?RH@y%!BnH+9k8nPR*afsp~K3k)uG)<=ep zQRZFK6>Yj=CcQ;i%E4waMH@lEf%fSdFfLeCC;2*Y(15+n%hF%=K#{nq&z= zNy>_$p1v-A*Vl6C3YCO~2!JLvZjtIj(EHhPBglV>rRZs-UpQG~OW-Z@2S^2gwcL)N z1JK-v5?gI+pgnP6iXHh{O3U+_=YRvIm&F$}J(?g>n+B4bs$a_EHa;eV#!rcCTliLPWN;uUXp1FE=5YDQK%p95;`MoTvj6 zzE_`=94PY^4Aju0+i2Q>2Gy*JC2EU$v=%7Abn#(vglksp;s;M+>WITkY{R*t;Pxg{ z=64~UdQTyoxDP~cRfGd{gHt{4Xv?c>EE+*0glecx%-=eV)YC1e9bKG=#|ibKS-qV+ zqKSsE4>!lAUElP2hr_^t=BXRbGZps|le&y?FYl(R5}99bwEYzvfBaW$Fc{-gw6_#; zJba;j72A{9t+ztPk7ZF2aHtCg)BMfU`-r{<{y||W1a3PB#TKj68Tv9(LD~Cqc!id# zaxJdDOiOXkeFST0uw)fVJ^=GQl3Qsj(B}Ub`DYTJIHtu<#*# z%x#X{*m?5%9Xs(jy795Q)sxu)+1btATOs#0-MJ@nPwPXN`(6rr{N2lCRwTKQ4Jbqn zYgV#j=9JzQ8{_HG`cH+M$2z!^k9RfN#lhq4 z4&vQ$>Orp6p+ktrBBxAm&0L4uyOQXqbK%oXt41l{?(DtYPu zrbB&K5O#o`aKJwPvMpoMx26y&jt0fmFi9s!n{KClAxk@0Kh>6Vvbl=b6T{_ z_$X)>k!r`TzW7#ocX4sESW0;uf%R747ETlW1?^$zAYhHRpQ$U30qxq&FT?m<6bwfZ z-qeX}V{7JK#|1|x)bzxBgWwx5NrPK?=tZ%@8FQN`7U#s?H*`*J?t`Q%^3ROHlM4#PhLCg99fi@6 zc0$=GM7PIqZWDsg=WerGH6Y}w51<+Grbl$p6fZBM1>niP9)+*hYRLMfw3R#^jz{`U`u5fdh4;M-G>i{ThQ<2OJ%-ZtjG2O}DDm09 zXL2lXjL~@6dePnsE;uT4F7D`#JeYy9g9J@p?viv}R6nMqkImntG7Cw#`vBgTgGdn? zad?R6Kpv#&}8jWa+*>iY}>TJ1wH(k6} zLtd*x35q4u1;xxy5n_SWy*Yu-mg~$|Ity#hdH|V4G+sb1H;;!YZY6jn?B+)f>RTHe z6M8KyRri7?bU;Cg7u6##jH z1NAj@|hLjUW=c< zpDSn`Hbe-#d>uO58xIlUf^1v>pQ)c(Q2?&qLF?rqvU+eckpxi;MiK{|IS66Zs&jF< zxVi<~>bgL7>G=D(dAi4Ya6t|>fSkMqW|zQu(ApRP009600^crW1wOIB-^nW&e5Dk8 zm=q`tw%iJQSRk;@$;>N-9Nb~3rw{~bMS|*h_+|!3sizVOO2x1v<={uC=s^#80=JKC zfmMBsN@$Fpz8(Mo0RR8oT~Tk-Fc5yvuc%C=zIBXORHSVwV^sNtUA#7#SR(P3ICr)`JGsw}edm+c=5kt$Pu#_qujX<>!rO4w!c~Yy3wTF) zsn1xaSJTmQx4{`Ap-Hbknql%M`+ebZI{DaOD4cJbH?z~}>C0LYv#>G8+!)cC1~-K9 zAyw?4(~RX^Ta9e^vRk+5oSdiROto%)Gf}-6Klsx2h{ZHO5C=`gw97;KYGN{gVnW^l zu3GrgIjtnga+X~B2g2=*qC5otH{Z3UH1F{iBsIL=q&RuLH8gNG9v+xHemJ{M=j1N8 zS3W{x_y{%kO8g3N`+v<#S#MTQsBoij!}1-5KX$9O(`5DY7oAXG=Lr-;nbt;ccLmDh zd}n+2yRggOLALNmY@Id`I0B2(1~6G~?k_IlNVrG`L`<=FWS5yWC8;*AP`+4Xacokk z13IDF1HNi$*_*-YzGNxv(=d6kul^0PH7z~Z{dRN@Lj~ne>%*a(9V|2`)zY0o4 zo9ry$R?*pg-Uy0f&^p?a=`c9|k9wjca3d-o>US%wP%U0^g)&fqq7q$Kv9Vk%y1MGK zpcvowfk_JUq>yf->erR*BA0lupGanq&SFLX!ye;pQG-0%ce1?#)waFJFwJDqyti1V zigJ?VzqczK9}dE@R4-Qfa+PZ{G>b!w$aO&3)E*3|bL!G`a`|DfLiP!Oc@BNC21wd~ zBfJ5_5C=R1a{!|bIL;j)$OGE52ZZzil0SeG2*el!q7(vcI0ObH5qK^ZfhLVWOCEt3 zkw8Z#fd-X8luIB&CUBfha$^#r7RNs5U|x)P?*?@K;p{w{>&yJTP8W|%9)wH>L|n7~ z>4U5B`RdB_#Jl|ZF{W?Ibs_tP_P{`w>Dx9qt=N-c{sjO4|Nrb=>u=gH5dWUP!Xr!> z-JoNtG>IwFc!_R z)DE-5^X>NpKk}hp#u`zu8xCxf72czf2&Jq*lnZ^9UVze%TsC#wYvB>=$P?sf3jwNv zXoSWok`h4AL4e+GvMcB4>xTJCl%3OVzi*hL=LT*xP1xAT{Uc@pqjqUD2SZ0_Q2f<> zl|~UdmMJ6&;iQmFWw%!jEvqQJPOrFe4LfOb(J--HaM}AV7;*JSg{W^JAOj7 zrl@W>glS^c;3Qs(FACGjT9Z|eae-P|uuL$|Pb*BLfRhmc>&$nJ&ZyaM!&vP4Cz+*A zs3KvKdI#Se5ig6un(i)~Q}z2Ujj*ut-?%?hA8&BHtZcTAqNPyNz{T09-)|2(c7v=o z-y^qrQv0BSzYwVFBF0>W9EL4k`CdYkI)vY>yZYNw`EzM4Ga6D09wTTdfIiGP^d3&* z>B6lE(P6JLIVE8p5_$=_^I9eAnkH;kqfRa>K^<)2%(|D-MQe|T-B7GBcO;}m^B*vuV#jmw zI{vF}v4L^0savf10{{U3|GXX9cH6e{Ir<8O;VC7@B1I+by|pfrs7*KN8> zhWld`dv5e3YOg!%-zEWBCf&pA`7v7-d4W?0`dEYwY>S08xMA%raByM|)~9!&?Q)8U zttuu%<1q2#hHJ027`o@I`3qwav8Lt6(z;@Zdx1gck&?O2TiN2)Ry{&tP87}HCG$0m+ zt*^qMQ*ac!6*O?{B$nVawCXEScnwO>NG5QbYMFM)K4Ut#!9*{}>rBy7r8mk3#2=?< zbK4&*;Mn_hHCu8*9yaQw7#awCjocU74bK)CdkrI3Fc#xej@&`*RiQa#%*y+JDBxNs z3GL;(X6qMqgV=hUR)=gd&<2t01UHe>;(W>C%}pmbT2-4f9QZkaq_0>HlTS|O%Ud?J z4J#B=64-X{i6&5}{bq#eYd%uS%5;IpdTTcOq^(#n#R={{Hv?^0iRQVv)rU#m8*)BN zzs3ubj^g+2cJyIGRgnHBw-^Z`fpS_^8+7qsk3Y%~3o9;YO#|r;nu0vQ@P2TXelU{16UiFUHqAe^^;9t7E$maXaW7j+Y`F#M*{4o$c*GrABD z;VDlOds>Jy4y_;YGx1+^$`#8=<=FEq<@Ul-#5)^i0I zj%R+?r90)2jzvm9UwUX*gYYl`p=SxMnAbR^47_RN8kA>XhV+bBXk}W&m(q`|&g4)Q zZDZHpi{8wC{V+k7Fs3?_jYwxiGrD8Qh2ZXzDi4JAxq<@@b%G=;v$gdSq&GuBh-nQ0 zNdS=N12eSNoq<$e%?J5T@9D+M*5E^Ney6;+-!@O~-y%w%?B8>%44CdKUy#mfXNoxY zqlg>OCc@J1#HwVP7VA+!ih-KXcOM(%Cc|>nbdFU{b+qX#7S1?(qZOG*xFilSgPm7r z=_g#@Y5zKfq9Mg#!_$T5&W-CtOPo@ls&oPaG5U*AG)@PwQx6xj8<=Ml!2umw^OAy) zZz^qvXfWleUkG_%1h^eY^rXG{sT}I0@y>Z%%3) z7^``*7lz^5xkiE;EHL7eBG}0QM+#e6@u@#!J_}G};*nTxIwDv5KTwt#K89Y?@e_CMO&8)|qXnv! zf|66tIs&QMm+^uo=@N~2gg!vg2YhX`E767@U{dRL>500~Ko{+D6tyc4 zl;9-8_0XnH(;6Q3(wg`{q2p8ZJIu7(a2r~VzHs=QEJ7bh{(glYclZ|let~u1g?;&_ zuobw&M?td)Ai}7ju7VD3I89p1eR8rO_nA3t9orvMOnw3q!AUwDBIC?nUt^HcF;Yp8 zc6)Gm3_p(k{4}0SXY;E?wp?A`e7^lF5YX1{+1c*NX%aMl+}_!Jv-i{f&%d+|4v&t1 zJvlu)fBWv@xBnYZ!RkAW_zoTc?T?0|CA43Q>n~n@``v&3`@Kd&4rv-i%R#}FN~PWH zpN=lK6Gfkg@_Cl92B4#rho41d4}YcVlw9mAfZ%hx7j!sQ*hX)oqLBnof=1)XGx^Dm zztbT;WJtTJr-w5vNzilYN&v`6uRxl*Mu}RJ?giCpVDf6`j!M2SAK~EhKz}9IE2E3< z>&viW%+j(kU_oS8l|@#BflHH5sKUrE*;FqAd6@?0m4$Ep&JCdBDMsP9AoVS+54w-6 zHgIrBK=lI2Ym5<4x-7CRSjn)wnW^Dy3B#Oi2@uGTM^klh`Wvv8-5Koo9d4T=FN_ue zokVyszk*NQLaAS`sGXnpj*r#49z zFrF5ab})6@Y{iPUcGlyK;O?>zP~y9x%l z;mq!i*Y?cp%(vf~A>f*gPLOVvajg$aoSGAX1l_6vl@`9FtjKTj%l=A~hh^BQ-KlJL zD`Wj2-buvQB$S6S~@jqb;^@rT|}H9CqlSvcbWZeo}uRik3G(;8x6d- z-vC`WN)1a4b@05W7rIMtFVsc%?G%2Q*VjHDTRi8@h4>3QeqDed&Up3SS&?HF;NUQk z-MN=ru_KZ1#6KHoho6Iw3gVot28_5AzG(m!z^&Mg4S>&=2Rv;3=jUaXS-4ECsMW$Q z8jODV7=DJkW?O{+`F(idFgMyjj6D$O@=;%9s)c3E6xLdYi)x@bTi9+^8M3J=w9Mi+ zlZ_H%x-}_RrBe9v^|KaHgxZ~$b-_qn8|TVe0333}Mrfk#&j>6a<~0BQ8U- z*mu0Q`vsW^p=3&fZ2?X|f79voy4!rs_D+f-+oOpt3hGmX(NTK_k&ve$6Jk$gYfE>o zT0|)^UVwsW*E}|>d5hFSjG}0e(P17Fg)!1{Q3-$?K>vr%s8>8~_@O^0nIEzySANi% z6kT%t&8JLAX31TuUaN_v3z6z{%Rrm`q-}@BjBsA!V|bIE0tr2VG{X8BRb-pn07a(r zzeB*IEq!W4luh{EQx*LjfT z`iZG9El&LEnpUY}{y$F4)-%wpRFUJr!X!HFQCTnu?!)EhxFU8l4YrFX`Q*)kIa^@f zMRyXAhvKK}zQITeqT1u5A4oa%>u1Mv(tC* z%1a4-$;njbmlr`VbjeBRa^img00960%w1bg+b|S<_pgXTwG7lY<#8RIKnyg*RnW1A z7EvgrjaHiUf;y!B`1w2M*p5@$33yo_>QndRB#wQ2{rveVr(vQnpN@BvV*ju zWkbxr#k9G1C8Fg-E_jNV>C;y zR)A8~Pgt*`9JbCcnn&knHyDn#;0%!9GL=DDDA#4j6~nOzZHU-1^TW{Mg4VuaUP<=^7h_gH@4=_N;Si1!* zni--wyt$OHm5g;}6~_{%KXQDZR805as52=b6besJPvN%~pzRF7Yy)q#Rc{`gUYzVT z4{lydM=om_OzgcRsx@K7+U3&vam#FnZL9sIn@;Phl=q;bjyR3el8B-nxsKDKpG6(x zJ5J5SD0Rur6rl)o$==aIh50ad`=jS-I_ZC_s$4TNz+pQX74eLda45?(xsxRyr&DZVp!FoH)^!3i+-(0z|yNjb}hi~T-;#YQP7L^5r zGdjIi4*tvxZn_Y8Oq_ZZlt?a?g#kklEruQ4{)t{>5LIs zWln+G5oc!)lcxlU&w3LgO6E>zS3g)8SS@pm2IfDhb#$il@8m?sh!m;Q^DLW`V4T#AGO$z%AQrj5GdDH!g!ZU9$UV_26P1EKD$ zY&C?N4I6NI7}oKiq?lkZTx2rNW>pX4DXOF>lx0qtx(p4T@Dy-b;g+TCf?-;D%w23w z$PfeE&B(C}3fU(mY9sg|eN(ekD{g@qOIz_Ta*cqKooFQ^NXUUrKyC|0ouAFMkqaw3 z(Mm>;kOO>Q2b)WXj(i0Yeq}U(+>9H(g-Aw_kOO=_h*jP}Vjq>-odpXLa$p}qa=_=c zoY(}BU2EX*n&|A57loCavm5lKJrPPd2 z-jP;L)TT`5qxl^s-I?VImfjvJO7muxPx`%ky4Nj5`fMnI>w)f|Zbz!AJ5gGyiIs>p z8PFD;WW+~0q30ReXVEv}S4<^qu&P*7H`p)KV_ZOeL$csYMv#yL!s=;>`;in^6s=?g z2|36+wCtZEC!zX;8Z=uIQu3}h_ZI*F|Nop_O-sW-5WVMD zgd|W9V!U`N1(l{+s9IVJITT~5K?~B9Xr&(f@6MauWH%p*(}S4Z*?F0yn=m^&^P`FGN@RL*~xI- z-%uK^hLKdihayHl){`O|mqG2VTUm(}YeEkUSF-i!;H>Ai9UraUZQ(W#b?}yt3w&-5 zZ`|q@y6)0U-(tVzv~#SIj+)Tqo z!c|vz12V^~&JrtEzSsuGGiHVFRkCWnN0J-OKb14f`{vn)Jk=K5Da>P=GKnu-(RvRE z6+!vi7}f5if!W*YD=j0gW@tw@`LJ_x-vVse!(Y3c^Ov_0Ceg))qf%0-0QOnDr=ByM zOhANS>+3E72)H8`w^JKLcL_kaZn|1YSx_~B7_i7bH{FP(L;$HjG_P3tZN!@32tXtc zuDbwPAOPHL)+w!%G8?PxliLLvf>aZ&c35YN1>lI8rd;Q0W13zeR1-vMN!~Uim)L;% z&gb^^Slv>v7L3@Myu%dHMa|=(jX+I-GDg|jXbaS@XL0Rag0?_CZtBNEfKd}*Bn0>Y z00960@<9nZA5wzO&lg#%pD!u4`o*Kv10X(0#brf&a&AgIuqB6DR>FlzFbsa=7qU@^ zbHGR_h$>RiOo51yU_?#{bWuB!Auuu0j0p}f^7BD61}sLJF#rGn0RR8AT}^M}HW0n< zujpZc-isi2SIGumIBDQ`4+Rz=97`L!t4M}qubY2g4k_83;ZX9B>cx^~MsH||AHzqA zd|LeR@=RciOaRjqutSOZQLf)yBu6X<)33Q@z(6bj%Zq)vdu^2o;dK~!*w&~r;Pe7` zU^UeH`c1cKI$C|LG!Fi2$P3 zO~f8{yRz-Mmm4^J1pKiYbAT;`F4oOvyZcqJ;I2*pn`JIgmPu~)GDjxO8vUkxE=Vtv zw5j-CJc#~=uAer)RQmz@p2BAu`t<#^F4cawFGxKWw41=)p;jB%A^aMbz3oJ96%6gG zb)Lfr<+c9NP5(ziV42JFrVSBka_*NDv)6yjK#Nnjj6_o3S;oYv??51l@$`Kt#M4K? z?T@pEd8S~c9|z+sl)Wk#w^n_LR8_6I^lDyFo}rd%o}Kx-Q|Z1>ySZY{0mddG|p)-5JpBRjzal*&@eKChcb2q zoJ~y-)lo}$lsZ3_eo`H=94wGfUn|M;P%_`Dqr!ZnBbGc-`0QRCt8Q^rFZSW|l9sj} z!1k090(jlzn>sHb5{7Rm*rFdan!*uz{6lsL?#@e14f#47#W=EqYAn1}#e=GTJ){Bj zvrUYf_g!^t)q;iZbTP2)RzFx+WXh}p!GR--7#DWeITAkmS^@N~+7`|3pc+V)i;5JY zSgiV~fX(TMKOB`|ornkgSGCQ?kbX3&R41y)U`apK#T2&Vj2j2eKpxR_H!_i+rxt<3 zC!~FgK!A}-lp}(mL?s!gYzp)8>Hl}-QdSryS9+B<)(9Za>#CVG>vYRfH_9f?g%4Ya zJCZDyLsU{wW;orIOCE>4LmfUa=jX~LLk`D^s~H`!sIL~NXk+Ww%YEI>@cR9BN#o%? zGg)WVka9HVx^fvDd=p`azLo>Xe;Y$CGY&h(!^~6-6GSR`WYZ#6X7N=uW{sCMFmfr1F0K{O3snw zWxdDa=SUF?sLbl4Ayj3TEKPt8PeAgGgggO!!2z)yr3HGqB#$sq5ipB8^^kqVGc-Vw zFw#f?IeiRML||RHZ0wIBb)pGJI;e+h?9)a(Mm<`S#F39tFP%;L2*{|Xi&^?e2;(ed zmPkZXPa&I032Ex|x;rKyrai|4cIgB)^)_IZN>m5yB5E`RVLeozdWKUG*P~9UacsdD zDiCq74g(xQCnj-(HU%fDBw{;&9iMK8$@a<#RwWYM-Xjm#q!8ZJ2Wv11A59z$8csxj zU++`=zJeV0m``Mwz+H#jT+|Z~<6~Z2y99zf=*H0}6XiiCo>dZI9(02&Vu^E#?kN)p zbT4#c^a(^dh3E9Cgt}j228_~(^*}I2P2vf5-+`x&C))iylmhM&>lB&lqKS7u?@(<# zPZKV%XSD$Q(_#fPVn4&-cevVED|-I=$SVE69+%k0}?Wp?#|t&9q@fE{dwWY$Y- z?KUOd9wjgLcfWl%U$f}LeRurQ9T%W`dW5ql^`Z~`w*>aod=H>coeBN=ikmyH#dzks z7R;9B$Ie67r)E02KH5p)`XtNXr&srX&$7OV`O|b;iU7y1N%HRO^h>lNSTL|Xj)wI zF`?PtoZRN9t2zej?#MHx`dBRP)}7jHh$VS@!(l;POes%$`&1KK@>b)g8nrtdjA$_G$AptWTCe>soA)Viw7a)kID3B#h$>XJ~!m7N9eu8Nyo`@6r z0ehQD7W`}W_J(=U_+6QN-rVnfMz;O6PTnw&OlUyM|9#f6v`&qx?m50r2^FU(kZT-& z6e-)JV#x`)=7I~8<>ps5-T2aoZ>E~BZpN+hce08Ol##yijP0==Q?G$CY|Z(T-FtRU z*|cWi?)2pU{pl?8JfP{Or`L3@V1D?op6|EuU32l}TkLnR8jmDqUwJBhOrlV3wup>5W!UBPL83-t<}oFlOU$8RbN( z;#&ggL6t&!LF8SjDo%>8tO)z&7nCLRTJnlnx+NH7%PY>lc-K1}TpS}CNK0Syt&cs( z``F_|O5~bei~d4KHHgXOO}IoMbm|VGCdQVfczPAV)N*`&j$FNGm&XG!iddWSR%+44 zE9MPcEZ3_@a%6qz6S3I7xcqQ(d~vFiCzrk6Z#s3>Q&(?}FOJXqX9J%kFmK`sjND3M z5mzgp4b39)N_71LzhE%;`mYE5^V5sdPevU*4@qo_bW@3kRJL-fh80yLDCq;me3O^$ zrD~P_N;)U-cN@Gqw;~MF@wSz-Of7)% z{dk`40^>MXV1I^R!d3mxd)6#Iq89v`0!!g%DyM#qeNKp1PS?>g6*_WZ>BwFo^XFJt^LI|eF zwEoY~%ieY|i#Q+egls#Quf}a*EK>_$`xtYr9hjYBtY@V-1pLTX(W$ zssVOtP(@QrK2J#$8Ye83qSi&k66&sTye3S(EZf`^2LOG1S+WuyaiQLB=(FO|Es@Cw?%=aY#xpu69P)kjh7{3HV z%cB|)UP;-k`6U3g2CTu*i^dYGK5ox&Ee>1l&`?4sxGiyf!0Ahr#5m!?C}Z&Ac0#Hi z&>B&|*pPxc${644kz-lInB)etD9mB3!fA++g{pxhod8#0!#h}%%$~4%0)`wht)daL zwv)Y~c+pucmL%burzjb`fP5}>nWdvSL@~zP&uKcNHpCF>YMZ-G=J?@=h_0t3Q1e8* zPggQxb)`d*FGAAxPA0I2hT8F#n!;6g&}|GR_-KtHF`h?Z5={{wRLZ-a=!zdi_l4*lG#&~y!caWRkqS53 z!&*AggE=&8enYoo_-wrh^O<=5@+DSaF~iWKiuxp-ct!tg+2kSX59`wiZjus>)QxOB z2(!n0DaF`EDyx%z53=2|Q3Z{C_Zkn6Xtq^9BoG?D^)_xu!TR-*l|e|`AgAuIXOw8n zVk{VdyiteoS6U9}yO0F`QXUi@Bon}INb2buIx6B4_{|M(W)gfDat{S1*@rvU zJf*bKm<>8RV!_xe0Wp;!hjQ?|d*BVB@O~o3_fvR6_Qfd7Z|Hf1juHV?1CKt2LrbC{ zi$1TRNIa34CgThnfTtw4k(ecTP<4$>OtHa|clVatj@1yi=^EZO@SwpMtnNj~N;Ckm zOkqCSN0BQ4!aCr4AfzhA`GPev)u~<4?B*R!swCxnXRC5^vx8RP1wj_D78{XDhqp88 z5Y%=M-s{t|ckkiZV{+hT7-XZSc<{t4ljOIE;J*O?0RR8AT}^M}HV{1))vur#HL`41 zgwq}hHwtoC^i&i9QWOhVietxGTUf_7B<*g4)c?KnW=MT(>MYi6FHS^>!{Lw|z8MO7 zP0M~;8WUH~{bz3UuxJrjx0?)-qT&B;-;hqQD;Hj0t5u+`cv>4|dB+hwjpb5jZR*cG zV~$sj^cK(J(fXUqT9#e&(PqvWBZb`N2#E&fyyu_e{xaL-k0xkWvy$+s=T<8;U6|Un zyWDt)vEn#G)=esP*O+T-2Daq;V+yW{Y|p%aK22CxB@Vvp&3b1b*^_+J2H&8qWGTz{ z(U1K)%F;+V*V5_C>D`fGwLOaOIWxTlML;yD&6@b;ts$@X*;qBbe0%RTyoY`x4G~~ObSWB7>QkG^(V1S?iuCIL)T}A&DJ?XQ3}o9}yVlSrkcUYHoqWC= zE-w>gDY2HDm0>L(cx$gTcjk7gnf|6nb6lsf@%G*dH>P*JbkH-#n~?1{9(szc{f2MS zn`BEB4^-vF;QzyzznD2-;Q8vABeUa`3Dis<#k+6+ea2qoHdME>yqpmdpHfjuD-aYm zzkm-=f1^F>2Rgpnj?9jBpFC8v8AKdW3_I?;479EO&V8Jfl-ewwGQs3VfD^;&qD6jqWHa-Z%a;bp>e8NMr&lvc9=-m z<}BgeeM@LCqA9k>mf*ylBd$TezhCYiI9G>VrPGm-BrMq5<<*CZ*-<(FvCj&}$%`iW z>|dh3DBsH5-7P;nWKFTxj^=r1&XK^d1kT(}%`TVynU}RT(lh28&gLbOK4XbPMpEcVMwu0WZ^DL*N;| zrS*ho{3|O0|MI0#f)?L-OQ6qWWUbfG6isiZHhS(SB=gh`(~V?Rs>VG@dS zWC}uaLv_al>veLW6Yq_?`WpZM|NpdI-EZPX5PychVrx*0UGOS7sSidxR7umTgnHFQ zl`3IAa>P(xfWsh>#{BP{uU)T=LlRYul;Es)XUDVa+4=3vGAjAx>FsO8Tmnv$8*BnR z{-0cNbP_>FMSBz`@6XK-s##3)I~u>;8o3CE3%IrjHI!>YRd@11kH`8LtkObjEqo z4zzM`LBhbmg#(YfC4d1%U;wRh_#bS3HGqy=p0UcI6Y2>_;Qbpm%Rv!bOUWlJVY~Re zi5TTfxvOr1YHOl*vW(%KF5bTZ&N{$E3tO<-8BjUUAq$(1UYx^%6?A-*e+?gj>Zxn< zkXG14)Pj#zp~2X)g8>7c&@Gi6K#2n(UcOQk4o5qgJki98$HU@vh1)-*19c}C)MT9= z_f>JV)K|dZ*i(zeMz#hzRw$53*_43mbdIU0ch6m#LE^{n3K8+5P#6;^_bH_un?8K` z^Xu&|U2!-75nxw>-^rxKUDOp636TvuK~(mfk^7GKOl=Ok!bkCx&T&r`)@r7PS#T}9 zD<;4Ia}~msSAaa(;nX3BN@Qp1i|kY9Rs$p7QlQRX1?X!PeRsz|egu~b3 z(f#M)?U=HOQZg>N+b6ZSS|8HF>Fcz|s^@gZVH^fjKOTmlMB`g5sCPSKOLjQJRgIe& z366V#us`U4g2-B39cRz-j%BUrC7 z)?JxgvkiXmf&c?mErhPFjKE6e(h#SJ>8s8c2bv3=#V}GNN)sKisF|vzOu7}$i(I{n zYMS1~r3}6OzDu&2h}D@!COz*$GV`*T&ng>?XFmgYwW8FLV3w~bMi<6(X7#pj^nVeG zk--#*(x{8Hd=pg6!-&Z?15nQCW{Z0-##ILEAZXr3t~WiIMW?t3LMS-E zbfssl>nr}$Kd~xViO_#f5BnV`*?&@wx`9Pz{`VsuJ0e_$K{YfRXbeznbkK?H4B7&) z2ce4DTzNul(dtMp>MKrKWPzPW*jz&gCi}lfe#F zypL~%={BgLUM1-s5Gm)=w(Ay9ihD7!9)pH;_F-7V(oQD+yuO<$Ui)H59Q|;XXuFg* z9+Aar$3lS%3fAcLlrs@QL6O8Tzx`iMIcB*>)HRyuF(5BZ7x)|MuSba|93ocR+~0^1DA{`_N|i#qHO=Ob-h6m~MG=Y01TEQIn4q+3Gm^ zqCjTAG&?Nt%XG=A*=%hy^fC{kQmOggU7SdCY^qE_SJoKGb!2p765%2`&U1Q%mik$F zQRFdX02{U(ZPG50j%1Il%HDa0(!l9gk0#h{nCmFYm!O!na8SID6|($tdS38Bk&t4j zy<69dE?&of0RRC1|AKF=0ssI2|Nq1s+ins;^nJf#-ENkI2sC{#5waE%ts%C=)CY~y zz{0Lbq-=#&LQDVMIk&ki3$4V&C+2cy=IoivxdX{mqoo6iV{cZe^cCCP@Ai(6o?z@+ zC5sf(Vbr5NnkprB-Si4*xOg$Ld{{#9MF1_-Vev7%F4;~qKAy1oJL{vH=0>ZOZT%S>QDbp%Lihg(D!4#041$}s?i1~ZR zswK26#pEgKxMTMdsbL{$pCAj$9aunRmojk%xBCdMsihTSn;y~aDP{KjoJO#G>~55r zlYwFlE!4F8%D&!#H!9V|hqv9!!N)k{g2smHd$6IE8??5br)+JR%dCBPBAAX+hOoL> zf{EYkWx#l_WCZz%X>yw^@?3HK#Yb7O!i+X^>wDJO z5?GW*w7RJZo=_Atp=_{(8Y79!?b#Ca=gwuX+k4+EqN_NNgqlz0Ip;CfY8JL&2>_9L zm&pBZWK4Fa7Yl|v5MWDPaBTe2YR1aewW|9&g@df>7o`k|BE3k8wG zEso7wbwR%+wfj!(>)=WX$F$XjmO1?{H23Aa?BO-p^Rr*_O{^zEpO^+#Kv z{Pq^WxmAO6GynooS$7$>N8P6GEM|k4x-&}=%x%-4?iWhUnaKsQTecS52DMu?II~59 z;)?EMzD1o}q0X@67JGr%fK&VV#naRej3OwHFZ^j31OuS8%Z<2sgLPnJ`(tnRX{(;+ zIJS$}h9&PjNA5nrdCu>Q2fflLybX%!FwP1r7`80KI1S}Qf%3`7b8F3q^=38RG3|Zn zw1+YiFk5G?!4qg8pwIaEi|$kb!*u%ezI!b~yof zHaGe|r~x}u6s71#+gxJHvWOnaf^1kZ`vkUGdob=3OQq7T4=ChM`~d&}|NkmO){Kxt zbl)gQ^pG~Dl?O(98#3nt6(wev5H^p6h&O#L%&{|I0~j%^1lkz`K9vDAUn4I9QpYR@ zpbHM6BUOk)1t=S=f(?hJWTv4+0J<%9I2IL>H0Fs&A;rMdmz*7I zT6&3|exSneB!ut>k{4sRI4KA-@W?CN2{ey=;-gs?-K{{E0+ToNfDVNJ)r%psA5hdnf(>d9 zsE&g&tq^0$;B{5-^Mc^Q=nhE$kCdvQ2`gwT7$zv7?OugM5qM7@NF{jC24*oZX<-h^ z!sXBgW#QsP56YtHz&0q0MG0Obh#8bccmMzZ0RR8oT}@AeKoGtAD~LTb8o|Vahu)0# zRug0D*$|4cNd;19QsSR?=gof102|V)SJ+*4*yZhX-puR249ebP9nN|kni~ybp zbQe%jRZ~ofqGU>)L$*c8xLsyT0e>qA14tV&2eM#eiM$#xuJl~!JtD5R-<4IjH$T2I zMNP%$BnmK(s+j_1K}riMlrK2|ySfOysYKZEP|liqmcE+r^~jDzFnz`_iGHEcir+VA zTuRT0Aoj#rVOMT@?BP$@SYzA&(9|t$o+l*cn5Zj7-Sm<#labqaWX?RmFHCqPL{Q&O z-5&+XR3Ak%9jYX4*|0E(I`IZLVapaOz1Qa27fq5j(JsE(6u%A$RMdSpeRM;N4lnyD zKi^!iSIcu*oD^&7Map6ub*2lv4#DINy~r_IzK6l_yB=AgAi$onFLt{@HWPOxI@`Dy;Ve0oQ}W(m_mx62I-v)8xLaKd`=E% z4tbxn`B#aQF9<8}AJDK4gBctHu`1lI>`1Mb?pV#d%$u$WLmKNLW(#;h_}xG-(r_Y`FTZnRp=Rw56HXay0 z8zMt7d<4Ef3M>$Ly-*g38^zl!nLl=Jis}}m!71i#KLb|Z%Svy+^<0~0DLe~}3J(c` zk#f=W2C#q6l3S&i!uNlUNoQ>i2KXOXXKC$lG*-sR_ZZG7O$Sjj#-zWDI{WW6^z@n` z){LD}Dhwb%Pfs_tp6ez6mV(T-tZWzUeT}#p=(iahTn3mVD7ZzmwXw0`zq8KLkhedr z#J`L}FBONR7yr_J-=?`i7Y)bs{y}X>z5(-IR@9vEPlxy9NEH3B2w7IHlOC&gmo@wm znUUlCyPn}!^hW3JSoNjZRlHsYA2Xg2IRtA?nD?9g({?1n=A{8LE5Zm0$gx8>Mzr?~ z!b4&j!scfzugAI;m27GH%GW<>kqCb4uy*}ZSC5Xrw03DFN~x7635Hi88k9dwIjC4q zozHrYwjwOoQ5Kenuhb&fh`N0I^vf)3M;8q4^SBG}i=5fM?Wb9?U7pF2%0;EeizPkn z!HW+(LB7E9ZAfN)p}Z)ZS0AIBl5Z+|>oX3FE#n;-k=CkC?i2Hv6v2)nyL?37q1{ai zOBq=F?N}rj=k%y%GpX-5`Iy*h!lUNGRlyqpmI+%11r6T`j+Er%uEBv8#Ht-TE{uuD z8PeulNX^z3`2Z#tq`Lm86~5_~e>K>~u1iF3ly?wNE_(-)=~x|jM}T7M$BOU>TX>HV z72)n*;Kl{ZK5v(9tt*P_lRH4s(%pp7UgmKY1s`8U| z@`*P8`V1hhqvP}4m!d4dE{$-IfgQo%uvtI&(&7qIdS1NrvihXJxiqkD8!HX?N_RyU z&Um=JDthAPixJ2e~+y<~6eM=X_Q<7IOhVStejMK6nWe2UNz!Vo<8qk4KM0vn` zd9rElR6EeuRWXT97FUyTU%KljGXOLZx(Q|ZbqV~wYznqb>xgbd?0}&6RJu@PLPxO; z(PUL#pA0)QKJWygt`S^|d`o@s4iVnW2|M}PPgvcZ&n+J|-lK2?%uFyR<$~&!lifp{ z^(gC2F)rIbjHL#NoUVd}30uKyXp=T1E+-n4#Qh`#Y!7SS4}oLn#4}hMBp~Uyn3D_) zjIX3uxKY(Efby9JE(+y3of|eDp!#jU2=U=!g2{kx_iq3E&*O{psB`oI2cf5(qw^2j zp0y@71|A79YYdAAqM2t9CGiFicTc;2N{i0x{e%7U516dI{qv*Uv$JUL_%!N7C!N#t z{qDs<=QKLGI6XN&+a=m$ViWPe5~EcDEecaKj#>>s_A(e4A-O!lYtfPj42RabC#yPYAAi3^~(E{gff z_4V7^+julv#A!BKpJ<=?`e;6huZ!sf%Umd=S2$hPjRSub>g?%*dq~*`UfOS)QmHrl zG67T#tlcuUz41_0va$o#K`AELowC)#+rxw)~n`75~E#aSmNy6Cx?aQsFudZSS? z@H|@)l-)M`<-NojhD|AC@QEApcV3*C~V5TJ3caRV2ZBA)bQU|PbZ-O(W%9UX?t$mOtrSc3Ncj7Nrzw1;ehAAZ5AaxcUAI-V}3 z1{9@VWRw4~Wxpcd&!ybNmh=|^e;^N6U+`#kmS$7FkY?I^5;w3Hz7{KRifdC^vY)ye4Ry4b5*#X}n8d@G+Ps(uhA%T?%1fxG z$z&(hBFAGaXO*n#&MB*PPJK2_yVeV1BTP%Bs8(}qCjVJt-c98j_!SI4_vaVJCSjNp zZmxm8ZUnJq>?8^OS(`77_v>yfNuyS&U%jP|)Qw#JzgRP+qCvNdo4E9MBP@|TE)%G- zo}Zg@Sf;4it9cM0u~Vx24#ucQ24a{)S?|^+Q}MsLW)f`N&qeB1`qE^jRV1f-W56+s z!&~YCU18G8?2A^P+4R8*kCz+PEOn&{mTV@I6Z1R+2WWrWx4b%S{-sL@H7PKwX48mIm zau#b=S>3G8;v!#CTEpsv1RwNUf-qqW%v|QOm4V8I?Q{T$;4rUbi2h_b$liOEjPQum zPsqQ7a~*cx?sqS{ha!XcpJcv^ywHP6;k;&ICqGOTNe`QptNK-tpq67RFFEg+LY}40 z#`6WEd5i-MqBo)y?kVKD<8;~+?HB#%_$+!K`;@mN?k+;o>R%Y?dO!i=A^di)5Ywc& zCQsn!k}(eDZ8*u6heSH&JJgVQR|O6E0ZNm>U>))F$z-U4n64nmH@*J#+HrI>p6UCk z&^cCRLogN1L^@px;NF%S&3)Sax2rBKC;O|rK{!g6 z*B7VPdE%hb%E&OL`vn7Y+x|8KenaMw3KdHdCX8!h06cM9$h>v^l#(3_gZo{rZ`!>fiGTltQyh!zCV_2eP7;1X9m zt?;U5g@~4esZqcY_xvIbE@n&^igb~!;G%}YotF8v+$h^tE}7W`Z_~;m%}ojegXUJC z#Y!}UH3TRH%b3;J)2pC^RGuvpWh=k55r*B}yJ;YO(_Ueg0FvgnMqf)@NgSj@l#;!!m@sO=Q?DUvKDxtzVOVLD&dNL%tP1gJj6KM2!P?}g zbGTcR&)SXkPI0-DF`404)#|pLTRP$!it6l`a7f|9bIj^Y}{#xx{_?r8o zX4@>+82uReQyr}6Fzbzo7@|QWmPZ-BODhVNb)DYM;xK7>*d3kAsv5Yrmuj-?%GNa{ zGO#Q8oZ7fywx#=JHgC`Y*2qEBAQSG@DnE;trYqKkwd5xHIbFc1=e*E zm#Z&;>%HAX7#PA!`)C5rWOCc zyj@Fg+b|5i=T`*TwaI?LFm&i)1#;?uodyV5;s8cmE3o1vKJ>qjFHujY8!+r>NtURG zDe@ytB1U76M>Y~+VBE2%SjjNw-Wn+lSPSwc*h{6uWQ`&i=e%>`tas7@#TFiuy;)ql zde>Lt4Udwl2}2kqdOXM2@K$2aClsndpm?6_v!17PJ>Yu%h3xDw!QDX^HuNw2mDfLf@jyc_EET2tuPJ*(|7iVo@-3JY`Mgz1+-DZByMj zrU#^>uDPMS!wkf2d^&d7QQEw~WalcYLukP86c&_w750@?3(@P~V53)SNJF0tJX04h zck*%X?O9yX=)=N&#SBIn1)FewaQ~d)1_|p(YT|g@74|i!EXDi_n?Rq}I(JKIljz?8 z7Ac3NTOL#)@7`RMn~Gry)$MMJdz`!&tKi@X_x2Cmec31~zdNb|-mIThL|*?>jCB970-sw4%9Umb)MY8iAmglS;sXtR_rv4%1}U znWyKMkI)+RTFjBb*Hd%5yk*O!>x*tj=(SC&E2{O_k@9dT2M~Ze!s}`pLg}2zE+=B`NyNk_e2jl{ZPYL3sp3S#@OZLo4>7 zSQg`lE7nJA<`;^B@@#SDbYkXK2iFGOrT$>AUfX_jW*ZSBCG$jl`?`Jpg28Ug_s5q{ zNX$Q=BZIH%V|NSa@1OmrQ$$%=0092mVjWzYyCY)1Qv*%}A}`SrEdK z7S_%|29LA6?qj~=rF-2?&Wp&>2DF4)aSe$lv^^g~<#Bob4FCZD|KwfkZyHAs|IS}= zJ%a*>hal}2OIDRS*h)nRvR#QtR$Yw2oQye_M+0*1f6xAAc6Mjsuw*6bhxUtw_x5HV zGqW={I}dGV-)pByi#|X#Xr?Z|!L5sHwC;mXeAgciMUIW4_Ss>Aw!I+;!MsMYXl=w; zVZ9^+U^{Jra_18ATe}Z4y0e6og=!p$RBX_qO;Lw$ShnaZo1ki-ncI@uKr<&BkOr&^$~H;&0dKz2Eb;v%cg$gx2~{ zaR})!*}Sb*l#Z<=9lyL5BeZ!JQHQujsjbG;=|=}>ANgj@#9aIn`-gL?_<4$SeK#t(w@UwF zy%yxU1yR@HLp-M#yc$`Q-u3%n+(09Nb1&6TrYcb26K+SZ-lrb2o?UeM-FK&*kDcC? zIe_#8%M~h0$!mUYWiAmn@`CD~Hw+X(EUi+rniZehS?qJbLVGVtUfM48vL(b&t5)KX?3HFE%4*Ss~WJmtov)M7lUD%Gt z(JRoo6B}|6xw)v_dHDdM!%iH#xERCE%%VCj=AbO5*JLw}-HM!CljR%)A41;|xDjmXZ)>K=ghGLYgih0tcO2^2bBT_xtfiB5lAauHZop+Q1Z{ zzJ~WkRNo-EpD$S)2(UQDj*D z?!ic>UmER3>t}B(G2~Kw9+ZloGc)qSnvn5%W|%MHb$^CR&LGmIT!Z)udsONa*5La& zU&yCsBkuTX-u2>K4-G+}o1S10h<@Q=Zu=3?p2e?zuM`vYWr|kPCn%tXDAwwTHbzTqGPHD+nWzvx%gDw!u)qxj5@*qP&@3dLRK zypZL}pbZ`WMyED#>gl3xvoNV=dg;^>Orn~Zc_?^B1BDd~f1&-3>WI&3G%PvtQw@=tDpsRPMeo;mZawYsiE(xDp?6OFK^OWf1f5yC+jRS6G*mkf-qORE|NXR&T7-~2 z1(heMzMFyD^x&RkgSxPno{9qS^5*mDwSgU?=@u(Z)ev<)ApA-NPqA+J7f5h z7;jiV%;Uo2mXa47d62iAq4!@8(c z9YRhIRZ?+44IgS(h%jpmK?j5=>1m-Kt_J`B0RR7jEaXStE|!2?eL{wHAo&!$B04oE z2X;3cIRgh!t!0VO>%2juX%L|>N1sqvSk(s-0F7dy4o!zS2EoD>q6g|{$juTehT66< zDn_8*0hY>tu(%QEL={7*GjWchDJUQgBPV`nNJpiB;=!TZGE_;VQ#ByR#lW@aBTmUF zz^Vc1*ln03C>D}4a`RIZv@75Wxo{r$kq?g-%pKGrj_%NLT`L85XD^ah*Tq9MQGbOU z%w&>Q*}*iCxY7>E7qne%2eXKJEAHUIM5|SIIKzf2EAL>Y(|YwC%pQ8Iz{73Vz^=l> z8I#mqiHFk~I;_S+4|;m6$bT2{?0lhns0v~kB8_hi|g5;`n-mm6WQm#q|Slvvp+^BLim;C#Su|{Q!=MN zF4E5ie_FI(p__*w{&oh7r$+tR790)v=Pe?f0R3k?_y|CMwa6g>O@ZEZRx=x8sp8JC z^{ySg9A}MS#ij>(svl-Qw;+96PgnH65MnYhrGyfi|%3sM2~0@4&!5OU6#6ddIMP9n%9_$v)Eh$RuN+L&Px=PRZ*p|L?y z8ewG=4|Qpaq^&m{LCZWf!#E$x8K;{!>UU#-m3~8}m~A(WSs`6Ka~r=Dx%QHH&Bw

A8lbgR=VWE^%d& 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¯trwXuY*E3Ecv>TQt+Y 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�*o(f% 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

22a?nA2?y^geGf?ghni7`Vj#2EX{roVD*l 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%0DFOG9)Timv4`1Y9YRzyES>9Vx9)Xorkhfe@JQeXT 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

$ohZhfo?s6t-MdqN2XlE{^1$_DWa-G4fPMyo7*s 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

+JMiGJsJERWY^d8K? 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 z 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ⅆi^D;idA7+da1XID zR|i}1prM_7m`D)WD{N>(lzy0mgN}0f$k#Yp2dL$PTAlEncxbNhOUvOO-r2CSHyl3n z7Ld#K!r`DjU;Y_OAHiOcPnPBPxYKv?KIGZ4q9w$&g$@_7K%watGz-Gp$)hUoF^tz5 zW#C5=m5CU&Oj@b=JF2Vme4kUjZDzcIz4CBG*L7`|zveo*EemEhJ*S#3Ptc4;DGjr< ztQbH-P}Z`En1Ui}`i!lR>}OAYq@||WMtVSBc|q@CX=m%8Ob7`SBq26{i){^(_@K(i zSYyam#ix>@{m!xHAz2&)b5g|T1gf#f52xQvD3kbdqg5NVw2W5KSz^k1W|Ocm*uJru zs#_N;2PG*(Uo)`W&&e!^D$_NmVzZ@9EsvdnCg>@pmUqTsEvturB1YC-JHkiEH`o`~ zhbZ0@gtEKe{8P#2u7JKXUQB9A&uigJf&-cc!prfsY)@b zCH;wzk1AaXl&^K1hMjySU=Rep+m%?cbCq}zzU+b@@N7ch5eMhsxcb-;OR^ZM?Yp6L zEm_AHJK!ed!Re_eLxc-5moZWbdiR;OGy^zr{dO7z%7b_TjHk{ja~hq&Uj?%?7@3C; zhr#G^Fs<_V;yllmW_p#(la(W5{#8j zEzvC4+lZ$=D-$p4*%AD1e3AzgYJy-TfCsS^l||P9r@|m=0n`$pN`MCDURL7y%7c!^ zCwGpW%ar<6RP@h&w!zZ(ijvP~q%`5~*jFP~<*mbfkFq*Z&n7~j+%X6!N`MA)I7h`2 z7v2n87lx}?X)qVED@=Z!p4B)9NFN-3L>N1Q+>t(K-i0=xRemEMMa?9$f`M#RA#1u ziv$CuDrDOrxOT1jUK2}3B)|u0+fDV;<$TT{1#gB&-z-7MGE&KM$v9QLWr%=`8}MYV zHw-y8F#HenPEA}opC407{7w!H0)s}ugZ`V7543}TXs0b%?N8Lvqmf}Sn{oDc7wV|} zfgMO4sR3K!lKTCl=K&as+Q#-xV=?JbW~Rt zFw-8}zI-x0qoWKC7^Td5T%Je8Ku7T8 zb#+-+tf6$astH3ra;nYiS94))yG3Nz{UMz9L>*`L(8j1Q~Zh$ci33YBmb%&dXKKM;3sKI84;5u5t>$qOby*A!~Nj&&HI*VUn(1eMSnz ze?FyU9c5-(f%chOZv7c8=~S*4sL_h+jI>tRr!+3qfKs6u){tBnD27dt2uYifaQnY^ z4Mk*GB~fV&LCqsNAPE-Gxaif?(a>8Y(LH)yf35C|kpf3d;TtOLW_WoB<(=reyR4)4 zb<$W-Eh{k&wh^JE=7D}KqHp~YZ+8alwo>5wlRKopS2yyaZb#KSr#`l)iDzgO`QWbhC zQ54sqD`v-vRg|^1A!v$7?f#~Qnq+w%)y9-6JPZ?NJSYo;_zv=b^QJB_^i9*<&b>@S zb{j+_*7(8V!br`rt7PN}ksmm(H0n@xCUcNqxS__g1jDini6#hiDEeAmKIW*Z#gTA3 z%qS5+8=+Y^nP~9@r6rtb2IyRr0s4*n{#R(|68!wXprYn9vNPC_wqqW0b-Y>SEkufi zg75IgPb6gSQ3_SmDa6tTcgkF?SAN$Dv4Z?=Kti|Z3}g8^d3fUaT-(XPg)rs z4!D+qL)8r)c%-W*f7)+lm~U~iSi%iRJQHmsEgHUYBmUlh73HXKk(J}9k>h8ZBOr7~ zmp~>;aB15|S4ck*9cB8SMu^~~p+XYY$Jr#>r*pj4MI!!-FRqBkX*`7CA;m=~0t52v z*vD5STRX2wFmaB500030|IA%mZyQAvexF~lfK;`WT|xVRXi+7U7KjLG)ifZU!rHrb zENrjqU8nWG=bZ1HGdnZhwVk9?@PgE==XU0DuHQ$`G$RVkfL6u|6IY#~?A+>PB0q{-o4T$A@S_jsE-NXejbh(bErwAp)&@ zHYM(8T1XUSE=pW}bqx;~FJdv9Ot_{U!(r#Q0?ritxJfV+uBf2=K!*P$b;yTHT0<~2 z{8FBWqRQ|I?J|!Pc@zl?Hjv&1P)eiSI=zyD4Cny1+5sc*&-lnEtyAt0IMzlm3Am$<$2-X zbplLUzF`k0@2Xmhh-V9qV+1i592tx+ceK%4N6ZEPTe{#9o8dvV(NDh>v7ORZWyG!Cambt^MR>8Lh9r&^b}npO-#I9BvO$(tFq zm>*8xv5N02*5S-qZ3p9WIcF3V91U4OI+wI0TdlZ$Sm)b;s$<`M3)C1=EI;zw@?kU6 z#{nrGv;{bZD%Oty#8-OF0cl0m$v(7n3mpskC7o>GFryldeo?TcJqZ==wvZl=B%OC> z4>^y7U4c2*g|`=Kt+xPLX$#fE=j$Ws$e4~wRima$A5w^n-tZ5#1rAE+6bh*aD2j2z z7hVW7!#cZ^&BD<+-H`o(wav5;oI}Gk13}O%FX3!RI!2*w&^t1!e0jW(!=qWXHSG1+ z$ssrq07LN2lL&r>x549+T{QHr=sqN{LeY5)K7@5L962f~v*9-+Q zq4K3z%?hn(Jz%{ge6y_B@M8iPfvF2{-`V4E=>F!5W!ZGcNoeb>OXaFJOWws(mY*l{ zJ=HeZW23hUR`lS)|QUm{baot$FJUbg$ zN4yYpR-0>NREd_Vh(>59OEXShNqz=wRsk}}7|5i7x=#lRV5rc&So{iXa$`JKzT}*v zno)JcO*Jb5et;7iH1*J8qo1<6h}v=8Zdz_@nJY0yttOZ8kSa17>KPq-xfuk*1J^1o z{uVDy(Dy9LNilW?*)$=zJ#QFcyJ>3MWJs#>P^#B}%Blyriw3MbS-i^0#zM$fki;|s ztXPxpe;dAfb3#|;h_1~kFau;o>36JcGKvN$LnMGxegfj8>T(KN8dsIAR%~=J+3j*# zo>gMqp1=O{f{7_u!5(OAJYVr3Nmxy62K@NdaF{*5^MBcJ__DW+Eabkj*g3}^^JN35r71ZjFaMIR)*>0U9rwULjshD znbD`?z$#dX81+!R@1 zKwRGmS(?(=_fyz+!j|6G6?;t3(Zq5u2CYM)y3LKVkC$M-G5gf>#Kr(X9Vqsk?7_+* z^KSrhf-wW-^a?@;dsOK5P&F$=nt2!ifC9POF6>8=nReYW)oN&Hv8fwFFE$(*dq%_0 z0cOotm)ak7tMJ&pL2BC!8n=W!=39x>OTs&DQBlZ)RtJ(I#wYywzVx7PY=jTy&5MvR z{=u|)5og`-qDJF3wJnS@lv{(^hoMAsomP@6lQS^@!g0^jM45=Gz9=MDk-k&_u{y@W zFOe|~h!#z5T(VxQL z%L==*WdiU*5q(+l%&)@)YloXQ+#{`_C7cio4&$`Qo8g=-d9FnV*OE&A$zu&NAwS0J znm{wRER&0!kMV%SyILby7w_Mlp8xXp-Rrkk(Z{mM>g{4w&1(U?G8{Im+`HNxl=%K@ zuFWgd`vd6LIbN?|t(LHLMx|5a_DDKumQTQOZyP4q7c3?ZKjqm0-~mnv0eB+kYUDa= z)#JzWegUW#DBs(n6ftY-WDg-V-ft7ta@P6B%(ttsh~b3#c7Xp)pZx8ENJy?*{I(c- zgl}J7p8s|7=GE(~XjAPIz5eiOmG+Sc-W?Kr)+zYRnao89ee(8LW}#$5#36BIgg8C5A#gBrtT|CoCTOF@id!?+y!zyNX*oMnJQ$?Y>j#ZY7-LR5tTszkm`t zI6Zl>3^WSn=pmNi32IpQ|18V|eRCwy5DuCMp9xlDSEl*8odM`qLVAiZJ=JuSc@b8d z=AfW?5`A)}6^JiQPe~Gq`F;9Xr{W>6mk2e4zC&RAcm%e+Z zeUe8nz4tM#%Taf6`d!aO{4QRS5_X3Q)9sVI%7y_ z55%E_(AcoLhmCf~9=@xmY1gX%QnudHEVVNe7)MkL(Xu0KCNY0S50;{j<+gR*SpN7v zX(UT{ubQ^w{R?+@0sdc%@@HAH+e}WUc&)1mXVr0C=h`y%g47>i+_otb-n%8#3QP)A zl%+6y3Bdnk)<~*L=zY^@h=e6Zvn5&50DomBIdQv&Rk>0p&n`-&85!%tzXBDAz&1uo zX)1Kq6I4BML1#Kr6;djJ$s{uwH1V1ZKKe!>KPLrw`x<0&5m*j^+z#3|kPlnU2k$8W z00030|J)thZreuoonJ9)1RE(3vra6ht(ye!+DaqTO$^J~eaIRLEm4V3n-oMUsay2l zcg}4tCz8V;ZM5k`8CN;ErM=pUlL-;%psB<~UWRZFm>&ebC=Ga3N7 zeyLi|KPU5--Xr=2+9B|38^=_F4pzY&A8@e|nge843?+2LxwFtNe{_9x5^tl=j3hs~Tg#}> zSY4o98Qty)k1nv487a}8{*3+23G=WgdzN-0K=k_h$Wpx>gMald z2K~2hTs0?A#bQb|-??0wd-^nvmh|U;uD{H)kK!xEWXq%H|KM*8pJ8bA(a#rIjFo$h z{fyropI%fQV1>kOnwG8^zlsK!)1g6fTd)fwbTmi0*04ce^aZ1Za0CTg5GeXe`dpCy z6j_(W1S7{KS)Mb25>s5Q(YmK#!>zw9qe0cGzp!@O9KHG@a#{*wkfNS#Z`o|Ewwhp$ z>Cu0(y(rKvnXS$g3l33arl}{gQ%KZG$Hu#>Cu#raPLuvNEn83A@BVZRl#Rj10m*w0 zNxs^^zpeaUt+4$y(z~mIipkP2G06Uc0|p$8o!div@IyE%j1$IyC*a%$DY$k$#wozk zAIR$Skk#>sjN5l?U=PI`n_M&q$U04rL3`CVsGV0#TxL?VQ zpdV~-r)iu~f!fsi5cuHU4Vl%T6w|>WM}!UXE5R}$l6(%wlyit43KA3G<7#IGcYIuc{J}#G$jK}qtg#H4) ztR|&FRy-iEU2sa`^tvJ^7IJ6db_iBdNX9%gmngU?ncpp} zthJbH6dxZ)BNdOd?9LyL)Q1{4N_O|5lAdkJh7U^1 z8XVZOg_NcTK}1$3s*<$#gv?jPX&FSECR(4q3#^d&Td2mQ2_ZGn&y>NF z-(F)E41LNr@C1PezxIvgKbn1#%k>T@2*;aul5Zt5jyBk6BS#DExIw|JDunmYE$?ds z?QETwu!(i*uhBveRaLWIqJaA6A9ur*H%~;Fkzr3f-E{6`ifW8COZ!IZMC$7J;l(l< z&CroC>X6l4QnO8ZDJ!sO*fIRyiBij^vsqe3ww2W9luX;2vvb13Ql{dh>w1g@4*nK& zzDO!$0IM-23%N`$HgY$hH?^JxSFFFnIwfrMdR0~~MU+~cga-j^65?)EZ4S<$o~Ksq zfCp#(k>YX7ykTqHK9qw~Q1&IGd7jgQbk_f8|I`>UrZuY$CQz~f z;H-NM{ig&dZBF<6h*kV*PhE^U%1p@>zl~jsD<^dr;K=$L+N5}d0AY71-?a2K#d(YM7Fsz_OIdZm;U;C^VaYMEDfGd=$zr9deB<=l( zwZkH7`3Vfu(^SSOb$0sd?D(g_i@gVb@W($@eD=WBgmSDonpVtU`K(9xWi;Q+%oCHT zeA1_R^165Ovp&<~)80jkScr3eW`HKT7QTRGmL~7e-`fLH`bpY`{$E1{yk_sp9ATEX zohR*=kq7D0<5m8-X>d<_uljF#En*TK^`xWTpE7^R)e}RAVDfMZUp~I#6(O(IneCT> z#=ql>H?8+fe?WXl*H;w~c`%+9V&-&GFN6hTD-ZGm7rnu|v&$B5tnI6FY@l)T#)vym zfmHO2Sh8oAx1)z~9R#$8M19Z)0e;QCF(G11bu7RW(xz)ea-Dy6DiP{KyQO@IVhVW) zCR*_So@^_4b^bHI+2Jp5Pv4#O1_r-aM}^4D7iu3muykDPzp{U2`Bi&0A5c|BV4n7f zay4H1sH~j5dlPLyE?kG#E+DA?6-l5$zh9x0?;tIB9h353qjW!0EAALebZ`i$h`Ue2 zHSa6u*9{jf9jDj?#zu<7-EMH;r!<+x6j~B@rNqU6tC!j^qe^d2o;Q`K6xQ1~L}gld z5of@ZOwdZ|W}y-5bK*zLijWHmXBF{TNg@e)d8W`j*zLaT&ToKVZA$Moq5^zuo-lAY zCG|eil9%YM!kodWB)Lu}lXR|i;z$}_gAb}8JU~nJ%%7%MX5Lj_u!av7BTlRbYZ>&W zPLG(r#ESMNm--H0fZHoyHpt;}A9AYuZUlyKhH(x>1F#7-*FlgdBWh|sr;4n)fX?J?0!hCORJK$U|EU=l2wcAyQl$Nlj$IQP8mLD7!KvsNZuRpv1))kl9e6r z@FLTDIwQUb?dgHA$zy0=iSpB%^$wgy&bTCTy{N)Er&1QqQZy9+!f{dpsL8|sH8Wlx z=|in%gQ{ufl znv6`*R|q-5nX2XLXH;jE?f8HJQ;;D(=Sc8;KBl6nPU{qRI^$W;k`v|h7ig1$qRWez zMpoi!+14E{I3Q z(Z2uyu|Q70an+%a6SRbAfdM70O7%<&&64^WVX6So;-oIW$>wpBW*;>XN^wbW1usfd zp`2ptFc=UjtWXt5zYHb##c)0WGoX!}fFBfuuyweZJ?rP+UA~IH-zdP&maU82KQF|C4MU6u1w zZX@|b@VzcY1Wu>1FR}V0d1z}Zxad4HdZ0v0nv{=(lBswqncK|LF{KW{&kptk%%<1~ z3vIzfEYRctcpoer72OS3D2%=r{|v@O`#@As&tU8$(A+z!fL=>O;67j=r_YbHYMb5` z!#UOD^}l3l-2in1yNnO_*TUPv-l;S)oebixK?Yi-&Twy16M9XJ;eNv)X=auA#Oe)B zat$fmX74MoS5t>$1%vQdB|6D(+&dz% zCXO%XQg(DYDAm#4=iP}hSPQ%z%mhvKD~kW>1TN{aACcuwIv+kNDb+<Zi7pn~#=BP6Q+@Hdpek%~@1nL-FC0Em)K%uf92p$`&`VrG@Po1*W@)SQCdq6Zx&f zp2D>6Xbg2G5G`Q>9VkJ$!19W&vOqc4OpwMf!(2-0&4Krqd&*EOvy-R26Xt-TYFp;e zK**s>;DJ%I$XZuPWn52b$tJ&!h8aJfZlJs1gZM!n-W4kdfmOc^*7?B}s!4ql@!``g z$e-UsFzcv7`3=;b%;yOu8O7+vtPNN}+D1{=XxKIEAQO>E*TY3tL{$?Cv0wkpt#x@b z`lykFcQzf<%MCF9&8weJBC{eUm*0j?W(PuUV>}npa9=zRtLh<;){}Z$NVgD{AM8fR zZHwzzg&wufUEq7-A^RxF@(hbI06uk0VcF^LAeFHX%T!AcsFF~ardNq`8z$W`L%VKP zMp*uUMG@U}6KMD6-k&kt5d)U70U|yJ`$`<^$qfCJv%GL`wEl){&L8t~@IYV!4N!_| z9iN@4lefQ|za8|rMuFX1T14Uv8KtI3F>2_E{+dfHm+5a**dV12bkvguWI4vs#J1}z zZ^9SCkE?6qqkCR9^j<|#UchTm)g*)^a^SSV9$3(MoMQYw`+;!R zq>C5SKbbBaT1PQ<9+gQwOyKo7RDXhhDUC>J7XnOAWBn2odDotTd!%bfL5>H>$nVlt%S3xmM7k$U;GuJwZ@nN@-r@F8FmDJ|c zH$Ze>(sYWa;%E$`#d7yMDqj5h_+rqzjMD7$R3ivREK3Pw3f#5b6)^xkyBR`P1t60a zROHeRQ|vFt;Bq)2WqfOrfy|a`=qRNZ-a8(g^!t0joOxaS1XK$yQflPlOfJ93bin^O z<6PQKRDH~)$*OX7b|-_~aVI@2_>dlAjV8_LG>JxhV9+;-D@IqxO^}p%T!&*o<{W73 z^kj!;W7CC?rYM-p8e0d0_JvcyBAP|m4tjm?-7N}P38GU{@Va4f9=!EPT4N+NYB}$P zj42YY!X7O5V4xw$0_u^#`ey6&7DX&iGp;1>2EFp-3sOfmanT z?Z2d^H4*MhBBTh5rBdETZ0^Fobt_i^1}P?lzj)+AmAknUFO(kgijV^-z!?e-qbvsO z2IRhx=5;kEG4F`6amlC@oalKQ7h;~Fp%G;W&I8leppnH(Xj(u-$jIvH9G)P z`F3~zuZD(f@ZW`@n+|7lQ#U=gtDCDlOD2fE3QsIP9lvGYx$xV=*2_iT<9~wk>#w2l6o|iE zrBRC=pud!Thv)Wv7&K*-Cdku8nJ(#ZAqc``S>&~%iY!c(NjTT9sx9u#TjFwGv7H@jEelc;lOjoQ3SnxRVq0jS zEdK*6sw=hqwP{Qq(NmaEtgL48o%K>z;B{TqW>;D8ps)T&X$=;Fo%ZY}u>#Z}s6KIe zY365l84wcYLLVbx<%f(=q`@F~_N=oZ>0zP=Qk|sXdbIe z=FQ>3I^gpJBTTdx7r~K*+}nZ)F^o49kj2eEFA%td8gRQE-KcIEB@P>9>ScpjPi@(-|vZ zp#|e0pjlZ`qWNn%lg$)@Hf04Qwce>c3pIjcTI9IBzSu!u;vI%Rms zXl7gd^EC5j&b;cu=FOhhykF;&>+9Kv`TOZLHKPLQ}SF4j?ioS zc6Y?r`wgpoN}yG8C7`#f_?g)H#r3qbLXNZoASR*r(=VBj>*L$ETt60%j;o|V2Y?O) zz@rd`bhrGCZ|P9y44}U@BG>*E(82Z{*?0e!>*2T`Xo1mH!DjE30MiM1AoQ6$2fRSd z;S?`LjZG7SAlWP4p>NZ{fk}r102;F*QX!;{PHf*z;>^VTc+0y=ycV{q-QQH$kY9K< z*5WcS=-uk;4c6G0RR7j?&<^p00960?43>0!XONW_ng85*p)w*_!geQ>C~BS z>P$af*wYJvkU%Li#riX{b78H}l82Bt310 zY4af%e__m!h1c1ZASSXUH$D_VwY&N`XJDgB+J`@S%}+`Iq5K@_NyEQ6c49Q4eT^5e zZoOHjuyU~_uzSdd_mD#GxAA(Az}`F!*x~cqIKY1ynErf40V)CjU1b2YFrhG^FoD_X zC=W6@z@uwAuGTu<+AA%8wcjRL{I>J${S5z1kFA(?o~yOEX(u_G?J7_^VNxa1x_}z3 z<;5;huO@hezB!%yhSxJ9;gxh_#sYp<*f0@2&4kbEz(Z$Eg*(5!|J#tuH(F+tO>tA9v-&JW$ zD*`=gpp0*9zJrulfMrX8hY6nzbf71^r)Cj2q2GodcED$gkI-D3m*jDt5y@)}>3Z2R5wJ{4G(0Xbs+L^t;V?Jmee2RXk8FVd9?2e^tI<9eG$jZ|`(zFuT(Z0h-Sn{E|LyN#B4m|j%0NSay!jgd*W*8~^(y=CqA!?)f z!+Os{J}$H1a+YC>y#47N*ST9Cj;k4$ehARk^gYeXFxNTuyQ zhnlS7I!7R7w~!G50V`Pd7PzXlFkl*IiPNlwKIPDj zJx5!R`y%Mdg(50a9K7N+62w7}L}SPElHPPU9E8TqJ$VS@TOr;FRX_9#nVmLP0Y!=Q z3hpJ|LLKR5s%Ni^6J#q-v$x+#`S_j;U2l*K!Z0v}i|ap+AQ><@W<^>+X)5(jI210^ z(4@u}T?%BYJDSJt zbX!-}-p(az4OFA)RLE!#47@7vGCIIsG1V~zx+jPpX0HW5H^SA;!Eua+GFX$XUCtw| z%3yp7GVzChI}2QBS7|XX((9QK4rh11+<~<$^4V&~(x@M~#s}5Xw)1}#i%|CKDHeyb zJ74ccv5^yb%<%*N$2gcqH>1|yZ(H~VESAU9YnP}OhZU}03~hHG?nc$$$CC+zg({GNK(!tUyWh1E7A@pRm#P}%nd=Kh@0N= zOp`R})*h1{aX?~t!9t>tv}G?_@Vp7b^R58T!dfYn^6WiK7rf5hOsp z#K5XW)5rKMyNQS&By#>y`qbvS+%1gl98gg#9vI5X_PYoM7;J8sg?;`lMa|e%$!? zLHrue2$&`3TZvrspSD^2YH9;SG&{e$iCg@0AI8dGM1BW*;nC=?`MKj(mwE3Z0?`Ru zd7(RJNI1+cgp_8^YDkeZMwOF3;II?DVTsz3eR9jTjnCzKoMUEAPtH%z&qgQbLkI__ zly8Hlg5EMRlB|a8+-(q^smwei;j7Yz;&&5mUaSG?wWIJQP4dkWn?nKi@XW*OVO=Hn zyh;dNo0brED{`eK#~7Bt^SCFFALk9t0v{cNaT* zuaVoXHw8lM)mCQweL70FlqQ*KJDC2ze;8e}*yE+0kBbj(}e$4_R- z6R?+v3b-9WM*)2yz_YiKL+RmiYM>9hit!asoFY0#=4kZX+{$p4+1S6)6xYFC2G+#uM4}*atbBHI?=@cC! zp1$2&^5cR1>GzKZ_M)kHIm7Q!Q@>AD2*#e6@+ld{+8sjrttpooKBf#8+&ALezOXK0 ztthlIvaMhyFM>Yx!~k0r&T8^S?dQaqAsv$#PPfct2fe=wCh!@~PxP!PGW%?l+R5s% zjc1W#5!ka3?Fe2KImNpV;N(4|b!eZVJ$qoZe^+iWY8vMXWRgXG7jl6#j5af}r{=t@ z)@7MiM80Z|t7#R@QWOH0DIS0a_O;@~?s{zXawnW;I&bxZmGn%ln}MCn&8RBD*T5EZ zU|wR*{r~^~|Nq3DJ8#=C5P31d<{BhLV>f3Q)Hh70H!nq8Z5 zaVX-n5gMO%%1juw4zN4>`sZ1K@sfn|ka8FjyRgadG&N^&Z6OSE+8Hmc@z|BhFR`|* zgT~Txk4~Y?^iFHX-*JLsErFQ3%GJy1SJ~tBPWYZOI@cYsgSR!xI-;{X=K+RgNsAt<@w2z z(8=$HD1ZrQ8%`WEx_W#hH!xorZXx_6mN}`H?64JSLtrVq#J`l7XI+4fb{Jfyc@l!BuFrx5X6OZwTqBS!S(GAj7q!t{OQZ)+wJ%DDoSdKSKGY@m+PCG zugj%Ph<0=l$F&qrJwRUcr~ZD}ZGWA0`e9o&_Z~Z6;cOgmgw^6pD92B|4dt|^9F$8C zmJr++lTE=NKf1`|zFdgo{=B>X@RuNNs9Ih?xj8g8e7TsUf1rM?zfeN)ngBzI1oODU-MI9^ zY_jj6YBt$NzV+Bin91~R!1OSW>78YI9tEiO_)*xi3WRuT;`?+{i*ep~D)i%~wmyS7 z7e-h5lN_h}1^cXDOi3Y4_u$9pfB{8DGK++BMt1zlV=zb@|CRrpy8=+T44|42?nP?B zE(~Z5Z9oKDE(^9&2cqw1eOvGc00960++A%?+&B>a?q3n26L!AaETGCgA4vNs4S z3(4*;xZljd?0_xE8`VV_%U(_M>Zv5ETg^wz$%CddEk0+1YM%T3uPQBs*uZ+g4hL>p zG6bAiPJEo~`Mcacd8T}C`~wT?0(1aH0+jfP^)FK1QjTgY-R0FI6$$1z4hXjz+(3PV0G4XU7|RouSg>}U`Mo0bt@VO*K=5ChTzCVc`H zII0rhf_U+xOQq1+bKWdb>F&8^gpZ)i^U>ZI!-Q zm(x5r@VS(Df=7hS;wuzOV67HpV_+-AQucM;ys#q2FW3vH7wF^DH(7?b6K;Zk@kSgt-VFak0qN07 z(&4W{oX+LY^_+T>7N%9Lb zjD!_&dOrT^=KRye->cWcDa{czPmfpfJacYnu*OP61$tu{zo8ipK#r8(iZtCa`)Sxq zD9o&-lRWeL?2~178&YNhY@#h6qrQ$mRd=F6GqA#{a-6w)Ympnc8C{ST3tHpj53y0) z6Cnu6zM5RdZ>P5MpFPL+S=xul9K)$~!Os);b6|IIHTF6vnK{S@2VEbUuF)dZwoMzs z^nI4^2O0w=IG8XJy4FM6?4b!gq>6AZ;qu~suh83LU zOR5NN4D?zL3=j3GW9E%JF2GEZKn93j zNmeB8yJ+Mz_=)nt<3JQ>k9|k&{mD(W>b8)2XnRH_ougtVIBB1{OT0_%AfOwqpv4TK z4ty3tB)iZx2t?mb!R#mB7O<$)9((qvYy(L?vtUiOHPG-0$`ckW)cBDEv0} ztPDGU{)FD3rRy}ZH`LVaVUox5tqcv7RbQBeR7fL**}x|eD&#=rTUgX6?PdWycyOJ1 z&mVLdmkHF(wN(Dy=!dprRPbddGQfKXvb7ldJDL6f|S9efRIMmryLFC{W$TS zs${^3XsMm;{sRC2|Nrb=IS#@w5bX1c(9uuM3|3hh~^_Ifzf`MHwBb;WHN1ACAZkU$0KHTIN&AZ;zv2IxEGIRUFj>jSSGCRo$; zYT`*k>cv9i0RP1g3ZOdGOwDbF7u_WzVG@CiArZ)a&_csrCbIY(K^u@WF(2RRs}D(^hjY$?I|ek= zV%V8JT)48?_n+9hJBRdNo8GClF$p$}Ii>T7qZ#&6o6;Qz#fj%ayf64nECCkvwS6;y zog^8b(i^s!!F_Oh(tIirg)-0^DZ+|Q#3(u;y92^MP;f#O+#*`RS-~d1SZ=udf4MyX z00960A~(C`ke1zYsFB@r=$qYgfZ5HITGvIVT0%(FObvAElL#`-24j#E5uM zKBErhK{-wxUK5nvr;B{8D5Vu+T8{zx4ykCRY5}RTBjTZ*+NS!QUT}(hrzqvLN!}Vh zyF%>GX!>%a3H9Ih7n&1Fe4!*Il-dh5>F&~<&}iNaVctCD^5(%LmsJyjR`JC{ZJO*B zcE2l4E)q|C@gyal+KV^0RLgu_{G+9ezlpmRV}#W?xqI6Tlc5j9*UEtj!9n zxWq;Un@E{W3RVCB0RR8&UBPO@FbuutD|~d=3hiz?jyYWenO)i?uu~{&ciN@2{r_2( zrZ`R_%GhCyL61R}WFZy&^j>ltHxL36$ixH#UuO4KXL7;6(l!rOY1*o= zPcN&4UFJPt&H6Kuz;FO#q_L=ZEj1^!{Q?TGx7#3iU|qCYII05ZTmRui9J3vc2!vJh8zS@JhyP7ej}AvbdNLI8no5|A7GLxDg8M-# z2r?tr#2fVoHG{Yw0~(xi7zsYZ+{RhWZ(xG$3F*DgI16>tY}RMg*@LCQFQ$$xQreRO zF_l{vRyb_`;ctkw1K<3}QD*Cu4&5*;Eku&Z5U2kr|K}a~1ONd4|HNI}Zrer>eU83@ z=u2!Nwt=)j;JN{n0tpbnXoDokOHnvdM43cslF(9eRYCurIdjOyt^jsr%}C;KWDg6lWR*^MT06sP5% z2Q0IyJgXWnL>iLIoI}W@%UmQbuht03#lw0?in+5r3})yBiXH=dYp)y~<9N@Q*+F;o0`B)pP!HZ(}gcS1I?e05&UEWJ!wbSx zV(xbK<~$HT0YvOS>!HuO)qef*{VN|K?Gn5+%#_7hi=37KCm>f$d(t&0bM|vh)A2+_ zztCP(M{7g^G5s%ZbUv?@+Q_p#Mn;F~BHtLB@^+(ZvP8Mdj$QK}Q4{iiX=qALhf;Y> zHQG+)gaKs!9my!3kfsHTW(69gj)q0;chPn2uV-gnHUCunb2`hHRoS>xENX}Dz!)DO z*m*WcutO#MFn%4a`&;OBxQITx4%~=|_B*5+a>2)#kkRbgY|Hn+K(WiV@2mM0kH=Lm z_I8&|*3;#dv~X$Hc|G4nrD(gtFK1&3URq8H!EIcSCJ=<$TRM|FM z```p_+r^_tRPQ@nqEcR~($f9^sr~Zrm*AXV*t&*%H_x9-X}||#2&!Hglifx50+Epj z4>x=7my1|z$kf&s9iLlFAgisEx=Z$F@lar)3&YViPG(~$E8asgx3J2@a9*;n)Z}sK zs79a8M+{c1g|&T>eIHj;8eJ7MAlNiK)j z5a(b_`4#r8sH86s1q@EBcrV`Rnfs zo`cPjQ)Czm^PZT#VoHUpd#BKAwaUpXdJ?9OXaRdEs{A6VqX|s!7BU_0jzf8RYUF|5 zIx6Ht@u+_>a7K1(=H zX5yHyoE(S&6yGHCk9!t0Ju-rd1RjL+i>^TktOFP<<{}R|!&))0$|+mM2GB88sLZkm&RrPsI(7kjuwCp7 zc)O+sptq=50uRruhU2y(X9f?tM6wvmp5*yGbq~{Pxi5@+trX@WA$FD9NS@+4FZBhQ z$Wv;TzLl0OLb%rLKElQhY?G!+K5*R^TW?0sMIe&kDFd{S#*iGM?<$}p=WuiW3*nM@%p zLupGpM-vkcn>z&X9bc5rjpxcNg8AH}WmipXm=8AUd~DDmYvRDr2iVCiowLNzQK=%z zFidh`fh@)b(-;fnvA<<5MzTdu>Uy@e6RiWOY$BS8X#OqH_?A|e=~G?6GPcL+YM0k9 ziw;r}*8$qmge2e4U)~QY!234UGuV#e-B?@Yrg}ZlRQ0TjMmrAcOpQVud7J%Q znVW{v`FVQx_&`>xWkxPURjvpxHM)@M5C~U{YIGow%krZ@fcs*qQcc&$fQEdpA0GTB zk7so*Q+Pel0u4wOw#CeFT-xE+bjEFBb|x&*mT^FndHtz7c66G(?wB|ZxJt!-TN34P zpf|+3XJPd=uT|U_hYQq-;UhNiEB9ZjeEs?Mjy@J1t{Q5a0zInMcQTOB4WFFCbnPf zAu75bLyj%l;O$9}01}-%ZgY_4CO@;SIFbS#It?N{xejJP&MeT3)-JL$lz;fGn70x?-pggiH zulQ_MaqZej9@3Q}l=E(@I*?jMAEFO?A2+10G(&&qrawl^CTm*YWr087NhHFuu^ScLjJiQD>T0JrORJb(vCS}f&6X4kI}1AtI}3YI*hM#C7qP-F zg1f@^6Lq0PeHJO|>+Dn58Ck61K@G3-Q!L>u;Z(xWJPnjBwU?;!9pvuxWCcCs12=Bu zRn~7c}5ZI8O4)4qfnml5$PFq)2@k` zq5NjH6Sfn!6SkAV+DTh4W6_HwWg0d*;6-=Pi+bFOw`m71Dz_nFB^~+}88A{Y5;)8p4+< z^YTzxl#3TH1yT=D1=vBfCKFr>t#czE=sFt*oOIG$MI80(2myUNm<>g}jGqRx zaS=2TG@F%9lFA~NXE6jDhqB{fW$wkV5o4FZ;{n*v&rN!OIcq*j0HyM~mw(t!Ht#ra4A_N5S>Rx_HX-GOfGu=Hs-7~)q)eZvksc`z(fPfk0}ERg@)BBmxBKe45iW!7{c0A5DGFh znZQg#m}wD3s4~jP7chN*o?7OUuK-<;sFq>}2Q!c>UTqDqT^j(|uq%ow^yz9o57 z8&nlG$%%Tgh*6T~d0l4J>QOx2LmT1cdk^vM{&9VhP6Lfu^6ZnW>{ex2RBQu7GVs71 zW~Z2NN3ah(1<0iNRy|L6D-Jp2Ii1hKS90)FER3SWLOJ<`MpsP1=dx?cBeFbh6Cx}e za8~4gDqXEsV&&BInJLC5lFKjLdIE#ZqDbD?fDiacZpl_;3FD|>j}s`OWO7JHz6KFh zRHe$Ib8Bzi(uCoUVwdr7NOGju1ds5A3s^+VPzPa^0pB6)C2oa_d>~FjO{hlpTD?m| zT&h_y5aDLHy(*Pm;-sLrVe)})N3pVn>Mkz!z(lh(lE>o-5Fqw2T7eK8F+(@GY3dH| zaS?@0Pvb{xXawj&7Wm*ProM*GN{sbHFO^=Wg1sd3&^G9l$0VhGZ6#Vk5njWp5-drO z7UDKA-B;Xq7XBzaQ?9?MGVt*X8b9+KkeE1<5t7*Z16NeK+$%FoD`#+i!2pibf}V)# zSHX1R@Z(Z|1wtMyL>w9g@Tmy$_?DJm*LWI!Sne z9~bR(s;wFug}}}0qUU)AGKr!2j6IXseCEaqgrsIELefKwcIj_|NKzl)1|x}S6hV?o z+rJsA0}?LXu}D9>e50bGyVhP4y<4wz&2KmXPjAx$RqXq4uvJ2Vt+NTx+CK4J-~WnL1|Vb<28zTuhA*>8cXyXY=Cqm5N{}i^`NTs?m6^$0he&Q zAX^8AqddxnYP#Yyii3vBda~2K{&acv)ry>1C$TMu+Z8)Smte<{a8J*5VyWxx6#B2a zX?U%<`2k;6h^LjB_OyknJ+rTCE&al@%%;b{mhPgzc~g%6gK{hv_U1}qZ*C#%tM~x3OAo) z4mV2SkaVxe;b`f9og_}-b6Opxh^$WIEbs#Qc>L08AO)fP=T`%o zeh8t`3_`q=#%p9yOxk0M+({e5*DxShqiE-&`cJ@r+vHHzsW0$XWKoWV$p9_MpQs0R z8x47K&*@u%4pVVN;ggd1F`$$m1R0330?_=Oakzg#1L-InPY%^$ybrpOLRwKC+M!qs z-hi2ttixoS;h+XSGHNxyQA}^`HgtYVG?4ET@$Q|v!GTa#GYsgWek_pOUm&?}NbZ-D zRON>?$RDv_SUAkUc6Vi@85ll7K8u z78HDjB|5p=c#VYS!tiXOH04QATYVPYuH$+`SR$rFg{U7&9Y)?1y&+VBgtWkTew<0r z!9)(w(^O|i`e3>mfFewHKJNXfsMd#I?RNFIxuC>^!>aTR4py4aRA86TN9h^x$sdsp+{?ld zmm8oJmW~kPH$U^HDAB=kB12$d=!FU4a+?Ap1EPa(oFflC$%8n@lowf?n(%x|ttwC9 zKz&0J#AN^ysko^$Su`zI1wyzW&WwI_S@TURb@9UqIC322_fu2Z0y;YjYDfa>6nty< zFRpL;qIGpEzO}mD)>Z%Z133VgE}~i&DwK{V_j3%egeittkiyrq?&$@*()!fCZ1-<* zEpy)PUx8;S&ab=Rgmqfoe*5(1vegxxn{Ma2cZTUSu10|bR&?T8g&|9cfx_V9#eoe?h=7JB z$T} zg?xC)gD5K!kj&84O$J{d3S%99yJrrEq8! zNUc+98YuE1zBVc?NwZMUfDVQmX#)FSi3$dZNa~QvKbSIOpt58mgi1&7r6O1qg3L2B zgsM`3M=7vL%>`cEq*0cinWD*64Q!f&d!R|BY0*xhZo!^WvDPp#tpX4eG)z>K3}V5~ zKd=Th=;5)apyA^Tx<*w;K}ksyEL8w>O$h)10RR8&9sPF_NATzHSFE%Y5E2g(wT6d2 zn~yeCn>Hq`EuoZ;0}g>hjx*Sp{_UNQ-M!u8F2PjW_u9s%l4Eyvc6MfVW_I?bFACXI z+T;SDNw#bt-eO=a92h;2La~TL_WNKP4MhR?3}lxd4ctW_3V?7~FvbW6Joeb&*AP3` zE2`n)3Bi)XfqWJ`Q5Q~4c*KZS8+ceM70H{?!{nUm5@8_$y{7mA7^5bf<>4U#)XmPP zia4U4Fm0?QOc>HINOkBmk~2G@W-XqQ;oRvG{B%lM^(Rq4S-(Fx=zgXEAhM z8g_{EhH19B05B-S=+*!#0E3X30(w2vN@~cd;+slMTJg0gy0IoXErgh)%t%OB_LZGl z=1QHCu4AWGKZ>0ixB74EHl}$xpWg1R3d7J|-|p4LSZ`(ZR@XFpwGZ|QOx^@|LOkt( zRrg{Gz6%!ac_=0eGmVqOJ+Zy>s7m3T1uQ`4-HNCv zV(fbXNWM40SAv4kD>2&@Cse(TPfSp|z*dfw^t&P5Yr`utQ{vj0KUbkqU=l6~)l(-e zv%n3Z59$kqzDKHq>p97EHUxpWpm+r*3V(C{l)RV2FE9%{{k}EeXqXL#@%as;7_tR0 zGnsyRy+GBOmL%{a z)nQ&d6kIkiX(bb#|1FSFkNnwmSs7!0Yjsu#vgLvq`H(#7+9~PL9(DqLGc8Y zC`}5vQdaMt?7h;=gkdI~=-&DRdwSSho#TQ2p{zeX0hC+Rlv&q0Y>J@mnb>p92FeA* z(pO<==q{l-RlMgrvKK={YzDNAKs+7eP9|TNYUi+1ZgdczV!)-aNES5|)ELGsMlP6& zrNZg`m|&-a!1$nHWnwcG(nOdV0KOH{rvy}W(UjJ(ZM~~Fkg4taB5CykQL zqwB$7aJv`Cw$aQ_RVfO&A%;jkrkWQhI(A(w1{&g97^yABI1mK$6tY~yX_nOoc3zga zQ5?KFI&B?3J$in2a!^EXz~Wr=ihyyA^Xy45P|O>mw+_FPmk#{94palw!uMMpZ_sFp zI`qqOJ_D*q<};j|?}N=W$C`~4_dylFdp$j!OFaV9tR=wr_|9C50OKe)24AD2M=9O# zqH!PAgL_~m_Hg228}&unaDI!tL+*EU@0gD#sWs}P)1g}F=;%dVNS3Th{(HnvQkO;S z+Hn^bc;SY*mC7^Qq6b2^%gSpNKZ4t$H-&rMkUy|G~pAAMMs~!>B)gf&iW6j*~@W3hxDB)m}grrTeSB{e#1=zd8E$+4C3Q z9cS^`_dlGxJU#pIr&mA!(l|eF{@Q~6zqLEvp4%S`z0vFOWa`7C*_(N=2;W{T-~E31 z{^}2=cN7i7AQv!8SHJB&QopF+wX@VhiiKR1ISh1o%#4m9(?~^MmRzcT9o1-~z$wXl z-6XRuiZwP?caY{yp*9R)Al?|lsB+jsZX+~-TGZriqtXPK#)kRL{LM|P)YM687;9N+ zVx82yo43PNI$4q>D{*qNr6LGf>DX$vP~Wkz5fvM;U9==BpsT{!I1C!w8W^rex294K zfQ3%*dO(y4W$a_SBm=5jv`!RR$(X^GTCJGbxI`s6$4C=6niN;52D$MvD{&}uV1>~K zDs3>8`Z5^AA<7~tTEPla>4K>794UEld??<(7xdYY9XhZ>zXqIiJ6vyU#nZ3wx|Z_z zh%pe4ML{h=QEZBegmlUOX&g-T$B0nuM-F6@rJi8qSTmB!x)@=~_&LlXVP3X2nBE+r z$&}yVklAYgvo-oxbbpJ~v1t-|#Fu9OQVAg_2HdzZxafeQ*CxkUq7B__?yTvcE$NGT zq(L|iZj-jm$drwV!Ilg^#8NRO!oTX+okx}-k75kdX{*_0Hj-&@eRprrk^`y!(c)g) zQ*D5{pMIb^vd59wStd6YO#xO}W(z;Ii5d2$xiBQLBMy&_I6P`muqH~Sk&XAwsI8d=EO;8Q6+GJ z(jL)@M+!!E=XfsJT{2zHi1sEZ^0g5nJiWIcA~=b+z7R?33pWyu{uAW z=F^2Qq0h>;g=bCFqy~#Z+d1<7O!59qo<((sbBm902@M9Ht;N)L5g4@HG+8>PMEBjB zl;|phq$^T>Jx+=uO;DVqQ2CLmX#YEk^q5^HS+_A9-(G9ZmF6NdC@AHeo$)L7Bc*j= z?9iaWo`~#OR_uyw2-Z@;viFLSqBHFvLcmEimo!&huhHTLZc=Ls+H&Nw-5uifQVf*8 z2|ZLM(w&@RB%Cr#fnXnW6t?|Qj>6)(YJc@8?C(zj+ZM)I-ug#js?5i#2drLE#_xTi zy9)BXEw}&yUtCxz6h+^yafr4ZJ4BPIg@t13aoV5koJ~%|AQZ>1@^)kvHOw$V_r_b8 z7{;lya5SXdm^qJbJb(wV7xVpT3H^>=&A4bo8bX2ofkGd7zczZS7Jh7Tk}XcMf5eYf zxyMkWfzmvqY$%5~@EmW?+#XLYuihL)nrf~=-)GWPgwpEua1=_z_~qrxL-AO?=ZEsO z_;|Z$kZs-?55JHJSQ!8`W9qQU$ZROvlHQR~r1x~Mk)jP{mq@V|c{ImU&}f{&NYZzl z;^DQcYo5ou>=^MjR4<_G`6)?qR+b+Mo5+)OsSDZ!%Cj?+$E^b3H_?f1vJ2gpIxw<> zKZm`xe`4WwKb!cih1-Y6=C*J@0RRC1|1wcPYNAu4g#czinZFAF00960>|NV(+sF}p z$5)_S8(FH5lz5e7uU*mFTN`buY?o;}@skab0EGwy7yy(lKja}lk{`%lD$~u zfYim>hpb$#l7!1(re~)6bk9s5p;E1)S5B3(3Hx3H-wxLBt(T1q1e7TunY+kfp^9xDKDg zHPGp>icakl)3x~X0dqcJ&IinS{axBH*N`5)(ayp!DyN<8$8xC@Hv)6?t>Ik>e}}fZxj6(KZiJw8suI9Vlx6?(y}{&7Tr4gS-x zmrzvQTTpUQNXgoe%Y#q+_kRRMIN~3X{R2Ru^#i^|_v8nC^ChL^WX44-5`oComoC4MBDR^dQb!N3qtSha_Nqs2n74{JZ&e#gCN)}phK2L4}SCx z;4Auv7Rd$yaVq1AfLc0Bqvqr3-34Wvl#_Wa=vGW(@dLvCeI3cJiG3e^2bW;2#9R0U zg06dYenG>;wM(zM22DQD(YFCKcqz@zRda3O->T_O`8CZ~8))w&g{nGwv^Lmt7`t_& z`#tWqq4AARY;qcH0}FK%K`D)aglLw)a$8`}p7|ETP=mZ~s0RNqqu%AuSEbZ-r;62a z7H?BSJ?v&~aAa+ctn2sGCSz!%UE@yPYq~fjHZeKX8WP6+Ch6kbOmBBt2wDWwqJ8q_ z6kJ;T)rVid!$Qy+eb0R)i0dBsZjQT#EOBtJ-R(*iuj)M|$WP$S9>~!|`27&EC;ptl ztG(J+?Q@LqP+zAZtqB5j4?0~U=r92QKoGNlz@29F1;?>Z>Gn77B_;-Ss#?2&9%~$d~=)wjy;G^((^|9a_g64a%R}k_?$wP@S5?-qUH8 zD~4y4CP|SXQ9&~-NGZp*?7#PY+1Ib<7d;y~&&r`E_{RsS+-C!P7NInrPA1QTD`=hk z!Sw{Ef|Q(dcNRv$Dk(9@8tze9E4wU3Ct{UFI;plawWYk>COZT#LvQg$bszM|e4d2- z)f2q^-rU7tk*P`+MSG?wtRBpx)SwmQ!RrF7r8~1_MCDz|Ap7@^?SJ~s%<}yCV;}_%8 z$1QjRj|b8l{^z%00m^u){@zkVnFrGlUqc=-dc|}tsqQ)rKsV;h%dRtlnDWA4Ihm_6iZ`Tuc$K^*sJjYY-H1qt5ECEDKs7&rLGUW{;l4 zk*5Jz3>spAzYqtlFcUBc@f^&FSpd>He1UFWu#nUs@EOrQR9=~R&Knv{oH|@#Xu!z| zErCNXd@4>xjG{osr6 zpP9`KKHIX2lI5Y%>2$X6T0zeb?Znp7*<&Rbs#A-=9rp@RoT2t~rM$)rdJDkW;0oJ(XPXfTJ8#rhEQO{tJiu_sipV=z}dvHNy&ps zfq2M`#^rnzRzYXkZkjD)CW*8@v%YA@C8))pvk=c=HLL-36m=pcG%+)n4{#BIA%lel ziV4w55ek7?EL;9&{)^XdK7vl{oSpt8wSRZDga#5bo_$0TO}_@=aan{()Uqj7?A#${ zj7pjLPOw@ePcMqaPKLka^PK=oeOh!Rdg)smY1+dtLDtRmExW7jp|^bgc6|uB&V*!D z0tLc^&T1@JIj%fQb~hSvT1Redoj*zBugOjjCh;6@=Q~-Epd&n^MT9NQ$6J$R05 z(bwSOaH-#Fmdwdi`7YKPIj5U^W1G2I%o^x+Ew@ao7#MA9zV^!`+M^k1W%_g}m+M}J{noy7N1uIT580rcp(N)^^ zJ#zc%zBK{u0TQvjbRr(^+;HkLAXHQM(IcLN0#2-QwZATFt)k1fX`WL`07wCsLI&o^ ztMTclzxF$WcK3Lshp^x;8QkMGxhjg%MiCK@9wXg7qi8~Wofh#$^98x1$=12ySnl<8SB&M?8tRB`6EHRd6--(VUWSaF~pgg(Mo2{8hIz zS5YQ*6D}f4R&||}8e*YfwP4!WHs(<`6+~7B>WN5cQ^m{9RzVG4bg9v^gw|40$I#o_ zEm*nwj zakYI&?NQrL+@BHQz6Oltj&UIM;-ZF%)pF0 z!92z1O`3vEvyiC$U^a_6=nt<>FPPAs!?@ezKZnmw+dQIcyMeYSz6>XEknSn!ahW2h zR$@cdd;(()O?KS?F?3QGN@c%LPX-L7MPY~&+q?BNR=X$>f+*vUL**RjH)aD3W;h8z z%OERZq(2Om_K*`Dxz04zRlRL1=%tl*O|*WEBaijNd5DzhtCX^*Ho_K5;~9-W%UI#< z+pp`stppv5s4Jy5Gy$`WHB-@|AxJ(ub{I~J?Nte<+&k(Ng7RH+EP$T%wa#d0%dLJ>!ssmbqP$pYD@jsvXVDqdbFWZ2FQ$p zgsiO97x7cFxT5*T)rc0FZm)>TmFy~=gww#p-q+=1_}?5OqSNihsW%t@Sm3s1O1DHT z_K_~Ta_HRB^I;fu9r$D&8fnB(Itar=ly#qKb~A5?;5fq%Wa zPmgBywm1TAG__+4epQJ8>Ynr_l9nAf9T%OZSGgTp&Q*lbZ-osiW)WD(CzNK z^6Q$0cddxUqG+GTquKEIa5(G**Mdp3F&cb8n6E_9%H9~LKhh!;wz`vs-qpaLFsXpi zLVE`)vcD&)k@VO_ntkE5Ol9_F8F~Mde>`HX9;BtQ>McyS4eDA~W8yt5~*X zdv|g#HFiYVp#GYLMT~9_XIUcMwdr(;+4*vZ{WHG?mjM@ozuk5B%r*kYd)Y{_prKWeXWQNGU>g}St_0dg zI;00TjhN~Hv*59d zpJA91q+E;8p@wl9^9CA>Ow%b2T(R3GJlSUAR=!D?cDHObV*djG0RR8&U2Ss{M-u*= z`4toA4y1~;NV06emD9x$27Ey5GUm9ds}!|bE%IVXtJCgcO!DKe-)3gtWXZNn*OqRz<%sA8S(8>I?Q z>6=r8!g4`1ZjKW%NwtR@$hNL7}|J?=Y9u5lAeG~;#4 zQ?HD4S;4xsB0^xO6-o%jg%lK!Zu>6eheG|uE0@pa$ERoWf z{>RZ|<)f|Jy}RO3+>E8;EngL0ZQ^7rtizVts=;?IC6xY_gc6|UEl6de-zvn~xw#&) zHiZl-lxd_kLL-^TpM*+<^D-Pq@tpw!gt$iGuN8u( z7sD%M%@HPU)1pcZ^im=^R%E~nWjo$l_&^&4@o$m&W2Q6+LH7wdBE zimtm@W%Hsl4Bo-IIKai);bsOu+&MOHX{_J9*cH3lnM93QQIxB5AM0g>Gb)V9#|n~w zo)?)#P~?d}8)t-vMFSi9>lGHw67Lkj$qb#*aEBV}XFr-47qiqYp=R@8Lgx53wm~UG zhaNLTp|TrJOEtM|;*<$USXAjxB9v7I84rdM-YN-n+#??@dGmAs-^nuCm6#ch6cAf zUT4?)$B%z_qgN@hp23&BFANxtl#IHNWJ_(Dgd{7^K+eD7-A? zO%j}fb~a*ONfKM-DPD>QHBGrhK zVpWS__eRnQAU+ou;5_lyB82J(;z=)!t>J`StfR#H`XIxf#-@7t@^?+fvn>Yfj*`~i z|9nai_;uX+a^YhOE5NN?xI(^(k|3ObSO`JP=@S+e<(P?O+&G1oOS~r#-*|ClgaAr~ z&*U%{K_nOy^nL)@k>yoETvhT{aU}~Wdy5DFEHx=~kDObD4rXFQ*;wf!3~4X)?A)_q zVfwHk810^hr_TpFy#KFMR z*}{}4&SRrNj)eur#Y)P;W*;#j79#sllS2xTkYFy&VG7|1RR^E~UGgJAqZS_n{Ferq z!s*yw;~|uMF4C9v+q>7>#D~MzsOB)GBb#w3pg%vrnA|0>?ub5#>zGpBD${7mPGJQTn zTof!aSEz>bP|`~regS??=uE|LVIK(SPGO*#$X_#VYSD9G8OxuIw-y!OWTQaHyH44- zHIr5iT8)xi4AVAAT>`QCR1nr?QOj|tX@vmhJg*YN*0Q50sl;p?T~Y+{)qHedZaiS#@pKZE_*BVl`*&!L_qi#?|434b1VV}_guG6hghJ7fL2tLp< z40N7OCmSL|sw9qAOZtNmTsbgN!S`$Kryey{Jyy)8*X<|zevSP^&q|~*J%x>v=%;`w zn|Y!taclW{mTzivd`+|2AO}&nwK;-{R-62L*RoRWs@-*x>#$nlhVHj8qd1L%ts*2Ebb$Bg z6h;o$;COM7a4JxQLNh8Bk97Qk(BoHeW_jl@=iMXBG+&@ee}-WmIbb%&g3MsgN-;8v zcEx*J`CYoyZe!eA$Wd>&@_{Ksm+vxWlXqsqBJ(MiOxaknoznj`nUr-onp=Ca~NG`uQh~~v+5ywmbuh2hY{tWzJfdY z#ZTZ4`3CK1*m8#Pvv{krp+!YeK=`DO6iYjXJuBKJrAlGAGzF-&0*c&FZ?n018&+Z9 zI&ZxDvD1b>WQl|ypTnP~2e%8K9kC=naE_|u?QWZF9{I$^7_Kl$_zKNt6OOLMm(0CO z;NHqy#i4=On8%n8m5@BO)Evp85TuywkmV+co<3j&HqPDt-x(Wd!AN03G6-yp&pu4p z_5(C{h_iY~;xWCN1Bu>I(4L{MP{Dl7qDg(0XvNW+{#Y z4H|fNwcBtxQOhhwRCJV9IZ7W?xhBg;?Mn_M%A|l`RAM%l%BRXGniz#9y>x(L3saV1 zJpIxo6fnU7Wo~i#fRfNJa0{a?tLj@o`&k~o*969_R^Ezr>X4%@zj^8A& zV|6>-VQ;>S5@edKzWi{Pow&>sbuT-yr>jCFzb7pysl?vMuPNwoGj|a=Iy`%h)&iIL z$|QU+5ms0FU<8+;-NfV=YXib zsgEZS>;?TYO23NB9hP(TYX=k9VU!T%#mvuw3+~j~$Hd5Yi7;|;iqLEF{Wjcq0#tY~ ziGcMS(B2z`{=~#%Se1fYQF!a|0!ikBIhnnn$vq4~?*(}=qGeVuKty7|2fL)?Q(bEu zNiWFmQ8b3ghh+TVrR0mC?M9`jno+CJ)i_vO%~PD*`*1OX1$h+*=Q*2OGLOW=OScMi z#9%p$Fk*Er(?E;1=j+gkk~QiZa@T}O7lJ@EWN@;ScO1`=0nmZ69bn>?Y=-dwAXFuyk4@_1=rel( zt#KV02*jD$w~#{&HjK@_G}PTew&kTAw}7opL&;ZBJ8 zaxlq{p9VMq7)X+hL2n|D;1pSqH}1A7Ss6eU5HBy?-R548K>E~mh{+TOjK3cK2#WBJ3tdgsrDg1|u; zCWiVPv3bL4^ohm?T&_=Ynk-etem#8uwxoyMh;7-Q$6~r}j8ve;I-N0>45pPbWpQpY z(g98Ibv&*gE~#UA6|xrlK*)*_#vhJ~rY@{5NTu{DD$cG;J%{XDMe2WHnT_cO>R;G>)%AN?S#G}r0Ww%6S&wtkzs8H@oZLI>>aOW(497nyW9mTWN@PbzG2pt9!l-?s>JKj zB0O2O2)M3e^tX*FO?GOUgjJ|C`D+ewbS+o+ylxBs`_wf&4AV>06-?{hHZe2*x(6&@ z?(F2W1(Lm>&YA6K5?9$ke%Y0!QS8>P)m{z5yg@xGnWEVbwE#n8;Bt!49Dyc-$|aVLCR3#{-$0+&& zT8sRI1;b*MiUx2VFKq&$?9 zsF1};Q(6nsxs}*Ka%P$%m+*^X>LarEil^GC;sqr`@lAq!7LtU<8e^fwhf{$kQ9v4U zXEH~yr5U-5#m8&rWU{oL;B&aA?d#JhxX^Ec7x5)%E9gT5p?&dl4l&VJZ?hquz5C7) zg)>H3!e&!Er%z5bEEj8Vjijm0;(dIo#lEng#gVR_fzaNE``~C>cOUEHfbyC4bf>r9 zd%E9wtYPQ0+e*FU+x;AabI|O62})Ip)FpUM76u#6WvJTk#Dk} zxj=cCAwyg(E1Z)_?q=&F|m;LkB^#see~W3Lt{af%^~H zLU|LQ3E`HlQxPxIKDx?q$D;rtkEgl7PzDnEg>r38L9$1b1^Cvh*QM2CB5YfAMSmDm zp|1}H0}y_=3>r;h59xb^Ab{`cr)jD|tys&NHv&RVg}QMWd>CektNky%L)8&}+t%*m z=(lb4oxH^j)xOefa?`&nMwN3)K)TX#sx_Nh3B?;j`NUPEPp;B))I5v3y#ZXMm3-F) z4Y}9!G~acxb``S*u>==qrBVyPDzxP=&<1y=*>759^AX6$ZFfG9t1~bNvYc~1$|Zt= z)8XaOi$qI z7s8Pja%Ldb4fq>rUW)fTgi$i{F$@MKbQ+HR#VCPA&1(oQSN=6BMG4DCONHr_U~Mu` z;yqZ?oKkTb-dM3%LuVNT*XSQ-=Naf9Pn`bIe!Aa#41e{H?Jnvct2>}5gAl=?eZ4tt zrLQ-nuk`gsHI}~Kl+MzJwl=D^^z~}R<^Qx@-%r~x5PtVxVe!;zr9&M^@Bk8{0Y$1P z8in_)$(l%MsAv$|f6smQ!*Lj^kYKNo`tGPCp@IUx$@HuwKflH6k;@GHUQN=NYXeQK02va7dQ4?iM{n47xs5 zQ7^MKCHa2*Lk{%t%NAB?oH4w7^#pv+tFGlk08&OE%z zotrYo!~O`BwPBd}W>fzWz50ueJZzF~9kW(3Y63q%d(Lo8RBDUa$Xtp;`oc3`6*n)q1TS zU!_J%x-XkVHnoC`n;cLy&1~D}+ua#*YkdyN%0^BH>d>G1vO0o+;rh+~%{r=!Vy{OP zEYQtP4&E~dgV z6%{d@Uf)V|BWD*?#q$WP-PEu~&JS%64WkhBr(TgA)RyarfgP~^3jhEB|Nq2Y%Wi`( z5WM>Mx?WOG>a*9hy!{4!$YMhMG zyTM(YCF-TYlTs4~Om4bC(~{yL_a-PM>!-(TrKbVB-qS_Fu)TBjIN1ntLJAfc@wNxD zdeLDQHN==+XNmW%&hWI~&wod=3LJW3fn%TEj)m0z8n*2;b9T-RID4HlX7^RqPqKn^ z36nr(CdB(^{qc-1BvQs*O1chi}g8(XXu(d#mVzJa|h1Aa@ zEpmWP1Qu&H1Iew5i2_I!e-rAH))lfZ^TLLKySthb`Ij>C#R)lcIKIDd^Km!!t!@52 zg{cV-er=;+i&*B!B86_T23;t1PX|O-`Yhv1W3PUjx3?-=7ZH|FrN7408H`9`O+)6J zDK)4s4P2G-vVqTg-SjTVP;MbHPf`&DQlmVAL-F00960v|U?I<5m!U z_ph+_p`}&Aa_MEYTdIZyR*_hW3e~Dlm5J?QVUoypVDs-g-#0VIc4CSU>OQbZd^zXL znKSo`EGBs(M*MhpUvy8XVOq`T%c8nVD&o;M!RVG@A5(NuF6Fi`1JJcS%HLtuOmxSS0a==EQ+AA!GEcZ3kY(xYbar65o5HQ1#8cQ zurnG9BvNHG4Sj`{rp%`kf;}m%7Jv|s$FMa@CT=pV!=kza-+uZao4}+b*PsNN9lc4_ zMV5dy;XSk`P5%Bql!y&VvxZanFdLDBI^H%xnMt?J$|5CPZY-gR$fhdI9o&9?7kTr-;*@k7-)RI1sU#6fQo=btXm zbvS$qFCP9kJX|ODVPLq!-f&^G=LdUoG|#$X9iG*5KJVus{fgr-48NBk;Y)PaE|MN@ zBB?MNc@WhgoFnej;oP(Fe}ikhfACXiYLCdrYm1tCddS^2#8DW;Kl7tE z@-xHt+Q5dxQG6I*AV3rr=!3nzcVVeIh+wpb!O@77ZkNvhSx3;CHI4D~hfy1)c}p`A zx~nT^wh~*6q7oGQZO)o!yuBk!2?If3tjSVsd(3Zuk{>YHJ$A|5AGIAbf9BtJ3Y9C5 zw><;-HghI|uPrEKBPu$t^L|9M|3IjB+F=MIs@4opt~;GI*^O?w_D+u8PSY*t)>qSd z73A)=)PvT-3?2)blT3^#w3H3ggkk4wMLb!6C@4rtJKEQF;zxT*`Y!)CoqRq%KlR`j z57e(~CNa-xb>P-E2kxT$$yKnT}kvyU!9A zeBd5`pzIZC-miHy!iL_jG%@_X&PsscMt7zc$y!@`*J)#6wJJ$@MCWij*ipBptxq%x zM~^j0IqSL$HRJI%bJGP#n<2Rtd(%dVh!YgD0Q(CZ zjV3PlrW@hLS+V4y!#otd)ClTCi0niT^lIk0aKYUWwpl3IBaPV`uoMz6UTwY2PGr`A>B5NC5WU-h)l3d#|Yt+4O^^}vRRLbgQXvz z)!b1*mXWS1<7}Z-sH}x*OFIP+Ijijpx2rq}V_D%TfJQW2iU>qQvh!i&Mma-{!K&Xk&>9fZbn#g1m^fjIYVoAaZ@NjHH zC9f_JZezPl*q|(;zsIYVg@*f6To^fXi~1}<;P)2n#Vx9-x~g3G3W=`+YjIw;7Tt}< z&KE;MtX;NUs@0k1m8@fI^uc7eXmjbtO+fB4tw04+P;1m?p*GC@wpew}x*RX@j?yl`^16-S#8EJD zN3GMv#^gxBA{yC~ATBYN1m<6MxJLBtxW4D5+?d$E7fZaul_K(I{Suz_O?p^4| z#iop@SasX`-M-Lis5hOnoUnk+fZ#FkwDrugifJ!fpmMI!6pb*gNK@y)@v#mDTB$(Q z+?rs!Jx<7xQ8F8Glj*V!rpE4;hA?lZojr<;h@7^Gk(Zgw3w@6UQnhu|F`;%z4cs$9 zppQ(TH(jb-6-{!!3in6^DwBlLh%w^1qV4tSEPKmp8xW?jV&-eosqknNfZdn}2_-Yx zPjj9PZ|6sxlK5JXesCW}9I6`HLfO9*#~R@#p>(5$qKpu|d`1e>c^{DMIGNpbf7{r@ zxW9+d%l2@xH73o7I9l2hJ^m3iJgq$jWn(tp8OrZIu-k_y?lq{ikcgJ2sz&n!_mEf5 zgb-z8c=@&VHu#+IU#onf96yQGI$?)n%ShfUy9;XTK1=1u7JEo*dZFnLIpr_p=$WMI z;x3#p3HYPj@d(k;=sMph%$@tH0Z-hy9lWWy=eBG4I%G`b(X#lOl|q;Oxn%+$VkqL{ zPo`CZ03(DUswka;lZ5p|cHKtwNS=Ykgc{qLtxRw=%5A7-3CCHG+6G3dy@>_3I2BpL zJ^B{_0RR7_UCEByMi9OCR}eYb0LQT7TMhvx9xn>KOkz2)bK?wUTZy)al7sns*L$^e zHz~yda-0##UaGpg>eZ`ieecw#)AZ9+ElQVO8x2e~IsaLTlnPbQ48lr=;0_*l+>yJR zfoKU&68&$)C%XOKxtKC;5y&B_@gv8>9y!mfLxwD)L*+?oehZl+?o1T@5jXg9qf&Ft znm&Z{uktL=6vD0`x^?UAQIy3NdY%cF4Zd}LN$`4K7Rj+^-t0OVgWH06U6tgAQYI7< z`c?K<;TA`!8a-<3%K5k7{b=RqnW~ww1ev^?IpnqTENS|?4i5b_1WF48zYqW5{{hF;9emfCbJ+tl0J z{c?Ax`g48ttmseWc7HyuK~^d>sGy!u%%x%!ij(I%H-kIp^C0qcJSm%J%+de)`MP)o zS8!7wCQTrGi?xc=)qhhPPrWf{ypq-WrPh|0X_l2xzK5;5u^UXbu!+t~GM$kmU0ebh z3^|H?Ye3aSPcRf4bpN`sV$IKSu4F*C}TS3TjO3 zA|8%OXWiUnMqtI@8DJU62OEZ{%+tf)B4XW`z~~sVI;CubhVvY6Ox$O2`(D5f#_!y7 z^?>Puk`RN$2%Oi+ELuP&s>&JK7*}R+ge5uhA`&(aKfsrmyxt zTmS9aAZ$)571Zki@Bk(H<`K2L5-Uf}@HK20=FFJ>nNPq4n+R@&Yj+wHEJqg1A8#g=&1i~dVD+Q07i}u1 zNc(m10dXUa!vm)q%tIb%sNvfz@uLkcK_bL5)EEm+a<|#sKON3Y0%nOj6E5okR|Cg| zn2K_qSTMzDX%Js*8HF=c0Ik10{q?8I`RrBm0d4x#*yvser+;r{tbSa<>}<;vhudNm<2CSNIjIVA>;R$^=vZ zsi^BSY!Sm!tvV4~D@Z@aAxy#RhExy*qfTyb6btv=Y`&+VQpb#A5@|Art8h@ zb@R)+%h&VS{6p@I4c$)8uwrbO_hObX8t8oI_~LqP1!2EvC`8}-LR@lmz_ph8rMHff zJ}jo|qlXW3NxuU89I1PlHx*J6^Do=dYC9}^4OvgMBW@<|aVrk5%3kT(4y(#8EEpF0 z^~A6La0;%m3N-jZzpi~BV>t34ZJ`_azdnaZmn~%!R+)rCX1K1 z?xvd|qnyZ%1t&|KcpK+Y#TCLi`~$sFmW~OA|z~3 zeJy5rK$bo|B1Tqa=hbuqH&Q0UvC74~MTj+1b=sIv=(Rw2TBQ)gQNGVi2msbp`{oXA zqTU;*L&dnn;G3Mon^cIqxfj7Ka!<5w4lAXLrf(Eh-!H^VTIF-7JEVnf3TJ(}nE~q3 z4k3G*wZ+w1eVgqhdSSPRf-2*SCC5KetfVonbV2FSqKS8AT8wQ9&i|*S?s#i(Mn2PB zmj9aZXvJZ$jc+W;xgXyV5GH?N0K9s0HG4LDaygAZEpaEp$68BTZoDq6$S3nC~%LI z0{3nRqEbd?g$)Ho z;z2dfGN*bI@pw{cpxAnExrKRQbw!qjfR^Bg6@0g^j9p7k12GKU=M=L9DaSxa?2zCB zQ9DHybc#At5VvRi{7EKGDBG%<{2bfQezAu`PW@+UK*fNoWI%)` zE^{R=mztQfl3lh_a6>+^x3nI@3FvA;CeZ9+D=JU{q#)IJ3ocR??o5{IYFOItCUt9D zc5}Vp-;@5bZq$lfuO|)z_K!l@CKaSJU_yFfZW9^;(_zK=E)f=8V4F!7H}-ZKrgPO0 z3u0Z_LG$qtlp*?2E2B`9hDsa|PlD zy^q~i0%rAn@n@TKpPV8?xFan3iZrv;Z!D?a@hI&bNf!oPgPVFeZFkKJBsT|}u5Fm; zUC=cWUrlV-ew=r!!PfDd2aqgYk{fEUwE($b+TA$f8c5`dBu&vn8cA+mh7jo=K!B^O zzK@hS53P~s{)i1zeB5?Vu%NFnIjk=)zSTZs?L{*LwZLb3{+k95u8{P?Z(PM9ZJ4wK ze_^OdRsP_Gp7_JtU@GUu$aYp1+{?HcaD?WSsd>|yKWZMoBjlZwMUi@FB`u!I;KXYg zoRD!u;5UjeD-SVILC6KWQ7Ya~_zXa<#XY4YKP{tf8Nu1su+I||d0B+^decUFz3Zej zWNpc-I9@o@2a2ox0_qz28%e$h=w=S`sDKptSNhPHG-0bEOg?#>o2U+a6$tFhD1}ebeM~@rPPEY-Gv% zQ~}+7zh%8UZ@XSw;y5Ton8F*Cd&;!!daGc1ue!>>07u{E4>$9&y?W)Ol_z}NT1&T8 z#W=gTaGF&DpyJe^%pHTgZlTzK1S3JnR+r^cRT;(DXXBw>bLn)BI4y&TrH_r5ATvSE zf6Gx>uE3r%+@cre7Yi-)9#rrnKh}x)Pt@kGxHO4Vb}evX-fkT`U5etpl76HYhaP&9 zeR>v19D!=iC11M*eIpKz36_p0M+&XBdF?GL!9omxY0CvgZAoxmPJvS5-3kZvX)45{ z)gD>gr;gC>jeVgRPTjC_FKa;%8LFdL&Tx`8j)ZPv`7Trm!WhKfd4;vCe_T~eSp`F4 zf$<_=-Dtdm^Nj4UF+(a@91P)|&xOoQn(E~7d3A0H4BsB!>gT_V1}BeV!Q>rw*5au| z{xRnp*tP`qIYHTxhm8xRqC1mw>Gys&GY!xE=rzVE!Q(fFCzKR?`+oo9@xjUYU|f(H zD|4(03KFvl*g+_Af(Udggjj5Q?$e{+3aC7l21avU?b@Npp(Yt>4RTRWOS7#ciZE>5 zq#vYkk$nnvS9`#|7VZO%$dVFdJ7P28_>>WwTV+nPZ$o}Jbh7TZ9g8eZ{P6vqExr6b zgc)NHhTg5TwTE0={-PUFW(2DevW=9aANVFYRAfudm4TdDkdVHyV?%)S*6u)Ssak_J z{F13@*C7rxpe1}q@dO~hpC$cZ5Ch1g3ud#dDJL+!55hDmSBxCNRBx06q$a(XlQ|kv z@2VRu3mWSCqH{vF_Y$5;wIIZW_JIxEc;z2!zgdfJ{%gGTJ%TL1<#p+bxe>ON!L2TUS=!dXu1Kwwx+(aA01McgPlyPNKq)Cz98vE1S_1 zoD_!)6^!6j$a2?;xJz{ur9m>w%S#%WwV{&hi#&c#85z2sRLEBevGp^hdSkiwmHw9C25xO%~X0-;* z8py>~%b}W6$vTy6%ZL{c979<)LRlWb`&@bGvsnfY44cNicwMdg_HB0zCn91SDmpM$ zq`cq*TFBrt`e~?mws23;O&OQKd#jg1VvR9j4Bdw?mPga|`+9dpDvQ=Tzt7K4_fF1^ zu+N>v=xVVDJmnwJ|Y-*<+Mg!zL0A}6CFFwW1#H2$b#-VTBK!3oY zQ#82mxYes3RY5z++(Fq?q1$m6Ga3o=Xxd(bLT2@-QiO7}10YD%Ow z>e+_)D0{>zKu-`qOvwn)Z62@|>{E+-LtlW03K+UUeilbkFAVPVbg)lvvySlrvNhd? zMN%$B*u85oN#o%n?wOW(LQzwXke(#uY&f*Q&OnKk)Y8PO4DqV)r>~1S2=o)QA%0oe zDUUgBR#l@ge(Q1Zq@fIMDBYKheHed_Lir_N^!OKvJtm?x4C6K2BCzm6ygYaQ`sljh za&VcW9g<>4%YR`6Kn+$McV;2gT{ZUk}eT5^(@?9r03L66-kF3KGcEJdlSO5oI0GvLyS3$;XlZjE!1c)f9b{FP8$cxAm${HIH0K zkQ8>No3$8)6t)8`6Tr5JNHf(D(uG1E+e)3!tXeHOH%wLE0~+ltY4co3(mG=8-M>P$ z-IdEzte}H}b(CV95iceAcDadTEAF!sC1UV(W&lV9q$W1A%VxBA^YJ1#nbh@+urtwQlEGm0Y!HECJ{UFuHEt}DrT z{!1<$4BQirnf@a8&RQT0heO=3p$^$e(c!J^*OVg9^g~2N>(%K789i!plv5}D^ zjNwT_8^_I6qPLZV4EiGiWO`cYg58UaqmA9(bnfr(y!mD4Y%ec2N2rFdd5|qep!HV#l1wW{?0lrDBfk|tNEFjxi7Hmz9|(X>!FFgFlT+gsAC(xQ}(REzqu zP8>y6o#5h`yolvfa0^Mng*%w0wrlC2`GvNWBf(zs|pw>@ecHw zZ1Cnb7y;ZtJO&o`#`9Y*NNE#A#tBLQ6Tu)lmd4@4&eqFq?mYHI_Bu0pjntXxk-zI? zN}&$FW(K&D2mK7&kx^0mlV?DE`2`< zE+|v!#E;Fm19u5h%dv4^aiR2AKkmJKdvNmh z5+!DikT~GFA`Gn6^@$xFGDB;bv+6P=V%?FKPF@XX*7Hc$uLy&hgP2%II^rXcgwGX7 zJa6{a{&pO?xT1a}-0AD*^uP2UXgnwh%>QbrxDP41NERc7)e_V7B(FyU!Huy;)G2SK zjSVuQK4!8{3P)D1Ee)BEMdzFwH+x=bGdPapt{Y+vjQ`v#cAkh^<#0yY6#kxwuMF*E z)^-<5sg7f%v9y2uBMyW%H$EQEp6%u`FH#$cH97Pl{gUmW@@$aIS&CH7UK*d*SX4&I z-mKfNe%#&Nef=E&{v&_49>!2%7DPkcK4or9+)9)&b@2vlljsn}4RBMfP#Oed_bxh= zNj8O*emC`6?Wv8s&#hbOsPm+#grELQUVY_g)s)eiv{K^OR!I^?uuS4{wN-kIZ#A0S zh3s+0{9H90<_S5gwuRf2Bj*veZ~_5yj!@=*!^diu8yrdlM-8ENR0E~`A!!iQ(Y0AD zb_l1x*twn8q)Ypi{3HFpuhLHsmh&HycESVd7A!&WJ9R9&!W{ppT+8nlHu-PrXS~D` zIHGdV)yPU1mC&GRNE#a4#*VbH!)-VjjX(2@b=%;-yJlje@z>uCif%mE&&PE)UhYN< z=v_5kZ3qSa;`{Hv|G!b)h@Fjnr!GH9W8;r6;L2Pt$gf$)2Vw``)fe&1eYa?c!t+hj zuIZ8Ez2fVaFJ64T^Wqy4^!RwT_rIdJ;kxm+^InYGphw+6o2-xzN03JlW)q^xln%+k z7Y{*Z-Sg(q5v%(2bQAO)FDEj&bn2tEj+A&@V7q_!H`LX)b`5W)W-P~pro4&gWZYTb ziUFLgmR3-w@gwc*P7KV#Qv&1`k*w2^ADnVW3s)KuIngbrI)gV1#axvwLmURqeRbNH ze#@`^%S{ObR8m$Cyez+Q1eot-A$jQat7;K>xRBU4WflQmak`jk=}fZu9Z|S&K}@>i zgQV+;jwn$*cROfVOICGCH3hOXXv2k}@OZ++X{9qI86;qr;_{q+r^pX6Q6Ze&@cO^2 zRQrzMX`H@^=gT#*1d-4SMc|-Ht{M?6@0SwKoM4XYiWcthu;|VaB|z3Ky`*wPp4(6_MuhTk|+qJ8t*`eTwbf>Op!!B?kb`Ex~NtwVWiVV)PUV~ zg5*YYp{Z1*c)uB&-?q0A{K_iVAq!f&h3ZbJ1pLX(qb*s+t4mgdku=llGZ|BodA*B% z&h{(M7lBMtY-F>ViDorr7~)J{R%@X4Ib8Hq zB`vU59kw)+viDF6#E%v7#PkknZ-K^RO?-7Ot%d0VfLlkGXnf+#IPJdpmT5gtNSuaC zALrGQ)3I!)N_tAm1FkiE+(M^aT+-Mr{+$(v=C3mWTe@?E=G?dpTtF5xU-wwka+H^d zwn=fPBVE+oSsayjzKrOJ4Nh!xUQ)mjHHKV{dQnvl?TqXl!z^ZXYzHNig0j(M9>>Ru zOUm5F2R$}8U+X|>P53C$b(q$kEGk--Vb;u3`jULbYhweLSIH5xkFowrlqeXLP{YCo zWFi@*WBL}rw5)6B35AiC*8us2?u#U{62A%tl8|vptM(f>K#XrBb|jppdy;uZCy57u z%OQls1ThZuBzA%TGUC3-I}uMj@QLaI?2z>9{>1^n79k*P$g`QYnV z<+@m;@H9xBfz@vr0Y`2ZxZJU-4lg`B3J9IpB3ZM^-e6Y^wa*mhF{6%=+7t=0SY=3- z(`X<>g?%$KG&!T;38tvtT+Rk{y`s=_Z2zAd3f`vzB!h)NV%_oj+3*FQ94+vP%6si) znM9iecj$yRF_++f3Xs)uCo?;8tFN?WhBq&-Q(ac?ZUiOAO!;V;?5<=NVxE58t)A16 z++D*c>`OENQr27uv?#x%hG=T77x_&dhVF<@6$%t`M;xU2q!`J) z5cSBBp-`Q^Xo~_#@w&RfbFZJr{~?5MxP$a0de$cMo3nQPbsT!@Sp9X&zw_7ShWfmU zhaaWUS_~jVNs4m*Ii9;H)A-B^l(!YCEBY%~Elt7z>r*UpB-Fpe%YIiGPtjxEm1rE^ zr@iC(f1T56X>I+y^m=f_@@`e1wV2hb+2)4%IND(Ym1Ll(}IHdkIijU4uj{9`q)^vW8;39EM&a0h^az-}2mcE11fM_G~ zTH4128{i56Q351gf)Z)vxE*h+=5|q~HktcTdsPnzBA`)sWaEcuF_kFYxZZh}=PZ9*FX%Z>?3lQBxa<2|HTqm(KJe?M}nnuqL4LXvu5YS{sx5A^F2 zc*fOc85Gflc2&y8%zI<{C&k;tv-8u# zHy=?2Nk8k!G64izgWagxMr_d@F z(GwI}!^1msizE4&V3o&QJsnVx>#RnVO>w2tz-`OGszkTRgwD%# zNeVKzFmBrhSqJ2i;vj#nmNf&GGK={(Nl@s)sbr>bg&L&_pv{)O5wAm$4ww19G!NONTb2tQf=U4o?N78a_=u7cl4gR!3vHxB^AJll3m_x)kiL8_ z^6g0Akyhw{9coB`7mY*P3rKxG_{bsh2sz|}CfL9yvJ7k@2mk;8|NjD-4c?uPbW{|u z^#Qu73UVMl00030|BPKhZreZ%yzeV?YYyt6JvKmJ&|3@iEYxyi#EIOjmBPR8k~5@8 zSvGnMVo9sjF3BZ1Gj;lP(CL;k)!Sa$X95|MrYHG(eS+$8RmW1B&__T`6CU1->oLR3 z(@_d0LZSlXokLgRO}ClJn~8cZDGRaKut#LSG?1Ln0*cjmr?$I~JTnT7K#S9w=Xs@& zU5W$1+z@{so7C@d zkFN^btM~X&%jPm4YN`>D0wzlJBxr0QmwP?62%of7ue-?odt9(M(!e&T%hu7By9~h@ z3M-?xMDJtwJdP(ZQEgfIj_fTH3;@CF+k z8Ys=7rs4_e)6=CYUl6th%&3(a2g(_-*Kgne zwrc1TRb2fxcGTJ_Z!j=P_|^Xmh0XTCKO)BSmiR#iQ@C;^3_ud@ZReoG8?o?B>Su+B z6N_@OP{1d{R$7SUJW@oM18_%siiC_DZk_eKV8n+Tf#_mGq2a^l_t66mif3tWiiSs) zef}D^h+R{(wd#F(20+Qg@4UV_bib!bgyL0QWxp3iYnK7harDLjHNK;4lo0K8dF=hQY1qDz;wvkAF?Zo?B1l4wXOmu zHUJ-tbJb)Mr6@k#*Ptb*{*`vM2A)|$eQ*hxY_9SQX1LV>5ttWLasus1{BnwFA#2g1 zkGjz0^d=X-=IfAUsYawXddKjdQrhw1yC6@dPIytG^7LqF9YgPtUQkwC3&5NNZd*qh z(Kh0kc&PWn#h%HctO~T)*ME#%L2lbX47~FdI>vxepgH8yF9hft62nFW)K(xlNb~!M zLvlI0k`>==dA*XjVztAiij&g#ub?bWgwoI~ueuxxP$dYZwS|a^cWv-9A%kdk zSxBy6VT^t`{+20SLH|HgsJEf})O11m+WYlm+7p}6l$WmMm88*iedRSJBccov?dd8^ zNKjuF-8!Fp$#>u6O#gKA-Fk~ggZ~stUpf9)w?{v#oU|}hHizw|bL&itY6Clp9@AP{ zQY-zXyUh7Wnn)p$dr4s^Yss%%P!{;;LloZ|+0m|%?Gl#l>Q-dCGXA`dQ8>}+(n|=% z*OrB65vG5?y5sS`ujRDOMx&Wz*`}*{XSX>r&T$(X=P8%x>}INrv{<`^j35=zyg#Ye zwuK~phd#5p`ZboU@IM(^nUx15F&9|7(CGIiFA&Gq9Y1SEX^^U_G762iKI<*jq;f2c zD1GYQ>k{gggA^g`;Lsuf=VTZ?^nZ;Gtd+BW)>Vyhyys1epwN%w5lit&J8}2Q_vo?R zwb>QKt6Gs|3^HmDR9~&28WxuRO3+N@*fp=u3!@%z$(+vQVG#@!Jc2BcZ?wl4zl+)) z4{g%|u~TUQs{BxXx3S=*D`4Fyb+=!W2urD>%z4}au{Yvc5Hu4ZMdc;8%cQCMjpaPL zAn;1DbZ~|a>@Fg96-3}LjK)_4A!Xq}NPvM;#DvA!Hz4yH3)Cz9wp8K9|W<5)Et0X?Ni)b-}_3>o)4y2?c(ByRpbP1hx^qlg9ZnDtpft}ZgpNCTmtsd&1x4g-c@^m(`q zLKP-8u_p>j_ct18M(#&X$>z5K;C{?e@CCpqWpn53h-efes*)^teg&uOM%R#GX6c3! z@PnI=v$wiTv-`m?Qm1h$#m5KANa$xsUrsVeBOCR%<@jisYC!+_fs?k`T}NM^sBN&|%) z2c#(NFxY(aTJt(-UEJ0G*mdC`5^-DHmEVjFE4^PwnzCsc5$dM9#_Ad{FE57)o2jMN zs>M@|4H1@sBS{j5SE;9PUO=eCTiz57l3>33!}SeKl53#9u9H}oNsWd(wQ8S2mW}rJ zV31lV^dd@|k>73wobd3$G1XJ^?70NzYuACwNGxps>y=|foNb_m+#Nf&1Sl=z)rlaq zmZnZ-SiyPXv_JC8I!=74q?P#mD>?vTmubW|m%t4YURam32(5s^4Oky4p1f#QQC`zK zxkb8{TdY=JIPwZ_C+)z&fE#`P_U*z%*-TDSJ0E#O9dKyZ*2KGnA>+=p4}TEn<@Y-Hib9#c+{5mIm^Bhj_Ps;^P{5BMPiq+FbKtPoFCN3s>?6wGkS`y_N>e`;UNym4*O8|kdD~Lh!6F@H z(<7(R)6}J&a51u}3*3`R8R$oq$j3=2=v#JeV6L1*tla!B^`hH!O(V?=Kg(+uPRg91 z9F>nS@=xI`u0Bb|7Jw1+1Ou`FXR`8on6y|dOD9=9{oY!Hc*7KR21z5Q-|uoZKS=+N zs%>JD3d?PpntVy+*`glHpwl^ph96g?dZr<496~T>Ns6i@+LsffWK9M?CRWRn@|^{N zJ_%}7Rh#t(u~wf(JeXc^7wOw{w;0`b`Kxh31GNcYGY~Ba3dT#6X|5z32{vb^qw6IK&o7$O?u(#t$AQ0w zrYgZ8tHt$*A8jkhY6dL8?`x-o#jyJn&ZeYl-t(cUg6yh$J{B}o&i6?3STKIT{n-PN zOPF9N?k8{DfiYj&qsL+q&)qLnV$Rvi!`wfJrOr?NyT6S6NfI^+HB9HNX3&$+1pDu5 zFS6x?!kDUCK#_^R%5qq_{(`kRujUg{Ci)&RTt-i0)MA$b6g2W@_CvZ-X!s_$QK`v) zE}jV4&)?7p2wm09*zlzN3^12=^mDcbItJ3kkpE7ovO5dMGt^ z6pN!RWSenIb0lS)DA(LCeXG1>9-P3kr^D@uIe}wQ5<1n-=frR1|C0MMo~GXfkyhD| z$r3RYzH~dU6CkS^Z<94Ukzf>KmkzZPvV{UG#D2O}odE5Gn{I|*zqP!>hqT+(DBfSpXL zeUF!h@gN9r6Hn}fx~beDyP$L{-M)B#VB5LrU))`~uL*&WoR(V2GlZk}DRqb>>JYmR zszZb)NgE|CuNbj=S1}@OD@Hhn_TJ3eXYu(v0#DfhZs*?7pVuTxLT}2mRkxW(Wk4lFa{A|f+k!0 z*u*Bu-S*pA$%`2=hKWU;Uc(C_{o`;L7K3bUfQayM*6WF^tiz4bBbHC|$bCiaesC%c z{{R30|NoR-U2cOg41VVnyls`LU0^5JF=!h~Ck7J*P27I=XFG8M?Xnu+_5k3jS0M=l6)hoHKiVhi|9I+<*@P+ML)I}<}s5a$seKfV?y%y^=$(4 z?J|K-mFGl5p`7tjM`(}Eo;oR*P;3Wk$y;6Jk)^UZD)AdwE$D1@Ly1bw30zfFN#*;{ zmycF+XU4Jte{eSbFpaml{#-6sGwI{vV}b&SdPH>_T7IDlc9OY|n8_fh*pUAR0Y;_; zRi2^beM z8sY3Y#Azh7yppTmqid5WkEWnL`7+L!RJu6>WINkt2*M2z6gw?7SA~3U<+r0TmuA#~ zdKB4!yG&~|n@;3>*2d?9XlwuvFFC@uHY$lkm9ih`yqGNtWfar6HvPN`OW1|`mb?l_ zT|k(iuiuT4PoX%MSfhY!cRVt;ak>w=MKK!V+L)^5@nE1<+2cj#A9uU`3W(FVMmJJe zwi7RB5rc_UHm^f+&$utdfnAsPf~i~ePti5F^f5&<&zoti#P z@WKDQm-GWjO@OKXtb~5uy#PoW!9{JQ3G6-40Ur&vyn}qCu3B^%$B|3}dV90^a;8_o zz^qc)&j)DIbj1`gDSJ=68K5*2Bq4IMPP2_?{B{(OHKk@HuC`M)oMvCb@w@29A(nOko&~F5u_mw-5Ssz&}R6Dto{Y51n0t&IfGA4>JDSRkO7x= zA!#K-V5bq;MZzaj>z;I(}h!i)%r~`=ugG`e}9SDK9uSE z>!yEZ`3u$|ta=Ju)7yJe9W)!s2*{xKVqZi5hRsPj$ywhqbyv1UIUspsCMVoDYVC-c z3v+i*tvv?ZtA8aX;TpuT`OB~v*PH!Qj1S%I+eg8l;fw#1(g_@EH&6_?^BKT-lnDBb{uE4o;h@!*I@Y`PtOLOU_hS#!t0d`}6&wtw2- z3f%J15nTb>7_i0ov)#AO2!r(A8M_L~r{v}M z0{%Y6ypo4fe9-ITV*vVA2}F&8N94GPMecaBdCbDBr?xO%V|6>Xx^z=-{7Mg`fHQsO ztwpN9Vs8Aoo#1!g;ulq|u8jAlYFC6|l2ia+)%1V+r$zSmC9=7;Ez~w$X|r5Hnjrn$}#;n{eP zwbWI%&r~2LZ7)$Jx~jwhdwbErkPavYR%6aV`B0u9Z57nu%0c@uNqf35p(5~$K^In_ zRkdE2731iv6l)7K8-aFmB>|}p%4()HieZYsrfxw;Kqd-jX=WDY+%}0GP}AqOvfh*v z-7Ib4@E`Dd&_tN-61t~~8Wz<>hZ6}ukV>?H8O0h<6?xV)E=g3kDyRvxEz2~{=#Qc8 zeHGMY-H^V`Olvgt82+AGq}=ni0(sHuGDXpOSZVkLmVn+g9jrZ9@uZ**(BgJ}7MB;w zS)CbIBB7{sICKhHu0e!YC8^smAx(YO!cwp&6Vd_g&Q#MCbD2G?G@ZCPOvTi~XJ&Tk zXz_77upAmEGJzjq4NBxFeu79zbr6F|xTp->UirbcrQ;udxWa9=0{f>7?!^I)Uk*uu z8suyxouU0EsNUijmUEL4*S2pe1Jw&Q8d-jXr#cY42%yTt+i26Li`XVGFfg2Qjtv}g z)dzridc>vM1KZemK8zk%_V9V|U3HSO+dS?j$J|bzU?HBQxWq9NE;KYjjIgzMp$DTZ zrl$2H2tayGP}}t_Uc%5mh^3#x$K=Gr&QWNic+)Aim>&0`TmqP@2z+TLPH?zYgz%dj zw1TRlIs~DZgCgE^h-ujbOEg*`84(j-Vqbc?rcv4kd&C09tvKT_V;ZfGpP$k-5d{+J z09Buc(L4qS65>>m2R{v#$eQD)8L*MCPMAJP9pENAOie}=qJ2W2JCG*y@1s z95XufV01K_2Ly_QDmYD5u~_3&jm4cjoy3Mu1+QAnDUKb`}hJA-KyX9H#>}NHqY;1ppZ3M^5quvhq;5$N7WT}o%Fi!lv7W&<*ULz70DsvkdjGpvS07Zg z2(8>=AMH0-g5uGBO*i{(8Es;UgHF?j^)j$$?~f2W5w7JxcAwy6QRWB4GA%d+xIakj z9dt7nD~=zqkK_Gv4ew=|7nk<7foJ!{V)6OSAjhz?6R+6RZ?&$Mt_l}l-QD6>;)U>l-TIy$D{ z{I984PWWK%P0eiBwCc!jk2Ga+u}Vyz*MMu02FkpgszqXems7Ra?E+Jg0Zl78m8NBt zre*lOJDH|waT+d!X;}x;GLb`h62r8J8r0@z+4K2X_yDFO0AXZUEwFVuNE}ETl$BO{ z{#6H*WkXDs=*4tl2GLj(1S{h=QV$gCs{46VEQFbhI@}CKWZTvG9Ie=bRB<83p|tD( zN(=4ftS>VSs6rwp6)0lW*oGl_L58L&Vno%09V6A;~vFTmAmI~zousO;-nTB(5 zWEPbO=A}=aMwF>q-})gY7oymz3+V|bh3IUq?djZoN270;IJy&SM`mK|InM>))GSui z#P9^#OWkPACJ9aof}%~7K;WgM4-;$3a&0zEDK(BbLn*hGHCS7Mj~P^gJ>^-$Wjl=r zu>Au70RR8IolSBZHxPyQI0bi+s_0dYplnj*IIeOo07*l6O61U`;g6lu2i>nb5z6k=;O+YgR%?^?`hBC6KYC$+v@YnEt6%Bv)4SfCA)7M;Tu4b-~cJWa|S zz$~#H4-eM81_sLx%+731IS`hJgU@Ke!n4m0EbpSmb2h5ZL|1pniC~mhq7eyKvlQcF zT$&*4Sw^a9n!s#hcmQylbwVn$_}Ql={vRr#Y_sqg z?ct#T8=b~0|E1$clfJ*}bz%9_y9O4&1u5}@SO3@2-64=|`Re@|_Y&Xp*oi;=&~Mxu z@;Fa{Fz{hNz6vGfN{tqAnjwcv%;B~+LrE>#VU#8=Z@3ym&9AG^Hf%my*0Xptr4aKj zwD?n#3&#pCOMT7sV)GNG7n|w^VRX!3y}|>I8dtd-6Ih-&!Ag@XI7ro2Dt_CQJW)CyYdCg081&SbrQs7pO$pDm9m?GD zlQHlBT`H}0-s^Hj;crjO>Q`1ij=}FFd>NSvR%Zpfn1Tgf)L*e?Lqe&Ze16j*<2?C& z*^ml<-Vj&qE>1+Js+#Q)v#jVG4o&|#g@O;X%L}*Ez_O{c|8Cj*pH;} zwORnHc1C3?2nxaBV@vs#0Yb3Nqv$)A^G7j?<`+_7GqAru+tY#wsrziR&xEO&3GXQP z;Q33O7EAtWgDPM0xF=9S7k)eIg|!6yTWWcu*@jm$31g6~_6^Q0S35@L3Ym#41oDT{ z8H>JKaOt6>g9*Nbi%l`T6eJHM147tD<)bY6URIndG+`P}V8iM6N{CJZKV=|FzMKuL zCr?q@DvtE2{@cZw2X5*?>I=(xg3ZB4O;A4J?AYI_BVNSsC#;*zR}Cgx>{rZEhMZczRV5KVjTeXw1LlF+{A`peCI-JcM09Od*Ae+&!s) zV=y#%%AFdBR4?_lv#HBCT;HSeB!Y#}Cst+(5fygHfJ(u3GnRvICNANcC`iibyhWaG zn$*#%(s7O>srWEx{yw^AW?Q*v{xuH~w%GU@&HsbJjs4Z1l_b-7L`^?54r3{T;6(w% zzA?prG3&(5?`-1!2SelIt;W<3j84hqM~PAsEf^y;E^C#^%cRa+{KBlI&$8jOW%H}I zqLA&qusk^Lq6vfOgy)P3MlnO9t&>^O*jg{5t~;1^N<-+3ZIhIHBCYo67YGBqMyD>h zoeUpqcE@3`2%zFYI>@`dKX>^a``LEjV$A}=00&8#Kc8On3zm~Vgv(HdqQMf7S9pf0 zQYQ~w${*<0Q~0{h6p!~CDGVjFPi+ozu;J{{Po;4e|BK35SDchvTMj7gLMy7Csyc;k zQ;VgGiWOb88iv$C(LB~Q-Mx4fHm#afoAdp&b@w!dS!^UG)y%fCCej^Q7T21f${*?| z@IHPY8vZY)u$9TFV-)LeafWuu`A?MrJgf==DI)|<)0i`#Bw!Ltl6bEs6Cc`!l;Yl`wZd|QLk za>VzKDIXwjCZcpcKYG)&oTt&Jb?Bkv#-i00030|HNHQZ`(!?z3;EkEjAznage46d&|NHLD zyqTR{E^RfJp7LQ!_aPmb+U&l@u_L+AhiKOhogRjw z?OWo?=^NA@cg`E-$F{VPrcumAh-{Puz;A|VyY7-qg?9;J#9K6SR~oe#+m9cs`^Z{= z@rIgY{_nJ^!pV2?KZ$<6mypV_r$|FW*OtB1yKdCnuRdS9!{|Up--D7$T$ecR(V`vl zqJdhRX_Trm>`9MqVX}6?N4{Q{t{|=PD(v{CB|4Ng;}F1-w{*&N5(T6$FUJ=z`F;OA zhW*5}=NUJsw%KgZ*QdRyiQ9{lr#7X&W3M3ZHQ_L>M$q&i5|Qvbd$}QFwh`JBa_*Nw zgHg9&j)Q|&L@@}7tVGp{C<{!D#b5|s7E7yZ=qd7&Mp$irQJUe9kx?o=2cAQDXs2vbt7+#= zix?Zxon?M5Q08!0kb!k>thM+0Ed^#G3K}QgV2IAR-lc-m-%@arB*9lXz@KTNKE*rj z>Xu*o1i9)zvg7%s&lZ!eT|w!##1_#eiKBf=?#IP>SnvC7|43I(jCC8XD5u$Si7cXp zSsk}4>5#5aIB=j99ky%3CI9pL-Cxd}j8s>lZrvDW3(v*7w~OE6gm5$E^~aANm~KcL zMLB`3TSm98@{3UBG@A^R+H?#Pa(JjzlC8+?=n^dvG#w0+mI8ABT`=(RNZfDYjxHaT z&D=ttx-fE0&Vle7TV_Z zSCQP5b)Jzw#V!73sHmQXb5&0lRn^mQmg?z?$+(-~q)plCYnw?X3pr6WCGrT$->4IF zvdUSD%mA^O9n_77ar!mal%tuLe*w&2E}UBQpm2u=g?CC6VXs1oG_fx?9L z9e-y=Ae&sjH0*A84OIb;5S@3=Y&uo_R0HkQH{YM?3&N-VmZ2bOyRb$x--Pz+?M=|f?bPCuP7& zU|zvh9b>*>paCf6-z5esVYIoK^VH2_h24g$cSj3xu(vUh#tPIR&jSt#e{4dHKa z0N6%Fi?Z|&GxIb`C+fZspg=;^1mzFiI>O?VQ7hS2_}RqcGhaH2<7R6n9=H^6!fg5I zhNcC%tL$2Sf%c0 z!lD6DRG#n>zJeG7pvQ$Bt_&BHIY>}g_ur7SoNh*|`G}iB#MoQ9cdTx}`n?oDXM&B3 z*903g39G$vfk0u>a;lq^2?pqNsa8d*?FyGt0);B^k_lOxIrK#@o_lvjV>BV3u=uFkmTVX0rK z3T=0`<$!WMsS;teA^_jW@gvYuAwMPg=l~X<%9UC z>o2_;<})EI$T~ipZfN!KFNk&;J(s+JDtb(e;V{{y%lTa`7|9@qmdV#Ri6xu+0=h6Q z1iYmdo$@`;V4#J`8iJc@m7_`7a(ACfc)r;Sp&&CIS~huzPUjEHdHInI&9kULm89+U zvk<-(3Vn?YY#mL;F#FLZI&kO>1CpNNazzVga4WFQr$TRT=&kM@l(rQeR4G;*&OH!E zP8L3O-QjBNujo&~t{H;SPi&C3eq+*Q9E-7fl*RPwrT|7%5`*!BBH7BPsZ&LIEp{sa z!y7`#Yzluu&DV9bVfosO2?6BEVMd(w0{*Z0+vQTT`|i4 z7XSeN|H?#O{)4U*w6zK5R!DTER)D4hz_lGX;TM4C6u4l!hLDI@4WYCON!Qcq6 z<40`d2^9>pV8-M9_1ov#r&}$1lBc-ez8#dKC!`;fH8V8t#S|tYo*OK|DVBj_%jT66WxsTSL;J z6QjF$Osnp5j@2OfzgcN$@LTYjX?IH+xCF2iJf!^xqG+9b_ z>q=f_b|~Xj9&Hdcly#v|7cDweZzhbnxj2L517W^Cch4sz?`9j;kqeDLnX_y}G;ZM$ zZ(aW{Z!!Omfz|`oCG|T7>&T#rppWr<9aDr3?KhxdIA!FsG!BFj9|z1wd=bK2?^rm& z*pdF%q)|@ECelg^)uJxDGC8pljW~h{6#{1iunt!rKalR1c6N21fT(OQjKeiF0DbJ> z$|aAG9cLdWE!aHMtmgd za8pExuSY9bMnMpGpTKt6 z^#!xF$c*kN<;c$V;2mrZ1-)`89VGjIw$z6HhXNuaMpdJRrOw66e9K!fKn zyKy$KR(J@7fGvQIIR&+U;b!>Xfxjr)2v{`@nx+ux=Iowga}GR^PFOrx?KvJevJ$Yh zgDGFfNnx50$^aT2@Xd3s@z(~Y=NFUuchOBwdLKnPn`r2Sis%7a6XDX(t^}Tw4eUQ1 zm=`R0Jemlm&X5X@@KbX=naFH&86?F~@TNu4UJjW+dyp#<{vz6IFb|e2#p>|p-ZkzX zwydtcCvbd%0z7yJ2|7vW%OK8zMY;H?!$y?htK_V*HHjm1e0#M)uKj5jApt{w4EarO z-caMp;!5BIKSrHK>AUP)Zk|akn6SbW-hgV8)6-|w91Hs`^_EIeTyy3-e77FEV(6J# z&CSX@d#U@#cK9t^1E8hwG)ypeDdq+5dDJXgV>?3AP#9{1KJ4sY2oH)e( z<#LX(i-@Nx*slt5sHJRTObHN`a~~t+%mqIP*ISW4Dt7EDC;t}?dA^}(dO9q{1KXy@ zf2i$q`oO|G5G@lzA|R4Wf!9>g69K)g?Px5A++`G&YTR>koZC`m!`9eW6VA07oI;1P zDJQ=pzc8F=sQvw52sT=%-}|wnA;*I_)`)V9G~G9%#>mh*Tgg=-ip3Aa6BEB88&bNI zV=@u49r@?zoeDoVX?G4t>Kb!9aUQA^E>@U*wNH0iDP|dC@~L}HK#?nB?5gFqH9Xn; zGt|))kKz~VHwY6)sTuAxhb{d566r0mm~3o5S)I&KA`>{rl9|k?`nq>jeT%HBuYH?S zhO@t@)*D?zv7v8)6FX7+3hbY01z1O+9f+u{P?Re=%zm^nmrH|XLze)+n#8(^et*{F zd}jMv%Z3~WPp#TuDldj1DhzCp&wU<@T16yU+VCtle~oRc7BCN@s@B^lYeO)SnFvj+`~`_lRZFHe_EsZVmvl5#?RP zV(RtB=a7H&;JT4QW3q40gOBLa=7!pehZCnw!&7CHi=XT$I|ilr=6qJyoEl{#jN#mn znx{+&i0l-NErxvxLy{oHNk8Q zn^ih(SVnDN-6C^nq;&)Q~&NPeL1B_pI0q8oB5Jk|= zHkIy9M8+eYDGQ_?(jCv;E(DuTDpRe-xXPp&LVOVzci$*5UPJ=pI>^16+rOzF9xX4q z82MXlfsgkuet84QwqJ1q;z{)e^++11HG4zm+r1(4UG!wWk!~55WT_^_ZtcSK5d99m zGt%~sMtDGG+x<0}?YtBvawM_41HnY_&_brlz#`%to94*q%~aBgrAE$@wUG@Mu}xz3 z^?2+EL%iR0@*M=+k-gG?##49rM2pHY!Qmk|w38iEW&X7abD@hK+`$$>H7eWy@z0d}Bx8XJNxQYT1l2oa5p^Sn=vR zJ~kf3<+23ki`-yiK-XZ#F_=t3B*^hD&3Qh)>yrYYGM|PJvxya=H(T4?&d~!k3;CgT zkk;Nn>WftIg0h)Wp7~S47HEWm>A&$7l@8J|vewtYJc zy%jR;w=GQXx0*89mJk1T0Fp)V9i=*o$c#9QmEp)f#XfGd_#x_CX(ArNz7ahF;J$l% zwc?BpM&X}z*^3&P6bRM7RpTQ7KQ}G^MxKV`eC{$Xg@zS91UUSXJ!uO_83!sR+XMwM zzaz6?3e}dYP;29Pucjq~4zy78?kt1j$@z-xJ5rX3e77Y_hlQLLi3k4f;lyw=P_l06 zxgZ-QT6_wgm!aV~z0~8;Ajg?LDJ9?Ss1lVOd|dx?Yccwocu1;FkmJEg00s;VX%G#N zDvSOP)V?fE^T-P-OR8wFk{C864e;73Wb;>p(48Mp><1I(TbJ%A)mone82_tb8ZC?l z2!(pA)drx;#?{_L3{pG3&(NbX&Ih!>rbdxrq6AkCT;5v>FB7?|%yFY=xQD|WA$o=F z0Jn*>XgK;?r5``b%|vemqa$G_ES3ztrZ4pvOC(6G zkY^d&rDCVCO;t_5KnFhnkKL;hnq1Rl$kC~W$Qnk1;A1g2&@0+@6L@P+xH8ASL1+5b zc`()z(OaX%p~}Y~M-$I|3nGtCAF4W&-2Wg>4D}M1V#?Y5`{7?H4{SI{UiWj^V-QGm zgUD0=bq4e%k}f*jJRXByz~cbrkHB1nSfzJRNnPB-ue)*tN7+cT>EJO~neIqR@_0X_ zb`>_7rhJChm%|jOrMu(nx@uhZmYCs}F#_)ISDhz@`BHEN54;l^shOpibm&nFB~x)c z(oh7pp1>ZbbEJRgiG`LYs03utYPj4no_{NGZW!q)RL$tC1gDv=xX69*_zF>L9?Je>!I9T09_OZxaO2!WUHbjM?J=Z$He#piT?t_6UaZ&k% z|EX(MLtKN(?&l;Ua?{+-jSs0~RUk&~3z?CI-9J{{?f6HGJXV#5504!);J@#J1GE-? z?(8LF+$TfvVa{XF@jpx2DIl*Ui4XY7`jsXsoum!*8LxCS30Qw}NaZxwaHoBNh1*stcf?n2_|+ z^VI7CA;lAs9zw&3gWrP48K$@5+K&znDK8N}1Z2Bznub|``3!C%Cy zr_0n13T|gumdRG1p~G#DK$PLOUiM*B`^UidzD6Q=+G!+% zt58zjUF4Z?at3>dwfUWI`fLDC1)z0JTsLltq8}nL8%Mo0d8-$rhxnuRKtbvvGPO=| zid24i;4clj=kVaXAy6k~5Bozz);Few65?EP zv)Kz(p2|xx@H=x~PICm6Hu_@5YPx$Jw&H}$8VKo_EOdqEpgWvNHXWWhW=FQxuO=Y2 zLY&5Ve;8*}3C}(OckFvM6>SA0Fg+h6G{87KtKEA+p69D3!i)-_C@e2e)xK zXvr%$(R&Ul4=LBfKs&1@UK)ze*1jN55%D3>Ebz8Q=>Fc8O4?@F>dS zwjuQa9o`|}p+KlqD3j{7IIL*Rz82^)Ixj_D6WieOtGPdLBG{<)YOHyq2na{+&a9$G ziQC1iu;I;4sp5oz0kt+CI<-CtCiW}*HhNf;X9t$V}A@*UN*Qz)JbI>OAbdGj5!ZFMF(I8djX)jV8 zo}S6Ot2a9>PDY&7w$yC3WwG2w!ZfvC0g)H3&kZ%TlSa%#eye?q|IQ2BYd5RR8p_8; zMsliZ>!@bRJJXj&iaQ~t8g?a~o(kK0s>?mvvFN}K2_n>E*+ikPNS--*o_%pRP z8z+aygStS#!JS>=+yk*O*#hisgT9kX@OVh z9gIGXMF-6#M1kh-ug;oNr(Nuy+>^<+-e)3?#d#C%=PR11sN=!7(Lq_AJsu{4<+0XL6i)b&ZI0d$rkGAGI4ydL z?_ob=wW%C^x26Lt4m*MV&pE66tGt~hw+9RNPya9%9o=bzUZ&dOCA2?U^}ERQ zf|Eps`g0I4>wVs4%38AS|9#MFztM2bhrM?ox-64w+XaGiThPx#M54*obM1ryX>wgD&-* zugnjWLrUB}**4dTMg$23;uPWkCnmPrxDKcZgbNBc$-LY5)==)ib#e&QUGGuYdxGdT zM%O2HO3Q2ZOt8Wy*4nn-dbMR|l#e;ND2JVS~X&4O6!KiKtNw~^gs6(*@K zU%o>dw^i}Ph~zv7fN?oLI)5hifQ*dvS|lDjlWxK1=2z%bbGQyO6?W?DBo}Uk3yaOS z|AGFWEbxDf?3)~@*Q@{J@vYrFCv*)oQBCJ-E4is$m1f5ys9dlAbBH@wMl`Y)P{c@% zaQJ;)9fUwg`WK=mINLK28KHnQFaj_^0!9x0v|s+jlAU;^!#a(EDav;*j?|?W?h*hd zd=3Wtg7k4`-5lGK+aBqxK!$#@Z_sK2mm2oey`iaKG|y<9UAl{^z8c7`baY-e6l#l3 zSZO_(85m{{f?>@{CZE<12#?%}WOVQt^jYQkFZ2qsI;XHGlK$J>+A;kMVB{xRJAt_E zXy|~B*xg>Nkn;+D+)R9@;vj@eo_wK>-c;Gs*UC!tUZogqS?fa8+b-|(V7=gnBGxl^ zEI}8@s@Y!PUFXb5wy#2?I1-AfWn-kV#bQ*s!+q51JVR=(g%s#$!9F|_FZhaNU;7lO zRi4`H;paqU;2RC$*FmyngNT}{3+o4I>x^|he6r+VW1J1!`@Iodx)i;Q11bfwbM_W$D0yrP`_eM_ezEc@ z#_<@KX(^0nlmth?J$bnxfqV;}vnQmv*p@PhD|t z59k%`LLB0;4QuxL`_la?@L~Fcc(Hum+aGS5cMyWuzSogG%QT4-n)?^)j26N(g15IR z!m)$>YwslYp|^YQk*3!sYnS|}kTQ(~04?X!nZa>};~1@gzW`D|w@`~OihD>wfN`P3 zrM-2~S0SjdAs9s?hr;LU^Je&Z{?GZf>r-lsl=+TBY*t@14%Yy%0q~y^7WBX4J0VnZ zg#s11owGLrf_xh^U!| zN@(t>WDPC%b(KNZA};Fg9bqom&%t7RXulqZMvLQq*6VqT>A(VQG+^4Q0cbo~=)EX0 zCe@LU-DNX~WTWBi2q;At+htAU$UJ?iAq?MjXShk&{)X4^qmHb8D&FKBKa5xbo^nNp zOjkgDrocBep6T13n4?rQ2deTmZz%#q2iqaPWdn7V1w`d&Y09w+G^iw*-D64P#N)-B zABW`|=lZ4T%%iOIG5KU*Ps2$u3|Yg+QuEo0fjoO)~~v016;Fvy*@ zIF`P3AhsNH_v;?mJU1ywm{P{2Q3A13+;+K#mXw5%cfVlwWdU-=rxNUAp>qEq#<&J_ zQ88IaO4s&ylSuS8PCmH09UI)I-(#Tnu^;+-bVi;2C9fgl5)}dt7rHG`gL8RTE@68^ z8*&JhL>WCjV^Ms%93|>Uw$Xd*PolcYPKLJ8KwZ#&T=#FbLtc6@C%dt@I=}87qw0Tf z5Kwu+ZFts7ei|QAp?%2a=EeoLDO^ZM&F2UNt`Tm1K7XI@3fuqecp=33W^O}7<$XLl zB9$W~y0+(SnBTyny0)8i+5gS(Ly63MEfObc*igTn83W=L|3jBRPWHr7>S04iNeE;z zyrOHYP9C@L)+)Brr%(1&cj!@fI>X!-q+xMh%x8JeS;dUho*5qe1PW2dXq72s#$VOO zFdE@YKmP}GcPB?vK>X4o2%!T?Zo#-}2AsRQ_Vn%M>=FOI1XmCkb-*=Xp?u1EL|Nzk zgFAQK0gZVlw#RA{-8&x~YkZ{tNVs8O-rq={FcZd|8{_g+K+AN02qt>vz*XkAWx$q` zsJ5BP<#cC)JHu4(=6Mqf=IHGJMYR077?_upFoLb8z>0ib3j0uPn{+KV7xT9xn{mQW zy3~Vy0TF#xZifhMo=xcO)n;TC(o(sh3$0S+eJU4K!W2BR-o{Ido(jc*2THE+54VFq zn)YmjGCh^R--TtT1N8yeHqcN2M~Z7Ej^bc#aSQdQ*qRYiG=jM6GOi=F1V5UD909(e zw(B%L_p(#4?fcxc;_=mnL@d&aEdJZ^-)4(t%~w0hqROVw^?~t+0%h22R#KF| zo_q;biqxENV64d8uM`8m?$&1jMx*uUsy%6MCjTAOGGQD)M~MZ+kq3vNrgoMRwMh>S z)rHA;V>QdTE0xZM9;fURkNO(?KvuOw?lXqgja>UHKktx4?W6W7nVoM>5CYYO)*hz& zKuOs;z4tNQxNvnO`Ml5@i-&Y!PO+Vwt_%ZULz8lvb*k|-+&>{UHlf@|?zh{{8SB>w z)`!&C{Ow5O9Vrx2#}AQ5kf|Hg=YLp)th->sw5fRKE*?3J(tt2|l5Lt4)#0RGCBa1l zbPzS3oVjYN`9j_$LTI2a6d|>gvC3*UKBIC8agTMfxiqmbiTBZ=(UkT9rP zL6uKnhjEyivvdgS{CqkC6HUDGipUu0Zjjd5%t)tIMrU&5&k5V(Sj7Z0L*(%LkWH$o zm81F)S_ZiLC)5H7_oanoSjt@NctH)>e;iu^bt^60f2zo3Q({+i4rOo$0;sG0*J%>o zm$F+aM2)^Nc9DdHlL+D7nd-P$ZF=KZSM{{YW6oXPm2(>a7L%fdb4MRu%Z24L+~Dhy zUujfL&A64$bk>yTBQVN>rzwKt4Orq@ObgZI`HwuYY@Qw~=*G{x)MosAZ?`GQ|q!CUH2k-?ov1(RNc=bC8_z z5+dV`IwY9P7qe+TLF!tvGGE_`&jn;OYt4l{p#NLQUa!ya$ta=%Tti^!fHo{Wy7c@7 z2bi{gbhiIRDrBVDB!@ZRe`w_-(GnjTDQ3i8DWP`of$Y|ze(cYZiAp(6lM!yLF6IzR zlfEg&)YuoRd0oZ}pi(2EnaPq8pbZ5NRR`s+C46tV9W9*#ri5Lf*a+BV?vt1Bcg`)r z9V=~AqQQT~c6xrq<`fAbOjb3R_&RoREn5m;h4ZPZ;i zSv;t{kNwL$IpX!?Pq*sn)nVSAr5DbL^Q1&DzV=ltVE39{-XOqyU+mIXP3#diLV?1` zO>D6@pEU$fp_i|{>@oreOUR*cpNeu_xHMl7PSPB1SaZ~&4t@z2L)8}?p$>h_I-3r+ zR>cgLMv__t*xd(*s!Gt0PXsEVz<5+E-d`f3;3cvqJZ=(13={Sc{Cem1Rpbh@1)2=o zv;G>;zZ$|4B}+Qhx{}W2t1e<@%dn%p1z@G1Jtto)@F(sB#=_*Xob$8x`lOZa__7&K zd*PcL{rEBlIYH#g#40J2rbxbb;Ln{QA18cMMNftXvlMyqWxl)kM6e#9E&ldA3pil2 zXBr5LaI>j$vMy}g{L`6fJx)(``30sZt0%tsEdG8L#*}vXO?{##&9S zt?ARNMTcMwB2@pq2;Wf6{_}h$eD5;+i!KgfFz7+{zkwndvW7-42p@x++tMeCI17OZ zI++{ZS;3txZxh~xz!MVPys@Vj_XL4Q!n$kyS7zppH-_C?VJ_iw&ftlTmJ3!AK<(4FBbZ( zyrW$P_;Vq$I}@Y0W_x*keQ+P!#Tf|Qa=Gi*P=90Fc**~{ElGv1>E$(7vU}S+`tp)D zwpb#Lxk7ZC77Bd5Bl2VG{ka<%IUn1Xz8J&W_jVwllZgLFI*Y=JShI4`dF$2- zYZ{AQZFz#RmKq&`Yk_k2m|hj;2X9c@YtXNwT&_2*8VYBWn@Aev(J5q`o;5tx_Mm8B zZ*ZjG850tPIy=-IkcDWA_r{6GF;lZ$iBa)*`v(*nuAerAqd$v5k+B<<6LLT0ZFaEg zXa%ZHji%|T(hwOAx8YqWmfjj}#eRWC8BfFY4{lFD8T_)!!v2YQ>nTKb%4-{fx?kf zUIjETD=#F~5T~p!JPlG)L9dkzQ&$l*P$U^%al_oGJ@Cj^fhj=XVJA}_k9D8hdTJep z|92$?^oHUXS^s6G9{3V%JA(7Hq5d0N05j~H%N)71165*Vp>^1+Al1Y`TUb1zK0PQ}i6KOeqYg6|ons}xxG|eJ zRr{8~&-BTg5gSHlAvQH`=s@uH7P(|r-?M%==`II9J} zWbl5TuZt!9rspVX!J3au75jzm@c!%~Z$W2Mf62tkQPQa<%-C`e z!UWLxa$m8+z<4oSnZkD=O=I#4=6NzDUc!;NaU(@M)Hg14CZr(SC3{>*dQoHSr*-jO zO|FamzmI>pT88$~gN7ys_m`l;k^o_Sgh={;FnwNpUuLdPI(%Q-zZTisL)HeotG8MPchV`;p77QriJWRj?JZ(M>5`GNjVU={cdc8Up={@E|i z&9E!1jWKuOc*jP&M-zX5riyUQ9c<`qq1jI_T4Ns12ufMlDy$Y;1RPKhk@zuUY)H@* zGl2{~fStC2QO%4bB=6uDyypDho4Csy54L1QqOm5i7&_yLL~OBwOdQs9xb-3%oK1zI z23d-N~%O-NFD~2D@F(cJo+@>J+!7)$x1Qaio?1yhBR?4HJi35Be0p{}b?z{dRpRI}2 zL)YiN{f}m6a>JK7LPwF0F!xN^Z!_?pb$WKzk2>L5r-s>-uRBe;-LYPGup??E=H&Ph zMUjNWk>G9*t-^Mp9C^qQNamwIJ~Y$|YVCap=vYXex#51l&@D^P^`Rn{D8A8+ev!W6 z%?p;)T0~M($a1rbO&n66PgWGXtCOEh3A@fijGLTD7fM@?aJvMj(F*9}%fcQ~9G{`{ z6jMz0sah)yWQdR-w-M1u{_r24u+*2b#faAlNEdvmt7I?T>1oY&Fh!%zp`+)T*e;^( zdw9vJzPBwS*h(=sejb>XCW`T)kIDxS^!Lb3Ku3IatsxvPZSL4ir)zj7o zutfo1P|*-YkLnWrBxpbNbAN8Xe5;~jw)1px`?P-)G(Ex*Aik}?hKTQ*E{LE4zO{dv zU&Hart$}<#Ttc7c5BHQH=n$aX+T8x==pY6J+EmqJ!trz>-(!XVkowXu5`Z=*vc?1Q z=#bi1m#(@LEYrtB-~j0D3>VpUxQS_OAUdysKFmi(Ka z^A7`ex!^^Q4DF{ZLtTYyK-bs~xyXPA}e zLf&!g5_@RFp!!xw#FeH=8rEv*Bye-J^qYTMaY3sgrKa~#=54w6>qT2hMm3yv?G0!2 zRj$W6ly{u~Voh3jjr}s@Yev?z=N~CKTp4XjQ%lqz|2M}+5N)a~B9$4P8D!Y_0-+O* z;U785Lxha2_z;tons=8Su~U!CSG} zEA@!Cfky<8+!{{9C#rO1RQ4BI*e)YD$cSz?e_AkDjz2IrlIl?1WK&_FWj7-K_Vo7xW&eCwbcLY7;|H z7=K+ygenIoX&6rpC#$}d@hYMf4_tIqjz?1>Ce?0D-#xT9)JjMc0o%dBYj+3Kl7AGnZuc;|4vh`#m#_krHcDQX;nLmTBiu?Kr^{+{;Sks$j2ePVH|X)N;LB=d;4^ucbt2&fe>e4cTK4nWnUON4`*;V=shu5i-+)`971~ zNnxm%R!Ifxy!}RXwPQ51qaMGB9ogO@z11i09B*W5s3MOmHmHAiv!K2{@Fy9;OJ^i@ zdNYF2a5LlIWiK{JO^t&#rZssW?bd$t9P~VI9ZwxrPNyH?0Ng9+hJdji`Fo{mQ~$I` zSQK5ETg2Jp0@Rs|EGAD{51T%JyWHZiNmo7ZoWM5VtwJgk{fen8V+_hF`e8T!hNH06MtwJHtL&52nrzBo$6B#A~|(H$rJu+{-8g_8jy-ON4M- zu7`ipU zfD=g^2c0bFdEupJE^=<4;ux!}Z<%VSnUCGj^6I7%-b5;FBt7@D_$_xpu*UC5)m#Uc zdCwZ+Dbb=C!NS!MQ;Ga{m0}tovhpOb2z5wQ6%G*SOJw%}IZYFeA{Ux7g0-t1c#T|h zkNN2zylqLc4h5}VRU?c^ZKgB?2&-B{aZ7Ouj$X>JIprX~As3dRI*&Yx1i*DA=C zJ3UQ&1~9Jf9MRuI_-2COYi{?}oI2;{M(F;d2yKcj5=)Ykkqo@Mp6H)<;~gQ=kGG|% z&*Wf{<*wDh^7>kdX&Nc}!$ovA0rnAQy0h{0r+vJg3&uPnpD|X$y5vj?nk7B|mS-&C zz5#bI(m{F7HLQDi#Ca`@4}jG~(Uwk+?Y!Bz4j1KJtqyg7g#7}Q9Rkj)nj>!l1+PMx znvtQFOt$3s@6u@xm0%X;bF;&p0%B#f4qFg&IA2*}cP2@-z_f$DEn`!7Vl#CwqBD&o z#Yk`)r9|8$yP9LKo{1J$u^w>lAM#JKNNEYTk>U+cDB~KZoX(7h$W7YcCAp;RyQ<4z zp9^u-%+BxxwY~1dRg655QEYka9R$dZLl+M%hw%bc2q9Fd6fDK}wC z8xTd1o3Tc|{jZfVJI#X){S$XgHPMA-1#>Dn67~i=h{(4M?HIbj+T*nx1Gk76UEIIc;9E{M(ECr>@t2vmU^vPv6rIZ{NNL z@6ZgG19>rwdw9jhj;G7376~d>5rhWtNmd}vidn0%XTnM!;V@UvKKR=5`&#^c4_dWQD})Gmt_yJRUS7B=w}h`#%@Ib;=>DsaP>A!?qIwVxlue7Gd1#K znhv%h%qVL-y3D8-RABS>dHwCx+=?2+g)g)F;ZThvDR=E1%9CNeLG(07`B za+~wdBRYlAM+E*3d`nHHLiwPx-+{4-={~jfT_d^K^l@xpnC5#-Z{k7Hj{e3G$UXh< zUpdU-;V>EyWSYBQ@@kgZQhKgEF4(EGRjzKvCMH!+_5|3|N$e&W4KTOlpfH9nkLi8# zq1*!Dth(_PIdyc3S@jugzcbkfZkr$WzFR50&CC`P{hZyR05K7Fk`lz7_Kz9sTCXEb zu}z)C?WRKeI|3hT%MSkepsafcEpEDVenMH@bV(TwB|U5)b)tT!Jx+b>N25|-UTINf zs&zGT;S8vNM<5x#Ez3ueZU5kdF|&Fl^FYXIY*3RGBdS&oX3Q^X)?9lfZ#(uT#I=`X zJHY8v9zIOL1%|!HT#6z|xjg)3g_U^_Nyy8H58{0`#&$(k!I&+vITw@XK{w>lTf-_bz$%1c3g8s4lVw!+FfQg}?j*83P3j*bLlSV1^n z=ZQBlP=|A7uaTW#tp%G+-BoG$&T~;h{W#CIH9;1K3`9sNJFuwCeDW&n^{sw7pZ4X? zP@9Oj=TBXQ6JZG(0wX^o%?T*$B7IptK*yq>pY7j#A&y#eU5|{y4Ay&7tY%xrqKJJU zIx_xaJSL8$@QF)7L_NJiu-=tCQa*xR$_|y>9lh9hnBz>x*RnHdy07CRYH$E844!m% zk{N3)%vsw@>rScrk0!+LY}v0W%*XWnrAJufqX4H(UO;JdeI6v`XTyqN$a0zC*~ zsO_s~rq`<}Nakjil$Az~CU~%NEyzh`+qa$Vw{)GNi_!34LH9Qk(nVjUm$1qZ4>v)` zW)N7bi3awjT^QzX%aj&Tr0=za*rc3r;m-FYL0&NTGjh~+{sW*c!2Q8W*l=0Zndf3WZWo<_V<=T^;Vupob;#l-!x#ZYoB3?+2V%{?q-wy9ZK((8~u6->mu)O0;`D~(l=nW(id5ERld3m zcWm3W)5(n1>eKkvvHt;SZXR8b=aHC1bfH|38$PlHjMYu(6&gFxxgRP|BzGE+Y&n4o z9&%Bdfzho{QS`h<$}|Xv4N&MT<z6 zHN&5NlxQ*=r8HGZ5`|aG{~OQe|D{nm?C}^FbD#ReI-bHhi!n>d=B>B|T5gf71JWb- z5q7VBxaPn9$FilU zsz+SU&KzD-H>3GkkK|2nr=+N4+rr~&jAOsx_|h%_Y)P`!V= z!S!&sP@qyzdbX-qPXg)&uPS@HUU{Wr=YzQY@JY4!;-b7zXS0Dz7Io9@i{;(cj)wi} zlU(^IbBS<*a(5GwngLQaZf^vn4mpc9Z8*8BJNRn@mYaQ9S0s~WSt+e(qTtNGkgpFh z?-s?w)*%756p|qAM#klj8p}T#2cDux41T_C0ZtX>R(@$-XUE}gy!3UO{c+qEMv(SlbtgdCMF-w-2>2wTXjNsis47Pe+h>`aBLm@66IRQ2GI+f_Mwy zeLJ5+6bg2XkyHogR}LQ#W%Ulu?`=<)^m}pPv&?oT-r~7y7zun z2p_|!_S`d-LYmbC=W=A2igk$7cupV!lOJVA_ZLXyBQ1~R8e~%_hu0ovKmVrcW$RF) zAxV$oCp&U73-b3QPCz)yj+_hrCi+FT09i4NJDp1D)hI2_M(A z-O>?JcBTiH>L%V;2V!JoVS8r0g5~Ce(0FnY3`PO0lrsuTsC4oXv0}1?P=%b-C@Ff* zcsg>*Z_)715;lb|*XNGDQ@s~~+2wC*+u5es7vmnUD>t9rr)%fCU`X~ESyCe+`)6Ij zk8iW^DOHCp{(*U^2;z=1oapT^)$?}{WWvpgN~7GDy~ zZDd~{YzF=6ontD3%4z4dx7Xl-wt}8^+GZjxkZaf6KmF*dQQ|t?bHF?6UL5UFeiy6v zhDL8i0rqkNwJtup!_qXc@5g)vQK+TC#3D_as6mdRR;hDz$M|Z{2nI))St}>bQN>HI#0LJu zspshjk}sE!fSG=xxE{)m4>@tWYluXr(d2!Bd7RA%DSx$ThqDkO7ZeFpt9PQc@2>%3 z7jKO8y7#%$fdRQy+b68e;>ddzs2G=bBAYu|sY7cJGV8`7&VjsdR9JlBi1rfJyN)tAh?bGkC@RKk~_&5Xe&jhJMH1)pJ zv9M1d{oH3&0vL&4!buP(p z_bZw|qBzN(R;MX(Lo6N76Q|^iww(8sUaw(3Cu~jbU-TiejCl$jtu%>@`IxzmcUq@h zw1|jgej22uhd?frP0rbpoL6;P87Hd$p460ad&?Vv>gp>)X$c{jlvtq^eKH09f`2+5 zF-j>~Pu0`O|G-P?=owY;5X9pE|17v(i!0vZcUIFE%Gw0~W6gB8?(Et9x8jwp`9vDM z@RI;zB;(dpvO4f-hg3n2=R*Pjr!+d1+)jnZ^YFWSq|2$I7cn#30k#g7L>%Lz3w`@y z)yM~P((Egr3(bF2dm5=2EQMJ)IC<@!2x8$|svZ_(S6^tHu`?NLw|yZ~3R!)N#flZk z5flD2Y2sQ^cwW@&4e?P3Mx~Pd&Y|$o=d=iWq4QZg^kt=+KVPO8`Q^1WmIg1~4Am^P zE|lPk=W%Sdou8x?(_tTNt5zso@q-A>NO5SdhUMip-PhldWkZKBYjG(JY+ol=GsOF+ zrmb@q>-*D>P9;k?)=HD6|4>XIEmo@9t%<4tBB*QsRt(eK!DM%H^Y(%CI#XBIq=EK0 zMLwiA;m}JU4+QIYw%tv!9o<%uIa-6n$D_GUdECx(+*EX`?euHRz4sZ`6cFVx+s(c< zB$4+NAaI`Ji<{i-HUnv9$C&W`aD2WaoLV1QG)KxtbkDmYe=qNIFrT1pE7Kn~F`;K{ zz0QP*jpKcWirN0s33Ymj{!7=hcYMZ&lEptZB#z5=NH7BsT=)68wp*_7_QX?It3oam z>Pz}`O5Iv=LCFn;`z5eXwY$7cktV~i8J#v!GUdmILRoyoX{qt?5S07zqf}Y&a||!B zwYuv~68ag;sIutbv?(=Z6CdQ%DxVw!RQ=GX0pUxBfp zv;=5$E;Z638NnV3UmzG$bkpD=-5oMmeliFk2qdJycwngL4uY5Ocfw;dPn zG#sE|xCooy7?f}b1cDHakSHch^8h71mw9qe5!)Xo9D~p>B8=K|6ecK4%D=e0VJ~9d zJ(+@V_#6lR78xoYf|h5L=C}|7DIXclGr1T9hDaG$^m|eBgbzIo6wDlx@Q*)8U}NEr z&7>$bNHMWzToK6U?1V7{NX&VM=$-}N1Zvz|!&nCN4;eA>V4{4((GW7fY4|=Fu~6bs z`fCvwi>iEr+FO0`;34c6 zgit>-g`dS^Yn;O63XzODHu)sB9`;y3gSg*gZ&agFab$(L1eQriS;`Y&!?imQ-C7& z70B2q(Up%v>U!MCe5rarl_3az)^V6b769G+Hf% zG)n&(%YOq-hrTZzniAu6(6;kRv7FzQ*~o#$%DUNv8gM+6m+I8x-1no?r*n#wS?VR z9Yb~46HxI=6#0A(qsktu*Eyldfai{dj8iQi3w$`{@MW*{f-RitVzQ@*uYW`NjgWWd^ONlzzJY-!u$;#c<_A77=-8k)*Ic@_s!#CUH=NSmhIcG?`gG@PkW9{>xB%kSGRuY+1R2gS?qKP zTUz?c=y&hh+&uxv(r&i?qCB?L_*d55qIr~AWQX!q*5*+urS-yndB^qAEV-er<$JEz zI~WO1@D6K^oa2cd;D%%=>TUxdtS^K`8u@h?U~k_`ea&? zSw1yfWqW+{S?=$j5tDiwe^a$QmNmNl0GmXprKhphF(&R=mF@l5t-;MODeMN5BXQLV zyPcuEu95Z5^RL+E@mQv?W0jqz#&FK`bT~cENiHi_v++$V1>o#Dnr8Pfv5ueXyD>~= zO^ykmQiAIo+f?C%qMG7+tKL~aBO+AfF!d@MeW9xvm+|teknqL{3SatyOM#HqLF^1O&TjWV!o(E#VXSm7R;VST1-jl24F)fJ)>g!sM{hnrEMe zeYx^bmtJ{n*HZ31XJ;kc>fGF|<0Ec2M}&?h!i!+xJNWf&k{&w>+hD!CPI?v4z@LT{ zTU&Ogy1(^ndRE0z zPiHRW^K4`9=}uEVgxV-XY}*J@>r~2T5+8TYtx2t$)m{P5BS#cX|CW}{4FoPf16HT)EiHiz z({#3Q4BRsf4u5)hB%a?^wIWcZf21B6ooQc=%Fjk|$0w(Z9FcssxQk}Vij^-#o*RMcMpFH3!Y(l-8sEW5;Z1#O};+Cq$b z(*Z>~@?`yAD(z~_i@pt4bVV6)vprWzVpwvwx*Kz?qUG&1%V9Pb?s!+v*Kt0}J=V4b zUN`~_H)NyQWq8GzVGckd|BZGhwWY9`RfK~+<%v^~1XQR4s0Ju0xW@DhmGZ@l_rv4u z@02UUH2Ra2H=%vh+*w?;9Egr`hEC&-<*YI(5;NtEsbfH7+S;ppfoL)3FPFZ(1}Nyt zahaFg6Q4u9X7?U7`X20#yxJ^}(n$!|mRr3S8V@K51ZM{yV(+P#k(T~Z2uBh29gkaGOw5Sm(Ia(3BQ1G_z_vk-W62=JgoS2ZC0AMQJ89ScN+>VsFVc({R+7al zah8}QWztT+Fza+LF+?ORy2i1$R&Y+8Z8ZW_JC#HG>DA?zN&!3{RKdT}G6i{SC2Lbyu)omTCs?8%ne7*riqeogP+o2!Xb z>O?k3r!IE_cd!yDO5Zc9SaHL1%PI;C6eB`$q;O3P0RHc@dS)z)Vmcg~j32X$3X zrjJR2Xa#uB3HVE>dTnlUQ!&{c#z-^jC!lwB^RWtaE8n;dH&OHt#bbSWS9TfSZePQ` zLLf)F-(IfU{BCRg=u+XYw?mvFrNi*S<9hIbhav-J1xhCaj$2y`%d#U`#kPE_To~Sa z*^JxoTRW#OW@+7~TA9$UCmFVz@#j>J32?PFH9sfUYkus(`Z&rxnKyeWWQXpOcY4j2 zat|)jN_AErJ5&E2KaDt#Hrg(ZU1N9e2i7@6Wce>Rfj)kJ2TuPV0Cqr$zi)G|WQcuU z>EJD&CDWs;!GA43F`FZ)mp0KpQqs;#uB%{WTmAj(#}@BCeo_)|)1EK=QZ!yUb5qoT zu)H_ZMY1CzhJH~>R$BOPpQcg&{cRffkB`%smf=r#Au*}0|Hr8rBT)>3K=ek85fHrp#Xf#XLmFl~yVZ@W(C(RxQoHY}1 zFp)kCdX40eTS-^zQOp%cIGD-k`UAMDZ;MPGOdm|7RTqutrO-?Q9v_TkR8Az9AXEoQ zZvvo35)QhbP7C+FiIB3<^cIfeI)dP!`{^Tbt_OQph(Wo)L-)0@W0;c;|Bl$|Np{bKei{wvfJVSZKd>5vH~`cbBd!T#im?jPz>M5kX=6P@ zOEc)Kw2_{Lr7@WfAa_xM5wQCWt%Zz$6%w#LNR$IiFdSe(=DZ}Z=r@4&L5&QI^el;6 z6lRK94v{-C2kiKo8k$2VW=-^r3{A*$fFYR$p&_W{Zvk}xuu`%lZe|kG0Vu0cT@<1X zp-bTL&CeO4tRE(6f(|h$hdfzF+ytGeIhF}J6AMeCC+KGR20ykCXnX&sE9C7_OPAzY z?`r0>o2@fbHOw|w-?-K6X)~oeA=ob=?cZOojXC8)k!;rk4mcDZD7*8rY=8ffFzX7D z+4eS$oigHD_rpYV9EQtg3py@lx4GRX4Od+`n)Op z+_dxtKe&3glHUQtKicwirFt8s zi3Bj2cW&FHxaf@fGd`D{qWO`8%W>(zmIoWZzpJ>LB6j@D zf}?Iu!AG{P<8->AqSW{J#pSy*R%qzH-}EKBwQs?NIIknUKlxprw<>-YdHC+Y%864K zU;B_)5VlP?;myI6+pY|L60Z7l64&$2(Q;ceFMxN>k%K?ex6N7F?K)}s(YKe*6ijhT zPc4j8yY4N&dIsl_j{y<&Z7V`&e*As8k6*JlQ0L@k)mN$yZ?ew4oF-ASwvfY0!~S~Q3kQ+E z7g+b2U6`5bYsevcyGhSvdS15cf^uyThgC#^_@C2r!3@qgwo0<(TQsHPn2F?k!*|2mN~@7bfHle zsCoB->ukFv)=P_JtYi8Oym7ja8e#}YVoMdAt ze?C}$=A}12SF~4s*_BXaDbE(1Ez`t#>K3Cg(6D8?>#gU8>+xF8vFcm#dXL<{OPBMP zdL;dP!F&Drm1x;p{VQfIDxJmtHMX&E!TVhcmmIJwNf6olqGfMXiBF=~>8hv6d~^TK z%)J%=wDs@z(uwEvFTXaC4;ETGEpFO|fDZ1jml9tI-BZn+@nLPDN5zU}g}8@~B7YCD z?~QtxoEf%a*R^MUKkPR>U8S+V+B8fkapk>d-M_cbo3lml^5GYmz0O}83|YTkVqWxO zx%!K%7Y?hqi|mfO{_kvWWM;vXXP@89jxP4`(^!1*rsc(}Q!BU4xjW12))XVV9UO@o zY5xCzt#>~BtCBsFqlZ~4Z%K&3{5FHGINrl?YukDhd`p+Nv4=VPF7~f1{b#syMP6jc z^ZKRco-=2>JhWd$;N11vW$vL{y!F0k9DV{!MMVeSaK4<%?Q&87`n2%>eT{;R6+PPP z+0SM-e=Z4&nJrp1Z`a)e_S@ovri8zq>y-Iz&C#_tHGXVkRdS1YdHoi{yBjK3GUc{- zG8}94J=8Wy_D_Sxub($R?J~Zza$3j3a~JC}+;?{^KK$sISnd7Ie>VMkVDUd_%Jq}0 zil03@bmoq~(V4r-yi!ls<|a%yJcl#?wQS1;?TgdA|8tm2Dd^5UfB4(c2QQyzrO4l$ z7`rU9^xM8$pU&syR_5`AP4#=d?BMa7Y0tdtjSsx}`^Ep#l2;OkO6Ayj6BA@44oL@< zK44t*;<@sRt&A=nOFWo4Zn8Z|-et1LzaS*+`PJ+Lt-n(by*;Wld#AK>O~#Uw-SzwL zw6>joU|cNBphqrpROMcHz{43i*>U?x29*uflNDH!LiX<3t`++tL{iSp zFIk$2-DAZbX-feod$ZYk<=IS!1gEd-u$9UdyZg*|d((`i`?K_BH}8Mz?m1KSYW0ND zPy_${KVLV_P+m0u<@%4ixHzY`Cr)+AmeEp8Shcm@jUn)hxAd2+Evjj~>ZOg95l=RM zNxQmS*6fxh^Rw(%A8oeG4SrrKpnbsNz^S&9s2>rHffW%y<@2}r_+y#KF*PGNkproT zP$qI<8_Y=EPG$(57%_xSj6jbRFof+hgKac}?KFdJHG^*DGKB8sGK6mCGKB8tGK6mD zGKB8uGBkndgHEVGw{#go_jDOTXOs+~Q%Z)WQ1hTGZBT1&YRtG8TIvzE3f&Z=-(^Up zSr-H1_FZ9dfH7UCU9dR7gxq--b3G$yzXvq$Vs2_grUOjrI`M+V0c7@j%uImoTxh=s zH1lFY+|EM)00030|1!12aDX|vQ!nOv7SMhV00030{{l_D00000|Nop^&2Hl$5WeRr z`~=8ge$2I9?Y2^-t=dD+w4qr`jvW!)X!q$CB5Z;QE#+v<=V3epgZPGVQ#O3*ZD0y9 zpqzZS@^Zz1(nV;=59~@mH3twCj^7lPe#~*7QdjzE5x_8uexgzHCoZi$ohuGxDSnuY zm}Nl3J>WwAmDCvU+BIN81}Moo_|oX;UwR`LGX#hu;BZSo9{)0(0l0oB2AaI;GmVmP>78K9dUG~2;3f&@ z^(?1L?G1~8L^d0s0fi3})h2{Zd3WsZY4Sr}(IppBLwDa?WmB7n>!yxE0F z9`(ax2NY&O#A}m!T?Fa|K$^7?@`!sP?TULM^lR=Z_!(E>pw+mY z&VTSff79}Y^XMjocsWUE{3W&ShF$fnh0<~xDs5+_Ym|rZgx;T0=t;?Apm4rqIC-|F{=R3Du@g&OIsF@kvvOK5(c4u{cxPxaUf{XVLFXzpAp-&{p{82rMw ze`J3M72~yI&k!$9MeBCl@1=U{L|-|RLcL4Ct^hqM6|*1XY3N6>wFZe{Tip*wE&AR( zUXFt5C5oTC;L%NTF3;d<8tkHf>C7vqV>lM|^Ev_d*i@Wvrd{Ey+n9%Dw20n7#9Vq&=NH#^pbRhI&Ef9 z_b)c=KL7v#|No3#X;>528m@JDib^e|VvAmxDhh=vAv2Rj5kVH^f`GC;6^jhXkPL|RKY64m8xKAP0KB0Qrc^JoP^To3m)k3RW(-8S zKN7%T@$paB(K1?{jOa+lEQwGyL}nm>fJJF8nMxZvmeNo}ZlgE#Os-~w1oP2Xp; zIGmpqNHV1&!O^8k4x`9MMv2+2%E>8)x}{|=@&oBRe}+R0b5D$pQc=2PNU-S=zDsb{ zCH-*#1a$+(C$s1V&Vf)IN8lnGIax=8njBm4y5+&fpY4Hr76ILWqth*o~6R{q#2n9H( z8^k<5RwmgHHL=h}PSz8FWHO~TM#~@J+^#{q8Ass|<2DkDd20i$LV{IWV$hC1Unqry76;v)4+042yhVH_%bnhM1~VtPIA$Z8 z$Xal5*lbaL4YO)*px}xGwvmafwssM$+XXEp45iNBszF5{sC{N&6A#RU@XJ9gFrzZq zfzjIv7r!8YJOg%M#I11g>j7+U0Xr~Ct#I*IR2%|L zC~2CveS`_1Ihjhx7{os^gvSW<53mCxbZR0#3Eoe1TVfO0$R^=QMN3SuIsTJaLiC#= z*wkXpzy_V6gwMgwu;11(CKTDo0X97-MnTDy!-C;@u#r4^W@0|_>{A;;4h z#%xa*0}{j>1t74Rj8G$CM3O;|M!nqTrnUUZ136*|31G1Jh{Sw4b`hCR%8ai{)N;df zP8_XWOc?H1P`GHMcn zSBtxwTXM=D?{ZG9*G{(&@H+Oq_r_^)$M}68*0?|0F;srd%e6YBvT0K#HqWkT!h@5N ztW`H!JkCzo`rhmBI%aMUb3OCaE@Y_Yx?50Ad&f$>ADUf#^vI@S^~K`B<&%8#18R=# z{NPq~9iiAcB=EK689Q!=JG|Wl!~Op1w{yCVtv0u-D`gUfJKA(L1dQnG`?Dw|#O%m-4U9 zT@RbCx+ph{zuTPXcX*oQkp5vcn)+?Yk0amsBshf;CB-;odggE4*tW-z}_ZAhUc{QE-$pxpTevB+As%&C(1IiK z?b#PaEwVkHE{zMuwTJrQb#JtH_cq__pf6tgDq`5JWgksl`R0MD z#66BrE0TM1|2InRyC_yZdGwm4adKq63#sc8JgV3DE>CbMd+pfgV|4q&Q)`O{yHE0s zNUHp)sO4HEvgiFZXXnRNJME1-TM*{8{?(3y9aqMW-IK3+VxM-aO?#TDF3+fGa0rxR z-TG(x)+w(Cwk>q4s)|2a@k>R^SY+n&KNoe}zmQG3e$(@1yUTByugk~!JzKutC&{t) z->G%uQlg611qq}DDXp3}6{=Gor?1SMIBey=^ywv6YaEEs+Lhw6;aX*A_gVUR4$k!E zcH|@n$tM*D28_!)j3D@$lL^gHGiO!1c5S8<9tkP&#Y?Vax%zG>KSIQm{PM?1(%-3M zQL}UD=3%!xwuj~Ij)1X-zcBs?! zHO-Fj`ur2?HkPg{kY}x$aVoU+S!d_T{fYDH9THw~d>6(4R&L3EC!Faje5~8OJy(@p z8CJCD+TRITaY34#(o;3^YcW&0XHQ2qA(bU$CmqLCwk6J?79^C-@~Ifl`c5s+8925R>Ow%HE+F=<+?i5 zqju7Jml7j%Zd2Va_TaB0BZ_a*Kdxv!HPMbbS$uOU(dw-z%KbH1F{$Qw=Fs9(s~;s6 zdSs172mRpo>ZJ@FdObgUoaelE=Wn~yx%Tq8^ARJ%$7$>zGxtf=h7e#wEA~4GxW4V6Zb1ShxDz};fB->)y9Rf6@*p$!o-;GKBj?^<@5iQk zce8e_l2zZXT2U$C(*+3G0K~;72>fnQ-wibzkt9{NPmt$*27?=_s^O6!{ zj{gSE?~uL|!w)C)7y`p+2QxH;9s|8WVTT&+Jv7;~$QVAJH&9TY46y@SMTFH5n>({d ziTec)xg$xl2UIe!m+X&=`{&sxHO9}3Uo3t3#HbW|n*TA?YzdH^aQTu$DvgXx-6u-; ziFPPzyHH8y)v<*L(2PiIc1q#)$-2PB+WqmSF`RrRFWZ6itEPN{7kY}7Y;ysIK=-Ga zDhjOHSdq$~?%@R4azDz@B%CloC~SA?he=^`oHDmWluHp&@#|L>15M%o}5gpVbJ^f!i0)KE3~Z_L++^1 z2}K1>3Y!OKR1e|>Y%KU`NKhF8N2z<23%rQg0NXYERI!QX4x^kg{SN+;M;?;Ap>#j> zD~Km#WDVQ-;rC>@Ubf-WTfUgbtsb_L7%|C;K3fsx-JCvBxf7qTxKEtx*Y!G9s7$$`|u`1Y9< ziZ_S?wohVO@|ymIsUT}8{i0Wsk~yNV0BP7UeB9G!=cXz}E~~u?RS)+IA%vGmERZDN z+aC2RKdjU>u0laxR^j({qY4Sv>iBPHO=;ub>I>QKl88mbA#yPY`em5BxO|f_TP*3L z(eX?Pm(aDAV@Y#GxHtM+!@e(tppcwTWr`r&^S&MY31N|o>o z8_tl4jw-IS6j`mFfZ(MluA@2<26cn)i}V0AD`OI{lz4)%GQ|8b(4NFQ30ocx=BSH+w{OAxw%aa1)I8Xe~uKg;2^A4BZi2-wS;}*w? zu4@+I)p7ElD06U+r6l2j$s&_kU4dP+3g~Z$U%WzU`y3Ze(|-$q|6U>W?NYTG0jY;m z=e$NLz|C$Yeh%HfoV9*)CK>kayIphjs}?*+7X!cI3xi(RP}QQoaivf|MD8OuJE z^IzQ&Qc8&{v7hY3du^aeL{#ZgC^;&S?BO9XM3GaNbDvKBJuZIe zt^%HDl!I}cPTYd)b>X^E_V*jz{J1mpv1*tIE*M0j(e5)|Cq=Y#h2WGC`AE7ipKV2n zK!n%oaal#1U+ZdBa#k+YNYdo@kIYtG5D|J16)c0dnUQtEQ8esjS{4#kM0&A(9q{Op zp+VrMxpUCy^WV{-(P$NDm@1#8u&+f`c)qAr^X%y8NQAGc!Dmypyc#TQBiGs^Th-Un zOugHrP|&T!Mb#khg$Yx>6OT-$e!?XUUB52j16ssU}TXqnRn3ZIP8^`s~v&FafL_x1O zB%;3?Z}H33S>~idxPI@|(Jm-GYh&c`JARA1PG_Smpwb+fK*i$vNfoO%QZjbVm&_3pB+=HRfyc8!cH$MIF{reqaje!d zow85^C9+n|u1e2OMn@%J9Z6vN6obocbr%U^=1U$zAo3N2*Akx_hMZ9TnTpO z-|lG!{K~5Mr+b|if%WG8HGX=82mXdRr7MrL7c_u59! z;6Yl%$O&v)ME#?Y|9j$}u{ZxU&EN|Z>~MEp^a?ybNz~GRC%1Q=*gnzp+RD$!YNXOY{a_dkq#=+?~_O z(_7n616()7j#~_^Tix@mI-Q!q*?oIXD7IIH>$5Q9B5;c(S(d6z&gO;#PCVjA?*l_n zT2m_>`6e#6_z;6bSKF#Z3+Sd@Lc3rKS4ns#g=I!z=H5M7<6Xr!9^a}x&XLoxWhdwf zLusvaiW)EGU952l-mZN9{X^~Y5Pox#zEQB-^@*l`JE7J0N)sms`s#zTYW*(-uR3j2 zyeGEB5~>$n91dH&CK@sc+}LO70h7jb4GbFo=LZ%yLkf)d@^xDUn3&t$gV;xsx&GF? zMOt+aO-8wN<$Eik?B9 z0D;la2G?4qO~9E9N#NC&$S}9;FU~DFnNRg2P(#QseK`I8FOyQZ#Y58zvFC?n z%x@YL6cE0;9YPYy9=7Bh+!Ti&%DoQsbqDiZ2F=gPdYSW!XpFiY0zac5J5yio%OG~b z-K%)D49V_!+6&o`<8R}v*J@`KAliTKlLO5L5?VaZHam0#skV)jv}`H|PN!%$@PZ~S zEdr$Lh8U(;QL~FRl@~9}r&YamW~`8A>s^^2dOEtt7x2F2tZAJ+&QJ8^?AmQE9L)xZ z9@=8-iC3F>t2&!GwM<=_U)_~%B~0(vupF%_mX?~7>Q<*lH=!uTqCXe^%2XzLkD}$1mX6-BwWt=1G&wIN*Xk}cM)zaU4t)rH}PSB(Ed*1B& zd0I2H73dIad+@CF@ZFiKC-=3rrp=KkIT;;3)!0W%JgPkEy6?Qm*U>R$@6>=~oa@CQ z@SI)rP;1Kjq**>|m!AuZ1Go4Am42UK6#BA;_TXTSNIAwkUZ62pcr2^F=Lc_x4 zA`)=f4emQ*XhqGKS<)adx%FB%%P&%|;G^U+gE^nCAMKbelzDhkH|`?kK+-hYh($A) zeY=L;zE-hxK)qC#hk-pF&b_a0!=b1A#F|McEqrKO`*Qn0gD2HJXBvKH4U$9odH2LU zAhU{nwwsJ+LnmFLV5jG@n^DHk;SeRYpH7{glnywex z=IexA9QUl>&TxyEZ&>H5ljko*%+7SNdzDiLvv7aa7hbqfrSR7zEx>$?^almCbRx&d@YtVi9JZZ@OWR*33v5rSkoJ0@A(rt6HE`A z=6iwBQ1dPJIW3Lzaf-_&k!q26t4K5t`B0Of8sS4hKBHtOkC3YG2De}&h%`K268GP!<4Vcr;iPXRgZNKQ*hSlen6<#aQo7+&fKPnvZ z|NDd=xwUMk+gna~FA$$e_*>=*-jG5gofmoi^o)`I2_hx(V|l z{~RT42BozAQe#R@7*B%+;UfPYuvWZuqOM(*8J(ROH(VvQEvcH67yDJ*#~{-7!udS7 zOfy8t2M+gSZ)ioyXJhNe>tQDBWe2@v^Y=U3$*dx}k<&rf(E@Mh>G5Rk)*5$D>P5MS zEv0$BBf$eeb|sr5C$|@WZWp$abYJT0QEpGJxfDv2DSFLjWD4Qs+SvnENh)o#l}fD+ z@8!v)ksCEVsw~~n>6rx;`6eHRRQUmgQFzHS;y9PoW!@l(UqSLVE;pM3*Y*hm=W5h^e8D0 z$@zJr=ST88_lOpPct~)>(PMim<4NSe`bEze5+`Fm_IYu>EFCHGAMLD=zVodi_clAJiI96bv+uKl2Jr7_M`SJ4;MBuS`T#B zdqeid!s7No7~-=Cy$vk5$&vB=xYmO;qK6^kF*8fhh6WVlkKriV4f*6N{13|=Gxmw@ zM|gP1iTTTnKx-@H&Y@M#)0hZz0qfhXqwwg}Qyj*H4yTF_v<~52g*CsbFW@%>RCx)- zz)$jdxcLU%qx;4OM%D_#_OZ4eF2RQ@=hx3axv!L-bbLdE)02PB#Gg6Zo?`G&yrLnq zWbR(Ph@+#XW%Q-+i)JE=SA@jG{GeWopsj@CvJP|UM7B=Z?#roS{xzLy%H@<+-U|65=pJ|BVv=>wX;s>h$=yinj_)_Ud4@Wo8`Y z5wd-n!+hg?Z+CPoSbT%SpD{4YK=&WD-f-*tYf zSw_#YBi}FR#9G_?%+%iEAIz5SIo1Lb9dU={W=MsIxt>SAXY>5-5CC37#p6uhgjnh;UDAO3{+&*SMvOv8aZ!Ft{ zO#s8B7$ZdD~RDVrLG-~w# zE69)WqVgdjSm7jTH(+ene>k%@Z2$ejCk@e5yB3v=j!85UhC9cjKDo8lVQ9Tn298*;Zdu)j-z73rSr+g-(m(-&w~36j+aO{q6+-n&_mGg z6H`gA99{ZR#sz#3@6iOtQEX=m2~+?agj8pTxsB?6;`llO>NjP-XA);cB{f^c=;{eEe=7CLFfcNLi>v<=x0Y&Edz@pHVxtnZ_adOe6Z|4<72p}gn zP^ofw-D-ffAZA{>5EeYXgNpL{_y}j|;&R#t8b4mGFC&~tak-Z|TC0Y4v4=|6Swwn7 zt*@g(+w1D#J!>v7#exa%Y}}tF2!r7bDGxJ_7%)*u>5otGd>MTbt6?^IgDh^i5}WSs zC3M38Lt`ksA~fen6Hq|GPhDI|11Rr5PuiXEEiE|I*lRk|HG8Ksi{YP-=3jAqfvnwl z`-ETrY&!uK;xpvL$4^b~)Tf_p!snF@sUfmP^iveL@8dazyvlGgk=q(4XefHa^(_VA zjLB{Zr%#Ay;4`|KlM*7H(n#3WX0ly!KJj%QE`<}_?8wUf@X1DadK2CCxs!rVk2<{a z;&6TD7&T%hwn4QH0XK)goo!tF%3Cb~g+uHKq|Ilj)EHY}iVX7~V80}633;078u#~k}9ZVH9ea=gA{qQ(iD zA5gDRnp#~o$VaG)JZJ)gPK0pX0a|Z;M0Cf@h>n3?y<)YTumVfpqnCux8%0#V({J|4 zjqM1ndvryx{IeB?lBNYC%Gf8gi|@NV>+8p4Tss;;g7u^Gs|8g0h!M?+6oh#%-O12g8)Jbm1H;HR zFa4LZCgsiG0-vbxOhj5*<%K{L`iW3ez-C1;`(rRag@n;Y$3SRzA|p+x4xz;G+rqze zwtr`d-LAxk@(MnTn6^64Q4%Rhau}F4BAhE|pl&HQJCrR|aFC6DYCh;N2C+9F%ybb| z4`4ti%OQ?aGB6dBXN(bHk2;X6n>D7zCKZQQ3Bpg9(tXMIy~TjcXEnvfqJYBxIxfV= zZQ*2!?d?jnCYd%vf7rgy`p`i@Tb6tr#-G^r{zaWLA5vdX5 zmlZ6E-e=P9_|iuqK$nf}`tw^mW(t-)HSu^wM3)-SD>xvVSa;<;GKcv=RanS_L-FnD zH}gPHJrnk_Ha$y=TG^f^bQxh)uQB#mMBDyGOiNK)`B-PTHp|qQF{zd;2vf!4MI`Gm zve^!PS-Huijlu!0f=VB!ZJ7g-LwHBdJPKH%3XhRs@<=(PZF0Pbc6KsF`b8{lSr(z4 zp`?=kwEt;M(mjRdFl7isw|Gm4{Y_dFK`1&tUGpt|Fnd z^2v*vNaJy!oxf&bA5ji#SGf>}EMDE7ALt4V33uk-%}*vrzpN0Yk36ZM7Z^Cvq3Cs$~2KZ9(*UpXOuLG|A_A%MR`?DMC z1}*wE#?Nn;lm8)=5X&QP4*)>I&dI_Ec*v5C8OZp!<%*q)m67f5F*^O`ti-=BKL0~b znP2GaIZ1$Qk6r+lA8rUB;L!u{zi@^C|0%CC*JCJ&$F=&$fU|6jTKRby)G>A5k#q`-h_oSpnYv_qTbAhrNjR|ZB& zNbbqnIj%)R>i5txr$z#qH)|R8B044wXs~XR#w9`q2UUbw>3425WoLGRFIJ`(`-x2! znNU@bx*45@clh^mN?;1KL{KmM@jfzi4}V}&_`qJewa0ybWw~o9rr>^8$pP{(%KKih zxLw<>uC3^oG`bewi7?$&Shhn`0vZim0-5J}jf{EvcCF{;^DyuW!8|7>cYp?=&2w`D~nyoRw4FwqKqK>wjZXY`&UG!a zVpMHMlFH!IQ(?_nY{u6eh&3~_ZkUF?P?&t~ZbRudyP@c)k=pLb&RYlVB8p>sRFbdB z{ANm>zsw5Vp*6BJ*9L3e<8G?Wjk3_ZTo{}gpNy2G51T5*9g$rYXJ+yk%DNRGU=Y91 zU+t^z&cqUOa$22g(WXE3av;CxXTupn@LR2j;;<-IkB z&@-s#A6)s4D-SDKNzhUdPG8Dl(C!6-n}Lc-VV&De|3UbLt=FzVSKUg=r|LEd!TZm& zQCi=O2s7U-1D~px`Wh+wJPoDG&yB2CRb>Wdzs6Mwv?gW>zIKN!5nVR%#0)#2PR(ZS z^%%cvKaKE54-mUSIUMPpbBjxzaU9SqxbzRT;&fb*L~v~vCXNHtZCe!%l+vH1yxY2T zso9%NpO~-Za_G2!?KQtoyltbb&v*rMvrRf0p)1(cuy#x4LQ5Odzp->N5IAfTow%#8 zsRhyC;>u0%v7_`I6QDzyWNq~d(qeG@ZPgC9Cl~@&rO1t{4$EZo{c9{psCT0hZN?uy z)#%GjCw|kN?2}rbzxHO^LO$zPdp?lh_QZ+2I6b+OKVP9rw`m!+CHT1yrR;v?fHdn^ z9x-=`y>mgZ8NUSiWh-VtD{drw8GNSFlQIb_)d5UM^pv@6u8Pe4$z&>|bA>lz+JYJ<5>$3uTlQC4c!tW9r~w!_CB`=jdRq|H$3KXl8A1WNdG5ZN+G9XToFw z)(0C}G5sEde&^N({u%=C&q0Xu&xL+$6JX{136^mE$8POkJ=8x0BrP9l7FqusbAIt) z3;zy#06)PVR>0q0PuWwOwVD+}^Sn?+^UU?JX}XYJB=%)}= zuRFfTTw?^sCeV=DE+P_4q|Nkau$c@-i9jI>P%v}KN04?p#_(q7em~_m6>G~x6A05a zs{vl@-G1A+5Q2dr_kW78&M})lfYbhFc^ag}UocLg9})O1S@Kf@Jkv44__BfWD>4^Q zNqkSq=RGwvjN@LN6CJt1jlK7NBYDs@_NbyXF{ETMY2+Or!sBuzDJW4kFb6u!7#hMa zu8&tx31nWv#A(2w$4aoQO;`*)8yP4SH`%9r@x0GMT{!sripTPk7NgP21-n=>ca#9y zdf|LEaxm7*V!4RqHBbh>%M z3Ai7>pbaYz&3aR;hDc8A2G3zbkt2g`N?iGDhE6T`c$_J``^7TOUW^*V1lkr^yQ-5IKZ!sTn*tS>cLKQg2-lslRfgF4yW*i##?%1L~(# z7<&&fsDz-)G1%IR%VEP{(7K&U1=8$bP@q&xuiCopkp)$x?<*n6nK|uc8>{XaBtr?7 z?pLWDlZWQZ$BSJYDg?&vk|&VE!+ki#W|X0440}i9X6PhOUTqz+wNe zyKN}0d9qg*)En8w>FfF)@49{X^$iC>mX!!6vwgahF#yP|`1TyLggPr5#H9r7HJCYF zpsa3GJhtYTq#_4Yv;NZEqJ~*#t<#*@2=}J{dJ521RgHAB(V)!{DzQ098`hKR9Om~% zLFP)vxq1j|rDoh)ofkUo+a?Tr6vZl^<21gKZXD5hjmd#@<0Y=ct73+Bsib|C+5z>+`jPE=XWU4=#!4Q|JT@F(cNfL5QKa^U`SlC9XX&xbUD& zSsXb`Qj$T6vsfqdbbqw@Kq&+=4>?!vN-t-}jx;bFO|%IQxp1q*ADj$~&DjrpS|!#7c&WZ$2QEc86^8t07tmUq2bE$sjJzH6Id~ zHh-@f@5b$jI!kuzvbOMCE54LVlQZOQ~i=aaJ$o2#7rq!62d-W3KG=DNz=${3{+t~GYHm+(&BcF)He{ixv6 zpNn`x$&zuH zRmLaH|IEVCd;7i-=<)1hba|C-q6m7wNMm2Ii7!EmW@PEX8{5faz4rp@H{%1<;nr`p zj(m&+yHz>T-&dsTpEWr*ytXVKn2FB)yvj7uiZ|^$*^80XJ67=d*G3T=galZs)=(_V&&clW6`{Er{S#|6@s^SB$44)zNrko@ZQ9@Cgh-u|%cfIP}Obh+^*aCZkMY;CDTt+jI> z@pe;VL;0P?MLlR4kV5d0d@zprxih~`0^`eS8!bgKut$t#Boq>*E|xzCeRX77v}gNn zot(Po1z|>nBAz4^&j_b2L?DX%KEz#Rt!l{*bcqcikX~DXLYKk=#(@)(TP6;Ac&d(| zQqQ-$8!sCcvt8WBN(1EI`)-VE1ObzkJJ=znkD6SjUzV5-6Ps!od7Z+@FPJSw8195) z2XGuQ0ha(PZA^odlqHrb9#HkM&W5IQX?$iQOBA2GFjkh8O0+KG^vM`>yh7!WC_Z5z zb^nO?J7~2yBA&D5rBmLC@QrTzsQ4}zwmwoM=Y9pglsA zxr>3N_74$ax+Er*l=Sz84t0ppN-NlrsBC^OU+6T@VpmRNaQajRCHZEAYIpe#w$7R% ze*+NeI-53e8VNoRtJ7w`S&8;R${Xr<_LU(cz#RQW`^qj_l5)nvl`u*e%7LeZt~9Pu z%y_Oi8tD;*y>_GkdTz2no2{CoQA>UUoe(YL+d(~_<{Nbqh{dB|K>4dRO&ILZC}<9W zDt>r%e9E47BC0p0cLWtz{D{-9_pjNk323>q_{Z2VLaK6K7w?1a5$Xq)>&WF%S(Wie z=XRdHIE0M0ellXc35dLxUq}+=BR&{ zLI@q{UFo6%QlyvA1*IcJK&o`Xh=3FWD1y>E(z{3rCG;XiKuSPMx#qhwQSZA67I7}zubX^le3~yh`enGtW5d$Zk+r>(#%w(9?Uc{5 zQ4w-RtX)@)vz$0e>B>vAY)XK_z3q2u)ht0Z=2$SGP6&OlfQ;Jn_L~7+XSnq!DB5mU zlYb&}wZ{6WNth)_4f`lWI~1v zsB9g(-=QoKo&4wkR6wi0pc@Y+L5UcC9nrMEdv@zNmw8&W*Wkh~M_+Af_yDNTdxcoP z_8}R&pAg`RG?8kj2jT;N&7&1ben|B)Nc!Wjy`QP)BJ~zqLxO52G21hiXO0=oI8Cm3 z4(~@RN?2TKrjng+5FK(p4qD6NPu_L`T2UJ4S7CK~`k*b|%aXHIQsO&8pT}ay8Mu$f z-lplS++j94J<*#LyJAD7Ikb>;mmp_6$)C&&Or-@FI`|qLO@?1()u#x$>?7a$G-W^k zW7>y7t^@T;v)wCd=%mg0&vKu4zxdl&vVS_Ha(%qYPZcG^93{kysdg&r`m9Ze;t?Lr z=HKwM3s!tN;J)N5_)afovQOerO)3w;c8jtpeNb^BG-7tI9W2))g=*nFmI@F^YU0$u zyUfk0QOnXjF5+)IkxaBZAAYpT2<}?75TJ;7Ju#%I^cfKTfCe1doe$HDJ>4s8-1A_NtS-6qt$)J#Rx4#o}E z3V!Y4ol<*`B*-?3m>!qTy`(kR2q}8YsJV`d8Dvfr(S<+hNy{huxE>YXT4*$?EQ;6t zapHCFtw?_3mj?Q_#rsW^&Lu{%ZV;=ck!OK5)cLrUsICUOq20jP3T&XRYpnYy;L7Ro z=pD)NkKGl0MR9`iin*1CWyCd4>f7Y51ylVP@;x&zesqdle_u>OhJH3V(NrNpJG*J* z$l$Xn7!zKcZoF`>xcGq;oZEXJC9S(9n5){17^kyTWk5~)zt)@ca_TaR^IDD0b2z;j za@)qOz$}%np6)(>-ByNUz6Uy>#1=;@)Dw;i;hVb zrm8RqyGgczS?-h9rCut+R#8AD`O0*tiP+Dek|fCLn*6guh^WCjtJ? zlOQk{=%N?)-zUQU^F**X93&z34;mEy>l*am(i`WG`=`eJHE9a@2WbihpWp8mrE0WWJ)4Px@R8ZTu+?bn^C@ndV+nkmY@sm<%=7E5lxa{^}ObD@bUl{EOD zZZ2@mG_lXzuiu$vpHZ6TjZah-oZ5K8m;L;-mPzF-p!w@30zDrE>^Ds3c>itJ4;`Gs zn9S(Yy|QR)kJS^;$aRo&B`SGnuD=SUHz6Th#pzj{KT*A%xmN=!*0|!>#~O%T#q=hP zF>o0JTgAyDD+;KO$w*Fbih}6W4|ibNL)7WbRH*IrJ@}hi?`U}UbsJ#Cu#K|ekM+_b z?E~jK&q^FnZvA?JsG#=~AEs;rI99WEW!Cbuq(-XOSWXiAP=afW93pEpBD*RQ7O-LfA zuKKw%?(zTFU8F!pEB2te+0ZQ}X!GYy zhu6fnzHQ(Gvu(iNY+uSo(rX3^W}DI7IJ#yqoJoBTj$n6IwQ^ibVZ+g~2A)=$j;7T# zNz~8}_vf$~fArl|kQAt~v3Z?!X7ZtjoJYE%jBqvfvNd69=-EBfsj~IbV!%jJ4_U6o zus-HtG%7qC{i0j&2CJy~VT;Sc`*tPbE1(BcjE7798h{(YdkOI#akg5XdoEoP)?-9( z`Fr|+q{X~_`vgB+O-sDOOg_T-Ix~QN$~Xsrp1>-CQm5<#2PGtSPtnhJZf~*a6%}>B z9Kw3OWga^uHk&?-Un)dAaA#iI?7*{M{yG~D%yi#mdT>hAXx5mD#d$NbB%~$NkV$39 zO*OY(dyDd_u-}vG{6pEn(NDs5cj;folQ1C>i4~z7POapFF4!Ug%k>J2^ngVrE_a7A zCBY`rGoyzcD^lc|`T1 zkzF;|Fc5(`%p&Ax3`OQR5>-vyx@U-``A}h+WV+w6LMOgN4`2%34%j$xFiRwjiX$Dw z4*MMQfYzk*)YT@Qlqku?XgW_&7xgA4&=wR-pD-<{Tap5$ta@(jEop2=#$d>MUm6`; zT8IS2u2`mB7hG;27$_PW%_VgjHUj1(CeK_bAM@Vo*q+G$wQpKy@-OXqEe#5{Tbe;QC zonwJJQXLDllD9cliMnE3ONXDTY|iXqDVh*6jA`Un?nfzjmj`CMe+W^qjmu8fY3h8> zl4*>2juh&;+~{Z!Q;s#EFh2Og8&KUH6K?C))tFsYE6q(Zhq5{NW+`WMSGC|$8}2N6 zgot-o@}~B^>Gt?jmV#k}_Y{Ul=*uNB28z`%1(f=HYvM)(IeXTr?r5P_$H9kieE>;s zWK;TSDzjtn19t@c zvuw8YU=lZOC!Nh|`zWcY22ADy!^5B>58_(xW&S+25669(z@U?)tC-dzi00 z`U)?lUF$xpJUv-_sU=!vJGjhcdw8+4s%e?d8OP~$JPx-vN2-VI7; zk+t1cLNj6m!)W)Ir!myUdM zlT35Esqu_69`VfM39@{A>hyv)=oZOLz5b;u4P+j8>gZ<&q)e#YzPWy1B5 ztqt@qKX!N=ueJWz)aR?;4o;DsnEKQcW(TkJYoF}3-WK|(0_iE<BIBS92eYj7Zx&XLFXCY*N?RhHA|q+Kf%Wn6gaI$2_}bKOl5jk!cYm zLfb*4ejB6^9sfD?Sz zT&hcmfZ*q<6b3n0x)Q%+KlfMLk3R?Vn+{B(7w%_JD2EvAJSaH)kIJEohL&RDf1Ljk zIN1Da9n%S6XYv2I0pVpSe181@S;Z6s|E5tBL`)QPv4VKvPJd1V=Z6<2Q5;~n2uK|E zOWUmft;^z{Bl*o8-w^0IQC)1U7Cpc8c?jn~0g@0uSN5VHn3&kFMDq8h&wma_?03Hy z5s;|pzp8=Ykc+Ca^T#H^Au28gf=T?+p6fp~`1=#f{k8fC{NGs)EF$usC!PNQL1JL> zf0+1Rt|lrX0lH{D{5O~b|8Fq&ivafz-slj~^Z0*tZGn0G>E!2qwE5K+l*r4`EsO3R z=C>!k=0;RPA28=4E+uoBsrTG`)uXAxw6OfJvfKHU+uaufc>Sin-($ZSvz?q6F1<+< z@q|1>Rd(2B_e_^w+l#ZUmuLA>oxb7ki``h#rhW6Mzqhu>9KD&Jil#5V(O0Y(u;y7a z9cHm|DEyfvk8|0%4xm@yn7L1wt=#anD_;fv&7aTY>=73It^o~jjSZQlpIc>O#|-0iYtAo?m^ut0Ha|7+Ki zfqky_+7j(lV?&dz;Hm`66Q+~S=vp4gDb$+=&cfH2U_hma=4gBNY&o3jtrsj?WGox4 z1%QOkGlepgazH6fef-=!Jn*IaU4}PZQz8jC0K)3Fkup5?HD{t=h`n$rk9Cl!>^r+L z1H(`~*?G9TJX>wq*n5|5U_WV`3A`c(0$hK?lVET=-S=&$d*`q*sD6vBVaN6u`s7^#aBbY z`;39u#7s)%`YciChHH844qLLj`2YPS{5b&SPQ`q`ezjhav*%&tkyt%F+wX)auBFJiChaOy@s6OG$Wc$=pK)|ZyNKd zr4_q`DuFVKGdA%H+$t2y{MP8n-JYp08i^Aly?75A+@*48mkub{R1%ruZo!na!4RkoO|by;(jY%ln_t_k2U zLUkp-cRsM09I0`isX9*NifpmqnmMbaFBcN_$VFH*<`4VsWIZFU$mh`ps1gxu-(yXn z_=W>@Dy&{Y@>}v}^SKA$cJB1t$SxH$Iqg?IqbHbkCOYoB&q^pxC!s%Pu+PH@nTfsL zvCu01NP^$jWQ9N$lN^PMBt=8}mdN?L=x;ht5P32uvc>@LduFa=)F+NCJ&j5UTSg^v zzoeP52)%AcMcgt-2T@eeLi5<_^>yzw9?-O#`oPXMYV;`&`1dpyO*5o$Ou;LnKScGBngk+1JLt@6w}Q^*HB!&fD`oPu}yM_pjgm&wbAKT<8AX z=UkufbzfITphob=qh6lAiK=rYu}w!+)r&;x)vliEq?N?at>|Og4ux)Hz4h4ol6Fri za)HzW*5w`TBq(bFpv(I*0Zik`64XR1R!jq`c9L6{Z#09#XE7IE!CQh6(oA-<3=yhLwR;?W3so8|8*DL(d0u6eKJWKKj*Mu|5A zkTEh-q_F?V!0NLn;(lH67ejfi9zh;p4}e+s9FT%nLwt_1kun?g)^k|Qjs`4?ftc22 zY+X0b+duPcP~?I*7v5JH@?m;hoz2jkRNLSSAg898Vt81NkzZkXC5q}9FRl1%%raUy z@Jj$%sdzrhmlJwrl>~lH3R^V$GvI>D-3p9Mq^Wk4Tj`&84-hvIbV*pTqqphg=y~zgo2CkjG09Km zzQ`ntxWwkq`Xo-aC|xlmzm+3W40&=%ef=B}R;Wxl)_!w|DcK5SjQ;_>yXAJ384?%4%9AfNGu>SVQlcu2V2Idn-wy>DD1+f`-v7wp9c^)qUY8Gqs zy=;U7u^b&M&&%fNWda^q#(A*@<-_%i-G+?94gPY*(gqSif-=OHFDI>_kJ~=HoDlkD zZzQzYM&Out)ToFh{cFvNv4s*n9YOt=Lo)<92Mfnq59*uuYv4)GLG&l)hirD}2yYqr_*Z-=So_^x=DS*y zl2=^A@mgc@2`Vkgli=3k9w!p};coxE{FakcJN*I$a=CsB);g?vStnroLLv*`HL;yU zedp4RNr|mB{Uz3X&)f;eF+KV6PS&x-i;L+d^v`CxK69w-*B_%gaB<#w5eebQshCg==DVvNe4oy%aJ}T*r?;R$&~xhX-9y{}5cvx?VqB+9y`eJ)tM(K<+Y|o0&<@@C zq)r!1ac)`yb}16t(Qr}PJP2O)(6%ThOzp^ugt1UGnB8Mj-dve0Iw2uHfoLD~iO|Yf zE=Mq!dedCqb&limHL2v`0T4$23%TItOqDtHv?4Yp92EEKdre+z=Hn)Y;zCB^1vMAd z^nyw&rxj>@jscqT=Zfsdh4!e8CPgk}?hij}r95Wlp@AeZuvBjLpt3l(Ws4^`F+Q_8k`;PnverpS5mdDzeUSL_L9&%Wxw3a`*Ohs{p+5IC> zz-a1rCTW6YbwO?Pj7m*s$JY0I@{~=bPebLLMqkd{=@sQFQ4s>@*qOAP4xUFcdK!Iz79M`8ynKp04>cFlm8^n86y?1@)lN$AsM@nlmI5Q;k8W*-WD_f$m z*!6sPe_LR?gtG}P$o$h7pDKUVox0;+@}5E#Ms zx)$^4BG_UvQl^)q4pbd<7N7c|CroVijpKbr_OeZ2^AS0&=)wq1BC}SNdz4;XYMK&^ z>m5^P*GWrQQfpZ#B0u8g5y}8z#*Dgn__+W6~;n6OAUJnls=)Yq1ePwIu0(HCU?t~ZLUdcJR5v;G^@js~DEnxz1&~NSN zP{{2Fq96bU0fl|zO(-Y^f&3o_a+g#IfkHsh+ouePfkBZ7__q?tZBZBq5(|g^T-Ut6 zA9VUhdAl7Bj)X(8FdPI9Y=3t;`oWP1DCXz1{RJficK^}=4##fC3V^`3|4;yhg1`|t zDC+0B`u%4i=zp&w1<*f%nXrGo35ojV{Qvke4gp8}^+q@r2K_ek>j%sPp#D!a14!Uc z%2`pkpMGjrbxxPp~g=tIc@6Ten6hQ_;Q}h zE`xGEdPY#SsD>!Y9rOyPZ1PlbBPOrIv_TbeJ}#f|KCY=FBF|-IQ)`LBYUt7Uxp!=; zITUv3m$MmWGDeA8m%1cPtK3pXH@gxEvuvtElx#<%+_zo^1zYu#y|%M;7!krPS_hUp z(>;1MsCC}x4dz|$<9X$as`Ra*z;kK$xWM*ZGpf1uZkv5?hl0HWqLw4NSFL6xIi#qH z$2uy6u0~Hk6H`cytXG)M%JzktrWXt7ycp3-46~U|uPU~$aKx%Nwr%0RZuP|J7Cq24 zKB6k0oLd|abIic87&z!W<$m*2h3~#gLhM5A{Y3A}f(8kYf?x$zg}Y0Tf&>x>1c%`6?h+)pJ3)d4*Wm6h!3h!q z6a?2!?t7zq^tVR+c`EC-qJ&FVb3Iy|`?g&!d@nz8nqtE2~aF z=Aef}dGQdNrM%k`lP~^sZm8J2olNgZfY806xFryCL??0}U5YIIQ6DSL$bZv)GjyJ= z?dJH5P4&R-l}Y0;e~vxzx1fROw;_8i58Tp0iTSj$u(iN(mSb3Uo2MpjKxP}JO$cpQ zjtw+3KFGFQV9{c*v%!}=s=|3RaVR&S{AQeABAvV&268I7UTOT$x3WwbieU8-2UEA$iQr0hk- zk&Kkvrn3npDduUuX5_RAW-F>DcK(pWJn2{94Q$BvQp8IxxSrXHmI`VwdZv8iG95lLdgv6)U%Xnz&M!R? z1{#{edECML_WW~Q_v@G;jg7j;9$Aw3D34Y+7%HuI7RAY-bI>zRz{aY|`IKFK-Gzyh z-)n(vVolxfsQ3FJouG%C^Ld?vQ$KFQWUdjSXdZ1nXMeW|a z>z<`|qFuHQs1F}H)rmY6sYX}sAf^>xtfqF-S+TdGq(|KOMqyk(>bRnc!<{*HMXDaq zuWlYK7rT*C`yOI7OM6!}kAqFA_r|x+qlLAWOKtJ>>k-u1EsC#s;0X`4}P z_LR541|A_C9mDswfL4vnP&JOfyh6?uB#q#}%KG^1)PJ@eM+O^X(S1KP#N~WPP#cA% zYbgOnKZsodQuyMSs0iPy!*jv@6cJxw#0nYPh8Ex_)zq8esM1Tkt~bSmkG6|0tbd=Q-iwUP#AG zzO)Z=u5*3Hq(z*hoqdRv8~QZ?BHq$s_BOG*J{qkfgRiCQOFL8&__ATMs&cQ_ftCwj zPSjDJUz~;Mnceq=mdg$Drw5jnpC^zhuU!4Ym$2xu+PW9hd2lqdYPYC#* z>CE8Yr!zyi`TpYN7%v|?=Z~Wq$_ZtM^78x!pr9Zgb_gHO|AbqlX@Nh`rIn$couNIu zjiE8~e?l49Z&=2`+U8%u6d3Z?vkCaP*?*EY5SWjhhxbQQoM3h^82W$N6z5;P)`a|K z0fj)pKhQeQPr2-GN>>Qa4*~@Fcb)yfx<9t`&$jiiH+^8PKei2lL4O3l{tIXQbqf*X zS2|5F^v_3jy-5XX zA%kI2R~MEiSli3pKrcEJ0}RXSQ_g$78~|5dHe7qFDsRZ&GJl{OD0p?$qjvAXnEVoH z&#mivcDTgaD`JC^JdAZ{b9l>))k5v_4dG42AYO~5hIzg^zGu@*b858nQlU-D<;15g zFJ;Uqg2ZaCEWbx-So3u1*b?9B)kL2wav-^p6ZC6V>Btoas;8WUJ>TOE^}C*aiCQ>} zDV&GD1LDE_5E;kWGqy0y@=OegiP6mF8!O=p_;u59CF@ra|12#skQw}A*hCf|;R?I1 z6w^h3M1u5H5b47)6kp5C*G7{EW)6#vB%HNb0=3JR`a9J7gCI%%0xtceqI_m zcqdsLs5BYDP_g;Rh;5)no#mj6owt}l6KbMo0nMfmZSirXV^r*}QS`Yf;kkr||D6p7+voVU&8k z{bmM_b58RoH$_pfzc~y<)fPk`8n8nJVwYruP^aVH!qZ$4tn#~aX}dx@vsvoWX00}Y zob$oHF{4JG9=(wz>#YzeibM5a>MS!|cB`=dmfm9vrI{BI^6dYz`uLi0g@z@OG}z>WuJCp>mD8PpLGNT`oFetX>jN(6pkg18QbLnBoe<62f^wjt8ToJu z{WU=V(y-9{sAQa@9(jasvCu^uw)S&RX9ed6VpP}*X|!8i9UHo`vKwe_gc~Dsz8JJJw;o6lnV`*C8>CDy|9O#{d3#%U!A0VB1I6)u9*U{ievN z4!8vb1mT?^uG%kZL<9w})z_n#8^W7&S3I2QgLN^ZzfIC}2u@!ONh4X^-qGBW>@y@T z)loV0^X}xR=c(o0POdichWQ^hwxVp{s=NqUI#%hzx8`{+8XruTodFh=ji&%)_>VtdVm?M>K!{{Sq72%Ch}a{We4F9E0b@1R`uG zIdgshXy^$LI=WOR5> zVw@-^{amdRB;`n|K#s4+mrS2(XW<={j#n}0?cO@3v;dH49hjbS$vagrwoXMWp@gAq zR$+WYDYm(`bK*V^3w=4aCrjSFOLhr=FC*OLtiiilVf&0%X=RiLE`HhYh1?v_!jwTRiN!aqiYsC}U?dzV3fo@A zUq43+H5z9NgN>DUBnTZ%ct%d;eQL{>nDwbro9iOjF18JSdwYr)UE6RtyXu1{b7*5% ziXlh^)lm{Yonxe(szejdBSVjobm+7`Y{1<%*$pZxq$-8Ggq$!6MznKo5MeO*Pj#^8 ziW4?8x<_CFT_b~~MTxi^=bwpAt@(h@oA1}pvfd;pipd3oI_Y5cyvXej)>H&sju-E) zZ%0LL_J$X+j1^)Gzgp;`N-!+-D#Ob*&<Y1$0RC#f2Yj$WD@ItUMT zBFMD~AwF2x{Dra}ix|k)kH}M|BykjxG60?k%IZwg*=X-;)708fcR7cd@%gFRv*28B z+8T_-lU-7Tohz1(t>kx1U-p@qT9Wg@r%fZNSeinpLPI*TffClQs_{uu4|i3O`T_|D z7~W-dw4}cBMI!fifxJGFa2-DhrEo9>Okm7p8#|S!1N^W&y`oe7{f}3(ZXO*}OYr(4 z@#G_M79x;MVUX3U@V}agEwRhi{93ZkPYTR^{5D(F+f)`fHCI~vyv?OX7GmBr~!sD!!A zR*Y_#{QVb4P3M{ud=b~EoVoB#Mf(M?36onUnx8FYA%WGX?%hhuk;?SN<1Mm-g<{s7 zX*A>7-ZJYmrDVDg+}=C+M?j(#bnzz#lwxEKOVl2_Nv|U#F{JB}s9e_7(9jJY;A37v zBqMD?^06){Lpjr(L}`f-JI`B%@J}3u!#E_KkzzS^gb(NMXW2#t$`xpAz-dR=Xy~R- zk`FOqaxum2$Tka767eaB@%#uR2MqxA6kmBy>cUMj4w|-=#G0fN`>al?n2&3iuS&+y zi3${yx$Z?2-!7j^dn>Bw2D7ke!b5Movy+_ke#L73SWgQ1y`B`z`*&Fl_!p)#@L#-! z;O6FIhw%JBwY)#gXCPWI?@vqAPtw524*lO`yFvfeLIwU4B0tdIDdOV%_eBt%A4~kj zT$O)(`TwuEDv)1<^>T4@L;iHInWlpMVjn^4o(5+t@@FolBs5f?^J=-~7mSg)vSIdP zjl>~jDZsUM6wxP&EcZf7liakTVzp}V>%RVC%FfCntp}*OQt*uu)|ZU1kBa#vPdy15 zmU`oLZ+HEgo}uTh1)SB@J@|A9iqsI)e-U>yz3(*etyXgh<vo4d6?yUyo;{T! z-ukaY!iUG%7O9Rv7`YTe)C`UFz01*=6EP{)(Xboc{w&F4k-jzy%wi=pVqay4MJY)q zP*5*sXy?oRNLGOyz+2FCh8`#AKvv6LozGNZA-^TN+uP-2yR1w~T5D0Fsy+P7f|{vF zdPa!LF<`^oZAd_(7q^9Zs~L+sY4|k>Du+$K%aGh+<{Ip}%(GDOZDY5XwHIHKvB8zb z$&Ed+Obck6lvJ+kon)CqM3CCdfMOmT6_^w;K2x53W9QQTb(?+*7fW}9zvegUg?xhmiB8cDFA?*3e)UU#cPt;$Sd zq2){sPjw_vVPKV}n^AKh)9=|5vxWwjQO(d}L{?Y%_S(g2oWvcTlL$6c96b!aP>+QZ zR|fTMis>}j5Q1F1GOa&1IVos$jfeOaQ zMsX-o!kg6;oYqls-AQ5fi9FpoTm<0=gw0&Dy7gQ>quj}CNy}{425Urauf67DgI$*n8s&6LK%$UL zUwyH&4Ucd~&z6-h0#JH$q~>&=xPLXvg*qxw;hT0g7sF)$Q$;3mMv;cVREU(H*G? zX&H&NX&p+7>N2oeOKi)xI@*2JDxy9Z>ZU2=_@U=yp$g1sS#ifx@6)ihz$n;ieQ)!H z)4U6*Y7Z54RLX$$NE-3ov@WV-9u|tW3FhqA#8TzMt$azWIgW8$o__6vE1&MyzS|@BX>nHK8n6N2fbHYr8x7&3 zc15}m4&)olR;`>b48O{~_X3=@S=}b*hn*pRh0j&{%M`|{%8!r&9T9%p874>)C3>mXY!7p&?Izr-$nh2`#_MJF!EJ+GDnyB3P+zeU}7b%Ct z;{aD86EhWqXflTB$Xb~(Z`3iN6|EchB7KpcnB33?iBM>#->y^@`K2m1O$;oK3kPkl z?jX=6@{i+EjDF;<=`_^ZT4!}pAn9lX;baWx$&>_t>~DHh%46Ar#vvH@j4wh-zTH{5 zdM?F-*I{!JT=*Shctm(?iP`{bxz_a@_DXCAeKx!^NFUJ@FZ`*at*DNzBB#h^UU7RQrz*T>^MaAx1R39h?zFT7ecM0lRp?Rs#igzRq=hGl_^~aM zi&lGz>?K?GeIF`q`2;`K-Y&a)Y7HIz{ypTKf#iJrptr_ix?e1V1g?EB+F()4uNa>n+k%yxNM~WUB zGLno~VkAU1MU5BxB-$8|zSloBl-rBfAJBKGX>7Q7LXy;=S%z|w(5Fx($v5O@xYZ7R zKe}ncJl1pn;F8|29js=5nW@@Zb%U6Lp5AVlU)mnWGe1#UqYi?<6FfViIGE> zJYNJAo&MHtR2kww%zkKkN`0G7W%CI^O>o&egC#FFS$xdvO}!&{X1h;r)R-g|gK@+# zvjgNzuyLg&q>*Ogcl7-jJLx-PP1XyT_|xijg_nWkCh{YcjIWzloiLUIu-X89SR3_k{)i7_%ZFw@3b*#Nlzt5Z{SWOZn#=>7b6L^j7%`-Uf25&C81vQ1V-~ z-QoSyFV`a4uRgUj-owwXwvIUt6Fbsm00HY3VZABq@_pG<$7pcL8lb9q!8+(m=31vV zF}^t;?yQ5iM(VnuFjZSKBk!wuZ(#G8@B8s2P5csn*D4@dP)%$aUdW_D&ra-GOw91Z zi$mOyH9FLLl`_joF&a0Y<;TPo?W3x4`myB7sy=JQp9xDT-Pt;Afad1`tnh1s;g&ZO z!deVAn4^f}HB*FJM%-yQ=u60fo34gMM3|TD-43{RqM{V$8ke#C4jkFXP)m(TXY>P# z)T0t|=h6uHBf|56kp2&mi^TmMMsLU{)k>Rt-Sf1^`l+K1yN0LlAkiHMP9;Woeu@zj zDq@2DhyG7)l?71@qxQsu1sv&`F`$-$2iNDjQi4%QLg$)ur4|QJ>Bsiod#xpOk zChl*=8yzt1lYiF`Y0z7E$ZTue@ofG=uj5c9(@KEC6vQcQyKff~Lri=p)L_LFE}86| zfK=S~*ihm8Hp-g(4(n?E)%`EPH{_3#mLb1ST841{UGNS0r*H}KPvH{e_esnDc;>H2 zMtC@X8*T`NfY`Y}JhWgigdOzb)leuGJBaH~p>Y)$7vKME0D}BQdCgDl3WSg6=j#6P z!~SR9GW2I01<(JvfCch5QkcQq?9iWy)X<;uAJA_yAjqFfr2Z?dL3#d#U_iisf|Y>( zeG!=NN3T45zbNGWgF^6+#X^1|B!T=vo7_JNe`a0(zL5LxDp39d009600!D!;T#Y4= z15*U-{h68>z+}upI{-=OJDFkYJ6RYT61_PpGCKeEDZ#q)>kE1r7BY0V?>_xn^V5Sn zcaxVmK3c?Y=jh|D-D&E&N<~zD@r(NRXU@Hul%yg5e4#MZv6H9sYB+FE#Y^%-AZ*lpb zVwcap8Ke31WPJK(gPuM9z4xB_-V-e~oqallwNd@Zo7Y$G&)d7VsNFTlZl-?BZ{}o9 z1F>IPJ*viH%NOd0c=UMM&pEp|qH6s&*PS}6OgGGMiQ9hhO2+Hj%@a!U4@D5YB!h)fc?C)uakJ|}PE=KPtb zbL-k`i}Q;EpLTb=yZKI9L20r;-&yM%%_N5Q2VvGb{0{Hkv#8Q$Z`7rPgVkN9f-ahD z(2?5v;?=XpW9F@SpVAt0az5NYtP?61V=-l7`Bu%SWtT3!s%dne?z;P8%{kp%qt&05 z3f}%;)RdR($KQP8_S3s0#EDjk8;8R7-Z;Z`Sw`_vDIVcH=SL=u(?4S%Mz+ zOtI`P#dU_Mznp#~KDo9>q3A20tYn|izK419QtK3w9~iQ|Kb`TmT}pC~`eUZxKY3BS zQA<*y1A-#2ElmC6daCXeC$sz9Y7Zk;ndn#NCgi1MT)m*NAaLQDLeW`k7Vb_Iirsj1 z@j|ik#$<+GRZ#?bxR4JzT~a=;SKA_Q-A1 zuemF?Kl`_`yg2fXn0Lx|R^Rv0XSrwYym7hSL1yizN#CElJucs@@#)jnd6zUSn%7t5 zzI}JCc*nt25&oHGe1AfAZhi8w;+(8e=ws1$(bep^kqohtni`@%m8?6&MBW)m`x|yJ zsw!Uk+p}~QnVQ_{HVdzFeN=h0*MH&Q#9y$dSBm{>P0SW1p z7`kLofuW>hq>)$GI%lnO-sf3Q{Q=jP`^(_U3V7r8?#3|jD5=X z8Q*=hj&A@S7<{{5iZ7mYNwn)l`Dq40;E4H{d*o|8D-ZP~6bAzY*~~{tK4hoTliW^F zRl>fQ_#|7mVBgKGN90>+Dgj|#io{NeX6y6b&oNWZmUGnNQmO9;*o$vZ^@Q2GJs*6d zb=V8L1#=YV&bC?BAV+Pq@oBvej|+`9r1xXl9FgJ?_M*25i!QL)r(V`=KrB+{royyZ zDyL}CR?h7FIAo+QP?eY?X4Pg(30cQya3~CAMqvg{bVFM zCxa>?Qm)*KBKfYF>KX2k#gt>yF-4`cFml&5&ow4sLXLfJx0T zzz)S5Pr#qkBo#!fRIdXmJmI(eBZ-6eVK>&PXz&Y`T4W@$Q7sZtM^K&`hRhBRd9Py? z$8`2bBe#^d$x=Cepb?|M#%!;6jU$7QMR&YOQ@Pj5#HsoRM3WLEa)^V>~u2lA;j=dl_D@;^M{NH zF)cH=n2?*#NKAc$m7G=AY9t6{ek9pWAaMt+?0dw_rm#MlX4VLgm_wZnElHX@Q$u%>lI(1N=z-Q4}YFIUZ2uVSON)9xC(J zh0YkQBwuXta?vf1oUL_*!;68rQ=KndX0W7mHF_qUpoBlLJlsi!*|~6h7l#M~$?`qG^{)_E zc|xtp=&&!$1e5(}(#-u_PF|J_hXTnKX6yKZT}=fipYS6k?tMlt0u`p!TWs9=OOKHK z!;Gx_89G`xT6l6J%T6O{Hm|zQNm&|$BATf~L>uk=S6pcn!@4FD4K>m94Xc2c${-zd zb23c45snLkyy>2RizNhS#Wvz;rhhL~)GAJ8SFe37Vp@SWVp=Kv`=T;wr66| zu;m)Ktczw+K;H8n1`8`O?{p17-e9-yi8IZKv{Z&^@?X|LS7-C(bu^iaGQi8nVf%O* z09in$zfCWuIJkhOM9nRJPY>2GJW&Ss@HAOk2T27*@F!-6;7Gg0xz~8J&j) z9h8uc^KJgGS*$w_EA0a}>qN9Cwql8d6NcdP5GqeLOqeFw*qCvMMe6n3G>wg4eKoxU zHOy)2AyWqGOpToAHkJjR7Er$=+G=b2U45G+)^?e#a$f2Y4F1sK8hhJmjN@aK`Qf96 zz@d&fpcQ^!=SAUX(cT0=2ar_zT20crh2pV0dED?xG0Ohxe@8_3L_x$}K zDu-`?n83Q1KdF*evAb(EW)S)G{Kfk`!xIq^|Hd-C>p{1gAg5iaV&0HUjU ztn%8g4-c_t&l=C}hooAHuijsLBE7Vf%&}mCejg~ZZT*9I$NP>7goED5nt=Y`yc<2+ z9%l8T-T#7#PGf9&yFWMHM=@?`wL%al5a)((!k1tR9O>4JV=Jgo#3C-z*+CZo<$*W( z!MMV!Teu(C^N4q1U{PI{{vQr{52~>e$UE~f6dAe@!zvCMEswxQ;7a* zLllDugC&2mu^3cX^e15dYDW~8`m+q#uRjp%Js&#$y%ZVbzwrz5H((De{%?jLe?Ii9 zmgE<7|Blxn;D7aQ_0Km3{@+>r@5X?H1o&@rn5oB;Tvf^+yY~x9vOzgw>2QG3yaTX? z&f>e4+CN@e zW9bv%5zYGe!8f{yAZO_?H*}O&)a>L}pT0?x>~%>Cbfi=MZ)?6cX$;M{Wf)Jx>LLUN zngv^R(k_FogX-nN2+6ej!vs1zXsd3?O5fJ{o{7>{TJVP8x8@m?mjO3X7O5vunF=jV zKGve^3~gejO__WVx8#~Y$CxjuAE!qv-ekZ}{b_n>SCdxFz|+9`YDbqUGn39-tV?`= zpoxmCij>8T@R&CyLk|pQX1>pVyQ%z zfmlhnt2g8&LBO=3}&1o_pT$(ua;|wg!WYbUTX?*g$)>%yq>hKpO^NH^ITVBZ8xm7 z`{3Xcsu$aW6q*cD-)b7L@v2vlYH$1UdY-~^h{>a8aWi~=UBjs0l_j#caJBQ>g9d9c z>seX}*T|H&cuSrpyj#x@eG6(#=%EEQEs2#I zCbky)Zey-H9p7n8tXt-g=s>{ZYl7zYIrpPpUX#04-&vPt5#g9RQF``xja@W<-0!zy z`mdyA4X{lroV+^AZ!*kCVth+Kv|O}`WF|#G(5$3Es7MTmo5BmK_fDd{J41paBS0c7 zLBu7GR@oHiBNmt6oWZn4|D3gzT2{l=Zq$RhxLjGgi3aBtUUnF zLoqxZKs=tJL|wTXHa}M5u1?i1P-}>6vysZ9BYY=UU)UIGM9tDx{Je-du8Gix?;)>u zd|e5vH+8#ljsDYS{gz?l_+n9hR&`#=d8Y+DDAdxG#NQ!uhr6!|I_@o}=S19&jl(s7 zk(SW&2;O^8CIugrHq?Wc`UjPBx7_tzX>f{8*IrhgkG@l$Id3`(-$oTgsKY&Z6ie@W zEb+^lPZ$x?MU9tT9Db^yhtm-fniQK9d&!CO=QPpnj2PGPl+`efCil{nkg$CL&DeD| zAS$v=yzY$}nbZm*(Aq-I2OWFzo*PWOI;XlSmnCe@#wVNywGNw7uWkwr6S`Qx9ta3s zSM~xX zhH&Kt%8POP$jBU*A&OF~)usk}%hm!MJ*8_lC8#1pZE%6<8xYj10u~nITtC@foePj- zA`zIvxMz&dwvI|1qe^kL>w!xVdDEWES9-BF_PGt}BHBe>N1b`%Wl3K#W*M%CZwsW{ zGVi2Qw5IPwXN?(hS8zAcrzq1@{pfB&TuWSyB$J~h^J~Hjsi>UF9gN(z-a7smzX2DH z_Y7flUvGehQ@wlH`>aq!)33S<)oExt{b7f2f!(6}fb;69M@Mued;j7YX6`+!EL`kb zMlB?l;79ZiD6WJ+`5$=$=wEvS$=`be$UpK1|3_}6{#yj0f32JnqJKUF7XPW7Qh%hJ zkbim8`Kz=H@=xL)Q1RbOr=7n5Id##OQ(o6C56^jFoP|x?sRJX%``)sW{GsyJRn5?b4ARYOq$7VjSeLZS* zBU9q3gl8Laho;de{F2C1PwVFw5oY8)JP$eqsfXeVEz1;#jZrbDPh5MXN(UX3OQ@MG ztiHZ04o}J=E}D;7u~o06QC}o9iC!7nJd#oz0h_D0s(gMr!?lfcH(XCwdd$y*lB5`z zWpLvj2(D#~SYCmcIF9Ago0C>(zYg@c$R1GZa}lQXZ;+W~f;eG~;Ci%+Qym(K8dVBfR9Mk7h5BJ+h{H^s zQsgmF&T3EM5x`!!%$H@Q&WhPPOR$K{i$2-Kzt)lc3Y0#H{2(Xz)) zQ-!q_6zE70pzXK3wDOWJ+e&ZUw&oJolqF>f2IXwLfX|}B9!|fJ1!{xw37htmVIN32 z+Z#B?vg&UZWM^{fXJOVj_u7(NN{Ncpz=Qt*00960oSgSF9D4W1Mej=@Bq9W>_qFWm zY(#I-Mbv1yh_bRm5Os;@b#)S~C=shim*`QiwpJINARA>7zR%2eo|$Lv&D@*GAMl-VMA8aY#_{zqfn zju#)QuBoRjT*MGhZ)#W9F)Q>UA5jGA$o#SS^4I(?wwos`ClnKkr}RJZGKj># zdKm=tH!p*T|E8BoLH-IUhe-VU0SW~C&mw6kNc2C!{qH*Q-|Yf^Woq+_E(iJ9lG}gG z@|OoS7V)@V#-QU$hJ;81nzBEAt7Gr6+m|!)y&`?-oZH+T&h3Su)J{q3iOaFcD^+~< z)-m3Wj9h-pscQS8w6xEZ>7pvNNQj%X3S{FB5ObOS(GcBsaS<9}bL-BWj?1Mtep%lm z<$;8jaIM=@ytu-SQ@wv)OOUXh6}B7#i_&R+;8AFdbvN5BdoqaMseZBVl=G^*vfk=x zIqneYTI$mM<@Dp=g7vwNLh?j#InuM(A;DxlNu0B#+`i?0rurr+eC#IK zn1zfM1xO^7ylg-F3-3k%-aIsS+({RUxR^TVxZGtgo4lMcJJuZyIC^#WfU)8}(s>pA zt{k^@ECsQEmU;{jH0z(%Dulk(siV=a)3`7PcQMn>CmpKYN^7b3=sHN>vgiOkZ8M3L z4>>BBPAg&F>L9g?_EQLbpRE@j(PcEDuq;MSTC^a0WM#SAxlFYRl|Gx({w_@+M4a_# z;RM~aSyNd@HZ$hI7R^BU%-$+Zu5Gu_CtgWSvVH5gcFbbbxTp0{OjYs=_Q@cohE?}| zJ)mc85fy5eO(DSqWHiK&hRH)XuTtWx_NNZX^+d9F!xOP$DSd&P`tSYyi66xn6fXgN zVK^z1AKPyQ^uI`42W4rr*`*rCAfUJExm#JjgWjneeDW^x#=NdVUN6SDF3Uk0gmwpU&$Nv7Nss#`f}sUcJ_@Y zT!$PvQ|&o2RZd@Y`{9 z18Gp{9QgpkvvlEu%0m>{RIeHXbyD}p7_c7kI5X-=8(n@^3TJ3WY7M#dI;G{F(#Qlo zJIwf6Dt;oFTcI47C>&{XHqpd#$=c!WFaYLLTd`=D&n%&+Wtb-78ES+_X>d=NG{A!` zoK~~t!m%<&9m?=2_h$roMd6y zhW0#kh4IYVcZtz1>XhExYlv)ocnlwJy(bf&G|Y%41(nemyy=$mBr9owLBV!e+h*rc z&bKlS!*yz!lZ2k*{13Co00C~|+qVZvq#XoqO3%XLZ~^opIAde}*XHs=QbHgh1HFuv zz+-*2+VL=Yf`O|-hk2|KS3}tChdJ9|mMagKJGxXUyU3FAPU-C;osSjTtM*a3_?_Uj z9o+u@sL7wxGK+dkxlwL5%!wLjInT|W$?eE`vdGcQKG7cmFvN#>a3oEaiS!X{OJ2-g zoWns~(2Hz;rTB@@eMXnjv80%w(xc}#q@=by5#qUxTl3dXK&XpnL`Dr`WM!}C{qPXS zDafI{rNbfPRso5dIaE6Cbe>T9{S~@+D}U)5n7wcaEKLB9w=F7^i23icQ)z{OP~Fwu zho|NgW+8v*PWf91FltG(4g>S32P&ZGOcf0pJE>>UlLMI%8`|1^FC+HFHRXHZE8@15cNU zAXjczDk?pa3^yA}_3q<@AdHax7{g$=LBi8Stxs z@kDc>W=vFV*o>YHHHJD(2N~U;h25Q1Xu`Otfo}_r3GjTXaj+5B`73$=aJhuzue0Zw4KK{M#YCFdMlJ@^~fd@XCBZJ?-jpnv*-h5oryxxE}`0I{$|TQWU1SiF)OY6 zozJZk4478ONNn!8Uj&S=v2yF%kkuXttA#b4x(i)%69GbM{LJiV@RZ3kb(*u}o>#;h zsEz2~NekO-_&*N5!VM>?-6MCS=%z1!0qt=U|6YqmQQ5xm%1`W;+TG_(WFT6Q9O1tK zittwV>R3^RH);iQsGSAN7|MESL04X3i`~mE)7C#|G(Y`}mGVhsqgV@gI}owthAPO% zwU&h6NZlu*s))k)lP5fG5g(O`5MG+(IrrV@dJodxjC)Ox3@nWFHh8*P(Bj%}pKfSG z;@KClSyrg^FsuyPhSZuR0+*cQj6v|&Ww)f>7PfAoN3HX3`J-f-H&6({M>@meWE$X> zk@DHrp!&pg>fFc};HBqUc}(nRgM&vz4rcu-ExAJ3HnZ)dh@wfPczi=FR28YnGb%0K zn|>g;6grvc4Wo->n#b?yhN;Xs zO`Ix}3`drV$}V_FykOh|F?)>OsD^Vy-cPa?#l!VSH-Ch`YE|vjMmZ6gpi~wU7E<@G zlCuZ1kmuA$Eg^i8+Tl$Su%37Fq-*mOcIPPZBe$!cePeD-e^#1-iSr>5Ix{m{XH*(s6yoX@NcY)@P~y*e%uhzZjU@>3VLKKh;5 zQm99=w*dxvFaj%daS>ae((h1HN1UK&Z!OLAQH-5vlD(0vTeLDVK3jSa-7P0jDS1=T z-YR!$k#3Xkn!s&S<>n77wgjTKtd$NiYJGu|wN`46rG|sPK9K`0w{_7aAQD;=;Jzt` zK^cK)Q}(B>6REYul8TYzIhaCjbu2h%*4ZRy zxRWle71OBS?XN-0@j|87;$*jvhda_e z17$eq$X?iJgLG5a^2PnFKJR&`gX&uG8yeTleT`RG0$t|(N)B?6?$Pt<_kJx}z=D@%aK1Nl2rScTU2ab&Q1)d*?u&=#0p6_} zC$5~iB7*M%fn{VCJle|Bcgnn?z20g}es~+b>v3!nv;eyBP>**V0M-YEU1b$$y+nOB z6(`_@?PgwL!)!iebP#`CbXRDSCk!*$JRz;_rq9^Rw1jj_7U^)jbS<^uLh59Flh95q zj1dZA$_*7NHd2(`#F+LXc4T2_of#kUHRnmK2j{JOtZ?=~TDid(c-kK#p3cIzr?H{H zPx;f*h7TcdPvYA@l;c~xD(_EB>H4*>d;*fFG(4i`r|{-zzezGx)21U);Lzkk6^BcZ z6kG39^R?I~a1cj^v?C>xQ3$ap>3cRno&C5DfyA=yW!H;o7cC8^@~oSlMmd>Pqba*? zyczGkU8+Z`!X49u^tD*o*&Mf+syvzNRNja5HPUNO5snDx40&4hVff-9b*@(17x7t{ z;)w5ss=jGxx{tcU@zJ~s<5K{WQSfdCGH#i)yiP%B$%rq$QL_W8qWvft03$L*h1Zh? z)*0VNekQ+^-(#GcLO`+_16ruYe0M%5HjzV zG;8`4S#EvCHPO)#6)f1Q2q%LDJ&voeZv;qJ)Rc~%Dtx1_uxg?lOG3An!I3c3hJ8|9 zs4C|Nt7rUeyJ$^%TarJ!d_w7aud}_IBlYl!$=6ac9|zYRI$QS`^eryR3o7&A%KOaR z3|EQ!^@!=EMjDTcshrIc(m1`J3Zg=Ohm@3M{|5j7|Nj6E1M&PgR_`{kKR_}}x#X{)z2D~=L|7LgEA&!EvAy3l zjNsSeuGm}Pwymvx*@~>6*TK4FNI0$8szR#xFD44h(@|2Sn(s~PXCp3#nbklIFN;l0trO=Zb%aW*X4<`3&HG?T6OZjP40 zX|HN}C2NDWoblSKM{?08B|@zF_!YdL{EKAlC;U}D=85XL=`gU`>ud=t^C~C}@swgx znYQ9G2kr~00`jycESUs=V?=bdEwCy`0leU0b@ZmJHsB0j$*($cdw7<3tmV@5`S@2E z2Sz&%{zY048$(n$Vw(a|O5JhTrWSzhi0$_F(_C_J=f^l$D3CHe3Tq(|{kRe9V4i$3 zZ7IntmJkny)&CI;gWj(}3(M<~JR?kuHgop7F!8RSye7qC?Mi@-HkC7_IMlcoVLS;w z;)s$^-wE*!L2t1Kt3Id&+{HM=$^gebfnWjPr-;hIb;Qd6tkH0TwVqUx9suK(Ih*#O z(3BAe$9fX4LiQ5U4NJ@)0j!jeAS3&PB=>ps=r9#=ON&IY3{9d%4IHHTHV}2Zg9}+z zWt5^J?!uj=3;-wQ0m4i&GZ40WK>I9aMcs!~2!P^%mo^1Pdq!U?cnvUygQZfF9)vNW z%tLikgR4R)&ptrQM>mXY8!A+_+t!ol3tVrg&B5(@m{2fV^t^3oOouVR2LNr16=Inx z_^{KEK?3Fpzz4PV1Zsffkjfrxz+C|mNMF|1uycFnD*! z8lvcJ2-8%|Vc^ZHUr@zofnlqWK>ilK17aZg`nlz)`xH}<<_&pVy!XVA27@2m%sx1>#; z&gB(vKiTsu+dOjaY|)YbRAE!P2kp9S^Re`nd9tNUv{ z=k?q5)1S{^mEest`EuvBDgTtPqwOuH_cU4LwcGrfVIlvmXo`S>+BOZAj3fE6W+rbG zx%egv*YkBxOWh!`^PVQ#CYAi67rr}0Lv0i$27X`6)0ey0<{r!AhOC-)*NSe%<>#_2 zwtW|pmP*KZrL#g{hf$wMld{HPmm1}SkXXS#r$b7z(~j=*X;NqSJ^Qcxj=8|N~uS$Hs#T6d%b^^8yAH8?=KC0 z{eRohcW>0PrA}FkUH-IIo>O=EMn&_7cC7AKW6z(dU*moMXYQdZdVB69#XLT}Y|Y_- z$<^t;J|RJm_1ACuaNdybTaBn#fA53vJ5zUm&2nOM(LKtwNZW_)xs?2(b7uegIXQZ| z6*f=d{9zR5k@f4ut&LUNzkS|wcCNuMjrS^RUH{DM`DC=uxgbBYT;aw4rpDW+#DB%~ z7DdEI35jvm`?GJm?tbs-gV~p_Ycd=N`@TLnLgH{KS65y}SycV>MbX*(IditfKGJbG zvPkZ$L-lnv3AZ)38L!wH)>mi!&zZpyK2w27{5+%h;os^>C;u}7I~@^Nn)MchFK4&F zyqw*_h}>qqAzIVdf{44>EllxiGP5uSpUjJ?(G0&v6Ekx?Lt`v^8Z6B5Ycw`A)w49l zvMJoch?c|Z00000|NkPRQErLt2q{BLq8H)3jm+)8eN6CQ-F~MR(*qi}KHaDPS$FTP z6_XWQlYdT5X0ho600030|ID3bQ=QwIu94vGuEBNUa{|GFySo$I-C+_Of)gM(!QI{6 z9RdkDaVNM#_wN4Gd#$tf>RqQ!ogZ-3ct4Hzs=Myz8Fdi{Bg`^uH;=~x_4RTIxc;M% zWLzs)*dH#QAT9y+X~FUBXx!Hei4?YqWEM4t+SX3l{*&ow;Nxvn_$+c$6}<0TUDx9k zNhN`xxla1UpbsBz(>j|F&C=6z6?6Kotn9au>J;Wex63YO4D)7OHt&K^J~{d%v&O@* zHk(vt6V)ubRTkl@?pB}9vm0BgfX336y9rH{CMLSCSiPFtxZA1;m5HUhvLr#0d=Ft0 zP5jp=gZa>#IC;mg@ zQDD0@2^+5ZhuvyJ2OaSl=M`DVpMR``nnno_lHs3My*l$x%CPc%*7;bMyioA09K0*| zb0>UDzg=2wsIoP}Bf-WZgvfRyH@_#96*wbclgZo%j0lDCl%Z=W@DxIIH5pBcgDBK* zW}53hjZ_u{_viv5u0?)`L^RBd!Y|Ao$UTBu--5MM(kQKXhf*1b8JmQ>O6?s_T5WHyf>JX*<48*#RWb_~Re?SE zCO|1HnooMt*exRx$ZQu#TYN}sTp^ll{tfXaUMpwJM$7C|_1o*xl9MI{k>k&Pa>YX_ zb1D23)(_3Y0+-rrZiDz8r*mGj7g<_s_ACBH$QdGL{g^2?jhW^K5Q#T(XnCL z8~`Vo*wRQYS4fhR@+fpE*W{dfCygIC8jOxE&S-H8^!qeA)20HpYIU%xWNb52li22n zp=ke*iDeuV3NSxFLx4p)r7pO+bJsGKr#im#mf!zi9zv#$D|Ey3eD;}l-_sL8+Hdtn z!pl~<-WfUGT1&**@vu-7Yo6btOgK_&1H49=P5*!|Nol4XM?XSw5U-jSOQFVwQVmBB zuUlhUcuNFkj%!h+An~!GSgC43+YXAhhM!=(JRJ*;q^;+rWl%N#6*k~wR>4;^DAqrx z@*@>pb~&+9qNcvg61wQFN-j^*pGCiig;e~#vtI^+W)KD+O(uD4W!#-C5^PIEd+aH* z8*}kVI4k7jdImS+dxuf>JG(2k;@PUw;I=Iz5$v*OOjPJ@`zVhy#7?Wj8WJrpRl?%< z5bnFuk|=mM2&@QArD_*sfpO#6k8GVE-+oynws#P%$V;B8IzOLPMN`F|fkiI|qeV5y zvVm*#sVPmSl%5fl+Zi2PS-SyU?ISwq%A6)0LqHpH>f3%UCWI|?)q;%GlQ0b;~M zDs&K$-GRFu9U_*%I4 zx;OU8@GUJRe{Jr-HLAKE!aEp(o%93;Uo3_EcD=iL+T&y~mpvAw;d&`?q(s3R%6)p1 z$$yRGBWTY-`3Z5+04;n2znEl6x*VFnY&E(8W)5ui6ydTd}tFR=pYE!{wy;|Z7) zvE00In!*9oNse+L-NxLm5=C*L5Ye+j5z=hRb>u;*Q0*}=HJ%Zz*K{Amv@r^QeJ=&o zkjw7(6yd+KlcJ2_ZJgiJC-xd*!5e%*z3Vi-v_B|B#rvgQ$hyA}mM|XyVzOtTG#bkp zgtZBtOB)&hJE?1#cw^hXNn)8VTxY;utPX1^MHcf5ek+O|)cMGzob$pV`%WihdOF}2 z;#2r<+{oFa>rf@>2*Tf~-j`cx0zr(O;Y-Z9j~W-7!h(o?oy8<>QX#usEtvlA^UyG! z5=9co$90A`Q{m|YIZ#Tv`iiPX%bS$0S$9K1NU&F>CD}-nHNPiv*=KPXU!X7oHxI@c zT7Gn0$Q>xL)$i{Dr^Qh_Z|taHfFoZzCp?vsY1dr4d=15XpU*&ZLIgC>kme&!sW2LI z!3@%e<M>a*k$@f96D*AG!isQn&DNIx)v5gB*GqDE(i*qp=c|+j1;v z>$!I-i0(*ykQA@!)`gl?x@IiYvoRC*L|@-@0!xg_gwql=l<#!6eyn+oa1G zkTYsvY+ZqqnQ}&nJJCGBTojA`m#Nj^YF59 za{Woh4C4B0kQ2o9U&G;l1iAkj{KxZ+|9Fk_kLnBjzoEYWC)@oWQv5g7_s{AjoSc7q z4tSE#+HrO0rafQ~=3!>7M*yNP_?a5K{oZ-L%z-A*1vQk~vN5D}Cnel`cj>Ovn@iAx zaY-SD5;K=AyZV)5@(?EEoczB9CqcYj0vTM!m>)dg96=PZZc33q@{m;vrgjgd7)5f#% z3g)A-HM>ykNW&|utFuQ(0`@8dwg$|cNkCt=Gb!{i7LGpiurnd^P$6~fqDA>fh_@Xo zCxNvwTf%$Sp1IPUTw*LP*38ZMCu;2D)dn54)jp{XUe?pX>w4R{;MR=@D+9jsHO;jd z7_5SbNTCgN2~9oH*1W7KzZ0uP-6(W-m08ENouTiE$5ppdI%ab}Ha19-;eYNYIxDQE z4nCoA>f-xS???0nDt~NN63}h5>Ox18VWC5wq44!g*94tX*+T7z);)s78r>zFaDGC{ z)6R-UhCT`um;VS)zIWA68;gQPC;)~Gu3$*fWKbnpgK(0PGW~6dMc7*5cNEq(PHjJB zccHPKC8(|?gJ93UUOfJyXiy^vIyY1EEGVvEvo3cU@ip#08ar`1RAjA>Tbob_4Qby> z1v76$3ER0Le!njAucL|8sOY=}Qx*2Wh_DvlB=}WBHx|=M=)=V#q@A=;x)hbFUSBk@ z1aO^M7*eP^@T1?+yRRi~{#b!!w!Luk0Idac>b9nyWF9LZ zJ#HAA+vJ9tVZ^C@MNgn#F^s<;Ih-FG88v8q9>>`Hd2uQs#F*vDj}pbk&6d6i?r|{^ zM{zL0q$eaXhuNR7URs>|k^P5n6EaJ@crg{USC_$e#2${GF!=#CtpJ{y>QKWs_pyFY zIo=KIsMa;OpD(SV3CtN%0Ekdw&b;7rTWK-5b4qY=lYeB>X~vXK5jGVa9AeCNe2DWj zKL;E5N$B{|0@$+^5}gU;LZ6bXgaeX~Q_E!qYCrReLdNLOkR_Uf@tZ%9K2$7!xYsLk zVzBLSGGZOP1~+a@oY%WL4<~8R{=$Ogf`^eLL>oQVr9N`Igt71?XucOW8zUE6vyA1i+az?^U zzjq)*5G17@S>To)B;nB3z>unThp!rkI$%vHhrDB{{DYQea43b-E^F-Cq1HT+-`E84 zLCT6QQ?DZnP7na|Yu@Q?tpsxlyD}0hjtXes=8zfS;E~cYsid_e+}-vJxtV4++|Yl$ z+PmCUnodb`(Qz=1-j~Q&H)YfO)r!uxDbz$beNbMO0h=RU2DU`3Tz&2$yYB4WZuYu<&S zsivUj)y=YMZ4~6h+FErkJ|up$LL{yFL8Z~5{qwI;(_^F0rIgRXWD{lQfo=dce`F2C zmzG73cwfrOL7#?`cj}6)(R`ievnfP3ajej>K!Y|doFrYR zGQjoo!t2IGp`W1~ygOxb7swS>24~rCmM_n;YtZRhHkLPr#(KQj|%Em$umA79xHN|0lrF7kKSvDCO+7kpz?GAti_#RC)wVU~hT{SH&9uLkmq!Q2 zu*1C9AxFj!4UsD!iBx9M1UNB3OL#NWL^pVTJQ9!rVBTTfMbqA{2Wh!V#quJ1Z_9-B zCetwBRd8KHcfaFzx=&(EOGiiOv<)l(E@j4J1?NQ!N5N4GYLG^p-_Ye1#=CY-${-IC z4P&9vL}MGJj`((Ye4lWG${#2R60%)Pq}+sNQWRXk$vF(<+W$TRmHx*5KDvQ}GN72H zuoPb+C^BYz8i!U@PDJ-jSoKmo2%0*YN&RD-;8Ya7AqHzP@;1AuPDIF|$TUNHUwy%+yx&Dj zs}6G{)0JT$>709Hnui}6O4XVh^<=4j(wvh?>{R(*DDiAwB0MPKkl_|}j+4HbGnO-= z9SVG-;pr+!W?djGl5n{+<*bBF*xd5&P7EeR0AuHrB|U|n&i zZI`HcEkDTBlD)Tzzs*^&UaaC=4#P0&W8&wbh?WA@B%Ceh@PhW4$PB5ZzD~7Lr)K+S zJ2jT<8&^T<#d&fv2b%v4xktbmw*gl&*7G&Cf#pGwW`=lde6 zZJdO?A+qe~V_F#=Tvl>nwxjRyqKHwX^(?6m+?h-5laq8XIK?WwM82%R&EaxsV`9ohVvKpz3Rj=v z3)HMjYi4y;+{Tv&mheD7%^fagTIS>oR*I_2nx_>z?H9knej8{hg8cf84SoMB-D9F@ zodg0u4_7`qkNWh^@ql}6hb9d^BWXsin^V8MP@yO zD{c0V4`K`|2VdGBo-zXUU%YS%XT${cj0JrqO{d6Qx&AAhopEflQTuLHhxzl?OnYI{ zqPcLFU09zTm({l#rE+|??o`tqHYzmB-d7|f))5T-!LjXjDYM-D23bC7rNU10daJg) z8IrN$0wQ30LPLYLVQu-OpHv`DV7H|4;t(?@BO!0X-bG3iPJ3aQkZi)s9`OT>T&wkB zSTxk$>*%oA`Xvlrv-|w0N_Uo*vwuUc1&{%UoKwzb*S{vbpwL>l&Hu!+1mXy}W8B z&!{U4wIsgiY*&5`X+>VaRDjK6W!#br+!-`FGYF`zQK*gokhZ>lEL<|p^9V%@qLs?i zRuMNj7D(L0c?@hn9yysqrYrdNu5V;;*5u-jD@xX4*qAVbEPEwBNe~4wz2`G8#YLXo zo>SmTur{$^uVd3S>w3d@*(Y^_rOCM`C^~3>p0?5@lwdQ-WlGh+iIng79Q!k$;1jIS zy0XtmcnCI9r|eKNue_w5P;y`{3R!Dl5|{m!|KensVaiI+mRapMO%fuZfx_3Ei}lT2*Kz(?jsGg4WUmP3q5jCmWJ5-Cp4#HwFywZau?U8^iC8 z^HF~oXjC2elW3!T!y#&HXtaAltL(cS5^jtyfmp84Uox$_7*&@+&c@?)o*rG@xjl;< zL;$p=?=~vOpM=c)kY4TbFG??S%X#o>?ax&Q+^4=Y^lL3WVFstWXjPYENIf_Y>YSNQ z-Jk1cROp|Vy=rU{n7+59nr4LciLfj`nGoTRNW_Lo%vc+*u{-1(BX-nFj4McPlE*)5 znUisM<+9NDNPO%8JNCOn_mQ@{q^-Tlwo%t~N$BbxcGsf5ilCQ)({hZ|>y0y{ z`g6aKpL1VAyASS>p$;qP9Jgn=QW}Y&fiPG&EF6D zFRB}K79c2@Msu5)UWAY9DUpMGqymmkcGEA(Uhhij2@reX6)_V@K0vV`w^pNhbI}dC z`>%XmqiqqgyVBJ`~t0$_{02-ewj? zoNiw9Sn9R!$vW+PS@}f%4sh^2aMp8ltHOm&;=1%WqgnXn>fCYt^?t9vJ3w)^F$_;q zieO+tdh5D<7yIaK%>hjlC*8Lk5?v=#>kj9tN&nofmu;!%z9#a)V!&7^7l}OKeIj_8 z(%NMYuoY?wn@sVw0z48JCz4^N?;@ZEm0wtg*tpR-ZOQC~v_8Zw5+oIPZ36!eMC|pU zz3Y(=`jXMr;az>0)oyO5C3+3jHxS4YrUz{-G9nf*W9!zJ=iwy6H5;FaryHG1oy**= zguJ<=djMM^W|aP1W1?JJ5esF{ae)ES}i zOk3C(l7onLGh_g+$Ap`2&31ur;_nMBjiG9iBpV{sz(rsfI&)R{jazc;52X~WvkyH( zSHWEQDV=~|Mn!kL;m2@=uOJ=nCP8J=y?Hu3E>PeHy5>GQ=fISXUN(VnEZWPrgu|fvKJcK9v=S(VFlb9IB__a{*{M4Enz25H2G-Q<{CV>l$vo zz~1DKtjsy+w};mLs&pzeimW6{359ituAc4z{Lgj&XKElsl^8 z_%4PL+4%zS%lN*yKe>X71itFAUO8aQyFcDVpJn zRm+{CW6PEo-LR>zFYgALB`Vhkd>fZ@(o{w(NCybb60(Q%?oBDy?;gVc%(Rbx$rwTZ-~W+a{%^M) z{!M@U)A_moJos<>qn_jH5MIDi^|Dk|UY5&QW(RF)Rtfy4C0$|MSQBM^S?V#`W*WY_ z=VR9?eJ>m>6&yT$4(9MdaJm({krYQ^ZX*DoguWnJsfB)g8gb z`J4Ef!LQcY{&ZRue>V!>XJAtRV>$ElE8g2EiSSQdGQGQm6*S{;zkRwWeHd;B8Q$dkS_A|y0T)4TN$ZdeBZa`cIJ2? zf>|`XTMr>mE_(-zVEcsy-b}z4xQKSoji37gBBzt@X4LjLUfV7c5NVG3rlw?OW5gH% zGwwq?fZS>#nS{2p0L~fC_>7d{6t_mY{_6G>N$f1K^t@PWA zTMCoxxY_#SxXROSJcJWuIG-BJ^2`#EU(t0mA)DeDocHl_g}lm6IJwu-);(Wk6q!3q z94dw?qL4*AP(_z6%hooW<|*4wuzaE<-?ZsBBh0pW3&KC@*mbCQ$%mM#m3(?lL|(RI zXGHe^Z5rlsU6hZVb1)7VleARxuzmH8)`5`f$g)eUH4VByY))}M3=Q)@6wDBsy}$BF z>j#>2G;FDHW)zs_RSTv(+ z8R6{M?B|}@Vd(wJ!QWCQ^aaGYsZ8g!N{*P)RIBp`SDR3>Uy>)7#&Am9uAS0h3Uy%e`mC58y#x8_Pv1AVuNBK~nC%$G%-kR3dapeO)3E-AAmi5nWQ`r-zB4w_e zp)jzVG9*L%)Qe1@sy~WPQ3-@Za3@XGWrplPSJoeWBYbZ;*Sl^gs8z`gx7S!2(pRKN zwkUBRQ9GF@&UYToTl1t(hCX?HGk zzth_=F#rrFgeXr8s9^1Eg-e*pVj%Cl{nQW<5O%F%x~X@tWr`{!ZvFE78Y2psZ1GBX zje(v(;}!~PReKfw+4Ye9j-+Mc_C3(&rX)XOjI;8qP6cA1;>TffshnYpUF=7`79P~^ zCh~_l)@Zrel*GECVQ^`;2F^*Wjc~Xp?7sQezFYGO+lSdA&fkktg=R85-|;`FX+SuC zj)syDNPipGe|-dp)Ph+AqUVK$%Cxu}7n6!$Imj>uR#hV`nwwt3-AP2l^9^1bT~W~0 zF*Rrlu--;cNgnI4hRzDfZqXrl7F77>MGa5raC>uwj}}@5%^GVS_xj=Z%lq~j>r-XV zLe#Lqdms*XL~j()UMMCAE_Wl13^`v@q#t${P806N)wiaG0muPVYDDEtnqNkzUnQzar|`W85;QL8me>r3InW)USq4yF1dU%Jt>Sg zCQOj*M8pK+a<9ChqZ@*~!M$k@PZ(Bbp29}YPPHF`-q|C@{Uk;DJQ+{9OmngMI8hi- zSIR+*y9AdqOHRH#5b-lEKcBw&^}+Z^tzp426_d;F&s>@JU%T=jf>vI@za6yxL0)

gVB-aH{0YeO|CuavaQ<1?%E$BfW!cton-~8j+XxbO zX*zkyTDOrXzgm=3JHISin}&`YQ%NI6w!%EBu)lFoKL7v#|No@j`8yPf8o+TfqA|z5WSOC49mCi;WEqN1$G#?GjBX2KNExz} zDIu~okwH?n8M}-vG#JKmFk|9O5<`{-#}c7X+#mYop8MSA={(Q<3*KKpKfLevmGe7* z7um`gM&EEyv>Sm-J5Quat6AL=MuJ+l`XQ(wR9`1_b|1d zWZl;%rjDno{x0f$JBi!r9HU6VJs~+pA9QJIjP4^30)uUB5q)OG04UFbb0yVEADGE6 ze^ws|K(AC9=<@_u=Nhg2Nngre7+$)p_zr^1PK-B5xvU!xJPt3m z`}|EjnP1uUeM*m4V0}an;fdWqL>j+zb`$}-+y_0iYC}+iHk-{TE7fz$;S6|{yI81RAH4^lznf2bwkt>t&X;_XnM-r zKX-;MO0?Ig$bieNJJ#-Lxt=ddl?8ap7rk1hJ)3eQ$r!&@KsdQcB`}2RoPb=!?|0R( zZ(9}#OXSJjtC1%(wj0$-5UyW;TavLb(1JW3P6Rl*IEGiX8a2iC1DQmdFnm*C`y*cY z3k{5s!f){NqcplI#MkQKN?H{`aGNR>lHzN~hvz!nTM9bjfvcY;+Wk zWg}FcEGJk1ea_b1qo*aUlM++AP#5TFDvU<=lPi|{=2MrDvw!el=2hG8&>o~q0KFt` z)SiU?F_sUKbpmCx#EnS;-iul-!Vh6AcDU@DS$^#(8=&_rc32ve|FQ9VNfdPu({nkVK1){fbvtbM++L=&fW4B;S0(< z@^wgW`0=tRw%E*MvjjuB>9hX5Z0D8^?w9h0x+$rH^SvTS>;~--;=ojcI>R{+JVqHv zI>Fy_PXgcFs}RQN6D)tgJF0l(ZRzeOYxyq}j!s+nr?hb6C6%I(c-fhdZG8{P0}6*o zeCs|eFVU&BiC5)$S86s+TURavEzQ;V(2}!?X2seWw8&xVU1iC8kppAF3dtlo(ltVG zORl@++@MXmut99KO@>hjJivoVL!c>&aM38YlRhz+zWtv;Hn5ymVoDQFBr7p12gsFCHXOyAY zD#c&Xi}=BoZg_FiV|q;YY)J)E4UL;o?>Z&sdNWurOolhWKrHJx#L=9vxM3UUhpcN0 z_UO@U4Oz8zzMWIGiDbn*x&(L$*T@9BfHxPuxJ|kXFXExTH;vC}?Tvsk#45AaJq4|x z@_YzrjnC3&ofh6b+FDMxkw(hO9U-Bmdw~;%pNQAoxU=MPe4ttMN#B$T7hLUp&I0O0 zFe#%B<~*FIy+a4Mj-MSptN}~s{wecVD6`<2`OFuG)>U~z-F>41tf{R4cvpmaGuGpM zv%e^leJL!?uL~Oxr{3`nyu)yG-idnFu%;t-VALE`@2GhlOK7L|FGdV?<5FLo9#_`G zd8&pB=UvSh&$Y4l_%OF$VVS)=88t3a1S-x%OR5Gn=@ZpOSW6>~ig;%8Ys8BgRk}=Q z&S>%mJ^F~!zN12$S6gfWZ)=>~3K>kE4ejTe4aE9_MU?1Pg*4kWX_GZr5(F6-J?nHo z1gvQAxkk7na-huqQS`)Ffkl@OM)7`bckA5qg34lg*z0-@P7QNdfdLFyg*YKCsh&G|s8VNWlt63W^hr0SsIwJGPy zU6oH(T7SRGR?B!KL|S}lm~h}*U;4dD+w)9~2jn@p1XF@OIX!jU8qZn(%X&sweE5TK z!8W(eH~L>+y;(VlMWI5Gi{skt%1x!RF`N8v7a8>ODQl_*%OCPs+49$5*W0{yff;#+ zIBqz|&u`zElpH>D+k3u5k<~jqB6uEt{dM})=U;KILdVyOGa6(r| z{2~!cPsf?p!J?!JahEjjLOYf?`B#HC+%&KU15Ef$GrS^;*OWUc5SpiHLP&CItkf#PY`+TJQ2mz%(%&bPeB%ffck0w-}5d40!IXRhfQ zz2rSuQbmHr^4Y%f}Jvr^XZpzhNcYe6+-xnKmA+bGh#ky~X zxxLFC+}je)G^JU_pZ)Ibw|!?^vtP6}PN~m7vqJaoHSULN4^+IopS5Pyvw|Bv*7g(j z%75OpxOQ>r`~AMFJb6VYc^*}9>r%MUZm^23D8^25x~9K8TBC87WU00030|1u$^ z7fHo}!U)^8Ni%bzm*%XEyxV_!hhY8r_{0VLQ@c&I>pFu1L~eL*da>=gLizUJQ@DfH z`rdX*J-NJJW%mAk#xh>ha`HAg%(9sw)7N%*=EMB9%{79D>-U{_)H-oes#fe8e*Gl> zzweVI{=R1YzF2g_I<-CaclZ8y-FuB&ZnMt0ACK~^Ma#BF?&*(v`#Cv%_ERq}$(Pel zPYtrFx*qO5(XIb=)y}5-y-T0YPSsM5cyzI9=cB;z11r`=JqYadQdXQM|L)(q-ptyQwf)?V z6M>c+)ozJg?elo6yzzPbi{{?k?%345Cvxu!?9Bh0H@`d2KYRO^g}JM0TAv?kE;za4 zS&5KML7Z6p+%*<`ao5}TtjPFdW*=b_cxG{9Nv+MaqgLfOYZVoNYbNc4KDh8W^G#k>m?HaO65~EsR zr>>@1j!Gsxy8i9etux>)&FKqJSBqp=OldKO2nEJ{-sEdAQag%uA9j07go#>qA`?{H z(KK&7y|Kr}w%)tWsPK7Nfb6;X=`48(_JF%`h3Y0`F#%Glx>`*Y6%f5^6gg28X>MCF z+t$#wNPNKABaNRUt=s1vaeKJ}6|9l-Gm0AIqIqy}U$@F=|oN=IN`TqOvPDLZ|V0TZ;Lezhx=)1dZcX%a(YWd3`+d%tKm-IY!)6w z$_Ywn659AVyKS1>9jc<~wy6(ZdLZh`yxAexC;`Y~J20+^WeC%d0WnQ+rzXv-w#%!v zC92aAs28TjMT#d}24HGwbj+KsSofd;@xUCSr5n`wwA647%HBdm1pJa8k4=4SioElg zhM*5o==IxcM!=1^KryKjF#&Eqqyok%8Td5|1uG*^Y_F(e0OG2^j367*-t^Id;TX z&*QHzX5=e0B!>V(`}ee5+2L!4jX)`?b=hzHhJNQ{IJ6`F#~&w|9!Jca`8N~_8^_5S zW`t0(Cd;4+gRw@5FhaN~JE6$F#WjP$lw=({8OG8md$Pn>%2JleG8$xO?7J+(Sl)Zy z``bPDyxULjAMpL*`Qjl=8)kkDWhbr5xBKH^cWbYNKP!do389a2lD|J~`u#(1 zFcd zE!Qdyx0W)wxxTGyIbVeoDeZj|Aa;e5^(<5KHcKmUFD`(3ZJ_14%}yUR!c-VzBU{;} zb0km_)~m|Gq7%co2An7etah+tR;)P zWxtrpi&BB4x*d(=me$6omPTz7}pjZl?6`ajxVu@UE`d>OI0 zmq@qTL!FUu=NZEE5NU8xaB4iS@mqm6XA-)wMI^~Gu#Il zVqPic+4nMSl!!RDv9>XJ6ni!(<6=G+xbB=O<09nt(_I$V5KpOG8OuH>Z{)J^)~WWl zYtl*jyuQ4WoFC3lm+PZ(9`Y6GFP^~lpn}rH6NI|d$ebd6o67H2R3EE_Mx{c_{MP2> zOt+bl4PbNnG_gIa(L%WE(2I3Ys=*uA6prD@_ej(JiCf`cs zT@oQJbG~qB$E*wj4aUN5KzO9(%4lxCFGpu|SoWdfk^V2<7-$EifbYnNFo(9ES|fcE z;U?%oZPuACa|YWidV&2{MS`}sO<3*m`%DU(bWIMGrzq>#IQrup4YMKVYV8L6y)PI^ zwol0L%!tk9x69SpJgZ69y^2vgdLbqfG3@U+BnwuSO}q%^>68r8>4Hq9CSy@o@Vs|- zE!OP?1W;;h(~-Gx9!P{uh$vRsFF8ekL>6nlB&Tuk!6n6SDs1sLcRCU>-eJ90RJFF$ zJg$7+-9cpX@iHYurXV>C#!jc*bhXQ@od-pfqm{!*h_Gtu&2y?9YqjdT(fr?ZHm}cQ z?`!!uOK}zt2FAGwpB*ivQ^)M4@Gc5PdW_|+cxLy(Lm=XQa4->v%d5@FTw%suV9&Po zJ}}R!rR+b(K0i2_08o45g7L;Ykjcz*3s z0&C%G-e{B%Uuzz%3HZc^=E0<4@0uy9z_dq@$=QlMtKK$9@^>(w*mc>(X5N`N(wI`T zSk>L6U3zomaU=+^!#*8v6efG7mma2t9&-DZC^}?o&-*gQ(CAmf!a#tmv6GC3!_pWv zHw@Sf8&?wr9%8bf-X#-Wx5L8GkZAuNt0OU!UpYI2z;PS~N~jV8#!I{E0&2-!;OGTI z=N*-<4f6$?1=iAsoSl6~AH7yrN<5CM`vSDGCT;Hv7=XjS-bCfS#tJTYEZV)n#gixv z*293jraFh3%efiI=84@3U!>=3ttaW?&r5-4bZ_K34*!ns|Ls%kpNRVxx>x>RuLDYd zh5LX16f3W+{NIO^t``E(h5R4sH$Wx4vgM5?acAkBEV3*3K^+xTIX1Df ze$;{RS?eJZbU`&rQxonVl~(Qg2yyIdiFsk@s&x|z$UHsb>iM(&^7ZOV(pTFp!B}K zoO@`vej~VKA)eakTmLiuZYb=Y<@zT=-p}%qn?quT(NFYvs=$0Ll)jyz__2MRiPVpG z&IN?RP@s*CZUN7zTS*mag`~^T3~eK8M?et6!6b7k^IV0m-EQU0AFDB^+ztSX+0Td& zmMDog4j3@IS-|Uxy=|A@!!8My)31wi*!vcdU6M21PmcFqrz`BChws_KKa^b!q$y>p zcSVon9s?YTl~ZF)M-7?PnhK_2ByPO^{o&lCRE&t#{OS&|R(*dY5W_sOlcCbiMhzHk zBgNPC2P?Cfk6u-I>eX}RXWLq}-+qNx4@K-qV}@OuxNoI$=by)(&wX&kdOi24`XwNClfHYNNz2>$NPJ#8MNj&mwtHusK7(Gg(m|mL3Hi$dEa!1HCl&{s> zC>~F}L@~k3X1VZI0rf~GHK8Egs?JjJMOH7zV@w3i+zkTF4P^C2LPI{RMmkss|$3o-D9I!-B-P zoX5#C0QF-(JfBIiat;d~h|*9gjT2-5b-K7w0N3 zhvta@e~X;mdv1Oj(Zw#U{zsE!d`-sH9q>kfiy~c2(4VQ-IIAAlF7SwkI~Wx1hQp4) z1pSBzPxo>&*?V^b{s900|NqQgS6372wxt(I=#e5d21KeP2%)#oAxINMIttQjBnU_e zO*)|~AfQO^2mz7adlQsiM0$(Tq@6RyeYxYDeb3(eJl!8K$M~Ms9COY2%_Y6EF3R;J zVJ(?Q`6RmM*=)A%`>EU^nNW=4c%@GJq(VXiqF&^o* zM8V(Cn>j$m#9jY)E=@NfTdmj+f^B%-CmFE;OQ4k4C^HUY48oi@?K`{gei~`VS==t`n z5WRKkfr5tq(TA8qKpjgtaPPF-fAL5q(Bc<0p3!7B6iBSZ&RI`fue;Ix>1nH=m4m`% zw|~#b7o@LoJjV=CYKBfNN9X3WM8(z5l{C(m{@0g3ITu>|kG9{;^2n$ZWA#WBr<_ys zybx-^*^i{ul+CzmqP;9yd=FQ8rYo3=2)iEvClyX)ZktMIErCKAH*;i6uABFZ;Z22U&e(NgJ?by>vXlf`M~1Oj+#;xerptWElPV$My@DZP zqya+e^MqJ!-SovY^?OyyxQ(SiW8nrEld_YB%vz;V5lX2{~@H@e4)>x=JYhRWAojPmZ{&JA?PT}uhM^)A)STrD; zje2N25|od0mO21!Rq>pcG8B<(0G#OzbVFnwnY>TY0H`lZz%le+2b9!)M)b%v z;&kSiB@?>*IL~6}45?0I1+N58$90&{0Lh(Zcx;rH48?`da`L{Bx38(BUKp>`hmsy0S>h zYhh8GBKiVM#)d?-i7A0ypcHqmL0|u_8i{f(5#V-dZ9Lkcs&IUzgL`Yj^ZB*cgprR< z!#Q+nC1vBX24tM&f$34;bT-(HvAl!@obn*<*?C3G_#AaFM-W5s=S}{A7r0 z&}gv}%X<4MFh_eO^!zuRmWbiG?j)rBRXh9_>*pG{&Q)c`t4vsa8fM!nv>YxBC7nZE zG3%PmEC)!U71t>kuWS-(6D66&1#Iu^@uMAr#64AS-AEZt;y}KkMGSc&rSLi_76$>= zy2-##A@Fy2BMnk_R9kj$3%DpKN87O_JEN87cuF9N30m24l>n< zjlYhP7gnYixG`w1Yx$??dSV!#(d!R=Np6Q=f{ILQj$2Ll%&je=5u@?$({q#NZz>tu zRZ~yVmQ|iVBYZ9_C+A5B9T6lQ!CiwS$l7y)x8qTS)cLVIPvzlxB>8XGY7($S^uXHa z&5%yE&6PzD(IztasVDK;21+qyKUMm8<;`qyjXU25#wul201`T3;A3Xl2ezVjih1DL zKcXe|w206=cecFNryi*GN9ZqcY&M)gH4Gfk9kc>AZ}8^_Bfj*`D%5h+=)KB;aSX#C zK)nB}@`;kCySp}G4Ee*+(eGh?Kaux7(-wU)k>_}gaGl9iZdE2@Tk4G6BlsTysKJdZ`83a2}uTm&nE)0}s zqRA^N!}>^zw2vJ>-maHiiPl(qg^zVqf7ni!uR9nj+@O(O>+B0@VymMOTEn3-X{WU) zJ!0!#!%Fxe3SUxsCKgz?GVaF=Kk97~eCE6yi=pUNto-=0+a++L4({_Z71&;B=9y(D zHp!r1o7HFRL?X`?mL@lrh`36?*+q7HrHP<-Uly&N5PaKgppr^$Ae%{t=B{gDT(n&t z9LY^&&)~*;qYGX^WNb#R!xj(L4iuG5-nAuQAVJ`oMX(U7EO|afvN%6A=K)KYsb97W zv(Cevba1e{K~a7`%c=JK8M?H@Q`DO1tMoRjYZl7WXVlZ6SjdVyy2KumV>Lh^6D~&__A5iii%?i1|4)VBFO9j#c$b%M+q~kh z_@$doI<`nv;UgovG|KwE)o(9RZ{>O%6XZ)Hqf|PYrv_Z&ipUvcUD1!D0=DQ0)$in8 zK#$`|r;Y|*`^jz=Y=2<|PToqIrTL)pand*hfw!{w2n>u1?%}?BKEX23L$7_f^B90A zl~(4IZ?zKZ^UdbEAweE%Q<^mmQYu;m=D!sBRhy@WSMPlmRHK~D3W$B{5yYAv*vpQfmFd3VB1WJ5Ywfuhl+l~@F`8$B@Uw{B4JeOy!5ocmx@1XS85*(WfS zBx2&8tTKoj>j`_G2@rOiGed?w}AICJ$FyYv1bhQ!5IO z^SQ920<38H&llfSx7pfKl8{7f4ms=qg;zAo9d@ss!3Q_`^m?#HgSpwTp^Fq5rMP1pQZ+8VdUhl2ZIXgT(HO3d7-&e*lF3t&HRUR*Qcr@c8##E6G2& zxcfIUj%5#LUFXDU15S)L^d1`m_Ve&l&QoO*T+dff(e3wdJjD8h^^ZSHgKtjzpc5Zf zuYpN#k_ie+W)5V)U=YG^d3p#ul0}))Sn;=e_~o8uTjlSwm{TK?yfMV_(DBZf23o>4 zzBWqAx)Xz^vw}F_v|qpm-VP+%t#tSTh}5I3A6utq=&}meSHrEvrjWsr*UF}*c`LZ z>ks1AoiZ01#*ZEuO0ULEw9%3g#84ANYQD#I7Qq$ZF*x;Qs>I*4R~)jpL%?9-yEc$Q zvGVzaWiCvO5232k*wUD$90{98o|O^Vv^{4$AzLiND7UqPw;pdMmCN+^DWC0Kna45e zosb-57HlYvs$P!9!FZCF#pmh+fI{&V?ah+NyFpMgx1B6T{3M}?Vd$oXgzHh(IRP1M zVCuE#31X$_4#b-8$Ghgms@4T(C}=g(Q;I^iU<~HY!VswmQde&xGSVF-#Sr5FW9dU} zS#RtF6#-Nwn)-4agvo%k)eeJC?%HuBBNPU?h4Sy>M_rGX%V`_nJp7vcIT!IGcXJc2PR|so3=s7)2rT-KE5*F4m)fRQ%KDeJ86N zMUHXwjl0>(-l(6;^+#*7LrU>MHqo{$k<1&V+4m{SI|K1(yW~RVyGmukgR=1zZd2Ps zM@QTFoyxE_+l7jAu`sLsbNXHtgb62Ga_sRu5j~gD3WF6yu7ZoRamVY#>+8Z%I-7-I^~GEK(A2pzX0vUf#ZTOd9n}kG;3wP^E@ZBou5Y)lJWR+ z)3;`l>U*|nKt4Q>)<7Id5V07sOM`CXg!cq3=VY=VpTFJrsq80d`(~9K3(~87@yWRZP z=mHe}=d1#|_n$%kSLNUTJoEoig|s*f_DA1Lp%Q=nOrwk29FFcP+tT`%oFN%F3!(4U zmK(GUm#uf$qpcVt#&)Ep;w-?XeJQn7S(bsY%-rKH&sC8Kf`#P-w&8&emN;x?=Yfdi z-PI(s{zAhpjgP({*vY`Ff~zBbYyQyu<%O9R5sS-HVI5s8oPQN6`Ka_bOlT`fx9!Yy zG4_KzFh5!G_=lJwKTvq_CH(gArwJvp**aF2Y3hR9UPK}(SoSjDaKxA?dUMGzl4(2A z=`CLd2I~vK8dhN+<>n#y^`X+h32pR8JmVz)$t2O!xFHhxR?3D!^;VQ0f0R`%&{?-X zXV)El&8n(IvO4oCoOkL4*9w`l5RvVS1LmAvb$+U`!l71lwb6?zqiX8~c+2%&*LpG` zhFpmSW1QW<6dz(RVT&qz9Y?73RO4A7GexI5mE%uIq+#^T3cnT-7Em%a(pa^qJtXi= z&aC^G``jzD+r6Klr7!r3l7(Ox6IOIX?9y2~tfvCyq_|1=adA{T|4sLS&D1TvbxVkq z+Wgn!RMjP>g&*E{yul47_2+cT-I_E`GR00~k{ZF)ThWo1 zG|$rJZx)PQmT_aj#Ohn->XENp8(m$xzKU)LN2svOIjfm=n5gCID7&*i+j$U#nEkjc zN1t#)@&HGucZWX0p|jV(Dme8s3!vv#8=L(S?SUQr+<2kW8@2cPa-5Nv8tcKTxh$Z} z{4dq%_?NAzOG;9_DDIBMT&jT4!zPqOjM(x%4aX3N*Ir=fB;!z*eN`QGf_v;ouiiAj z3o1T}5?3$sXUz@(A$a9nTV|E~>Djdlx9j~_neRgwcGVD0_x;~-ppwS$eWYzmj=J31 zZbZp60?0lT?<6~1G>je`d*gn~TZ_rlvd zdl`~7gR1PK7(Qz^9`PG(u~tqLV5>g||MkhJl%C& znxT=9PNk%~C8SeAYG{xeB!`BPmYx~9!=aHbk(8Da(6jbA-}c_?efN9Lm-7c)Yuz7z z&wV}Db;GKCeuOSSUDjx_VxK~XuM(l_6&gQ%LN9#fNY=)NN$sG@ui;(Fid4jl7riC6 zM20_O$!?cSg)mvQJ?OQ=C^NdnO*J?vevo!z0E2H$zxh#uf_P7 zR_^qvQIfaeuly(gg6CU z{<`P;ZDbxQhD0Fl2BYI!yq>dkeJ{;zfcH@7nUK=%Kx=b}F5`F&`>yP#G7f!>V!7;e=&G8TG?;X*4Go*cISWpYja;xpW_#$TLn5r@gy9DeY>oS^$^=3{xex_ z7elj@i3=^3H0f(#5oooU#`6ZE+j7=Kn@B{%ZN@C= zsh`<2gUNLu?*>}{9w56h$g$U5pAOS@!$9h*t(G{?nT-q=4E$E`kij<27KH@yfaJ=L9oe`htUWyS={8*Tnhi+V$$~hO$tb zmKk}wL!AY26E*7C;qG~?vDieGW2Tudc6Kdl^@_lK3PSgFnlxossMD`8tR+q1*_8Gv zKEY4sM8EyE})z#BUdipY*T$Dx<_vQXnr71oA;jZ2ACPtyYp|0AsR9Ska zU4~pZTW$x%{8dm*(Q^wI%?#*yFtvB{sv?GdS<_1TQdC5cQoqqq!${OmoaWK@Qd4@y zQd8?}U*jluuD$L^aCS%ufg8UMOS@}u_F#&esaw7DV;k>_WJ!T9xe_9oV_8p3%2)yZ z!FH#-$Ol-<1C1?Tf!1jQ!(R2Ok>NYZAD+oDgbPtblE0~BcH9vS&4SBykb`s{SMN5(EL9QY&O zaWrj0)#E7(eNDd{Zxg0$>*aW`-^7du^TYa0Y2tMZ9nxw}f71T_bxS#*ta`sH|6v~u zwr_Bg@T0V^10#n94lee* zJP~RMcGv!rfg}OC0EUK@;h;EmJ~jJ(HZ^;88RoZ@-5UUOdgt{zV%0KPu>-OZq7$BH z`S`T3L-+TAaq9O44erAE5&w~=Yug@ql{S`sHF?9`%T1+>(Mc?(+6c-CGr08=d%;J@ z@2punX(}9MdqDOlL(=1-w)98}>pyy)#GmzaYd&k|*^J za(ux82V5pH)4PfX z1tydh_7*e4eir-u-Z~%97LA9AT~E(ECiV=}h`LYw?G_<}@mSwE`ERHeEckD!77YFi z)q(~7msBet_~+7<{~q99V=eeE-6{V-^glEHAHDZ~$f|$y!C&x?GwuIjCCXLpyz-k3 zyX^s%EYaCaIe29wH1e4kMD|$c0Ua-A+VVWQ_P8xY{YWPX%PkCp2PdYt7wmQ9VBaxI zj2jx5@=?*n^#j7TepOmm?%r-P`PVOvQAgaWO3Gu4+Wg=vi8vbLD7f0i=Dsg#e%Ah! z*WUvsPG&!IH#SnV^DG9>%_?X!&f-iwr<~$-Nr_oVF#eLk; zln1_;BoblTZLL9IgS)7Y1Ho$4O}yx+*WSP|obO8E1Er6Sohiig(6GBla{1a`Ywsu1jv(nW@= z-WQ|`0n_RiPTa3d036M*+lILG7?nX6ULo`k4QG{!q%>axJ@qu4JmJ9*AxkeDk+-$I z00sK%$^HmBS4V3}pRal-)l~jCVIJy>3pUW5;#hX8!Y%*B-s)p7k>?+DB>fM?Yv*V> zzYUfdMx%x~HR^dGhHdh?_Ac+nVwIny-&9f0MGB1N7}uL;i?xnt*ZL2YS-IdH9GHo= zv}$XG`F4uc$u`5;67npny22!;BH{(e8DpcaB1)D7k;oMfuZ?)DcLB$Z;w? zqF3{L$}4l2Uwf0L25^n0Z7a?mT~3x4Av4o!;(SQ&MF~aP{Jrk>!}0y&BaFEr`qdHc z`mb~>ON%EWij#}PctRX$FJ+A^+iglswbnj?A~1cO-n~U&LP=CE@y58uftrnL9K#BJ zma5Z^B|+)HEq2YkIP8k2C)&E_bS_~_MI(ry-ecDR&z$Wz-Le`7_Oz%LfO?MNnTl7cB2wu{D8uZE`q0}vV#n?Z zuBnjGoWMCBr~M{aMiL}lCPu>hp^Z}hv|1K(<)vnb4xhVY{Th5L6Nchd^tQ z?0~9!)Y9w3Q5{McxM@3XC?}!WsK{r5FZ~Tqr~RGdc`_1ZJnE#Eae~U%H%(~6qqRs& zNaSbI%Tp0?yS zeDhu5?gw7rObRu85!d0$`Nj`$9TyijQ5!#Jp-?uoTO#Gcffsh!$AwGS-7EZy6m0hQlW7C zlnhj{&-;jooos5zlPzp?d0p^KTE}^{2C}TQC{gKu2N~Og*vW^J}q5X2tV`2LNZfi;I1@pL|noGG&^PyH9 z6=Z%aQ?T|%>qzs>d7Gtr_fP+EG8@~SNtqhHTK9CEM>6IDd)WBz;7FP)DK>}dXLh9U zk0|(1NmXRp?zWbmTv1nA%K6N!z25TnO8X2C2dit6*!W>k%{Y05B!wB*G|PIpWmrTwxkhb zzjeIl;JI?o*V@ZeN&bT>Zs)tRJ;cajb8F>LF@LhCopmytb_|j&sD=B*HR*Q7e5VDO zdWm~IK&t`BhA#)&*a^9Vi z-doW7?TxNw#g6>jWoQQJN0dx^|M2_mcj371Z5S(xaIPDSp>Df-Y)4iiS(zYB8Zbv>Ox@aVzUdy0k zEW)-Uk54B?7npbaSc*x^wbc>Ixs#RJx0C&P&i7r3ymag^&UF>d846Q1JRf&&|o$7dG+LuY}iRa=?2j$KQxvg+>wUJSGI6=>NF7>%MY@1SaQ@Trk)^5I3q#L+RUx7wRIud@v~rksuDEK$wQ zllRHi$5i8CCCT!cfpV`?*#e0i?KOc<)(dst*|+N3-XBNUb5Mc`78EL$d8-FfrD$Ms z7@N~7FRe&h$u&xl%5@F%+EVo?MfVCrEsdpQ!p&ctPPq z9WCLph9lYip!I!u&PLiv!!_YaRwyuNn{p}krFHa`RnhlC_VTFl4v3S)j^)M{RkK)T zBPFg4B%rCl$Ko9=lBur3DLR!%Slm z{NL(7gbm+%2ChD~Nyd7Q_i<=Z7xTSD)T4)*WM-iu7=kwzSj^ftjPIxn_)fDq47%OU zE>WMblf-5(1suu?*El3t%U+-*WBmbX5{coimu>55>rfe;y81VJiQ(bnt8=!%3|oGo zEC9%lM=ZWZ8Su(_r$!gfBs41XDDMuBnI^#*1D!9~X9}4U9L@$%^|k%zBK8T1l;=WwLN|LhKb4w6wqa6ybt0}3Ry$jp<^LcUcwuxS#W#YJ?8GZBL9`H~`E z-@-9H#_9kQ<686a1{wE>gBIDrUTov`0DZnY_Yz&p_!f!j4 zqxF38haziKMwyuwWzrddf>7DYL66QM=v#b`yS0d+HeLa0)D%-WtHJBNXUw9J*Q}yF1M(tFu-Z5^G zKkko@H)BPm6FS`*jt5xou#f{y&{2fOL1{R<Py+XlPrhk&iN;*F0H?bLSmF16u{r zJPgNGUdZ`&H^!yylIxY~)}eeSU*!_(u}Hyl{b`*f&@)>fXc`^0;BG(lHz@=W33;2X zX&R52%@>yzMsR-F59?S@y>uMKoB2XxF{RPdwp==DJyAP>I@~V}2&M^}V~pHF?2~}H zy)Mk1I*`ypY%QNi4$)ztm#)30?sBHDCSOQwEBa_$S;<33nk!6+XrrCo)_r=u|11_| zXlgFG@r4hO=o%9P5J(Vx;rrETw#icL&{rAXS)HUiZ-p?A1;zKQ+~piEaY$>e&6l8a1ulg`SWEGsDKT&R`Zp!_-J z;>`xl=kM82U%hYJJc(~Og<}Y+U-M%hX0NVZu+CjJBgyk%@-@QK^+4resWP0%2jq;% z#oOlk^*MgX*eT&Uc35N2o-6(-t3ao_!{o&I$(F}qM}%HU!zZf79tR5L+m(0{vT2^i z_EywK=bV;C1bWehRp%3Zg{e|B>ueJIEh~A-z;k(VyK^k>R{@ZuGSN;22`51V8LM8A z-YvOaFXN{pKAFWeVjhFDU1UjZEQ%+0OMJVZ&kA?N4ad3h_Keiy-6k79=8TMe`l!8Y zLiG`AXq!kKFG)23Fe7d2k^6P{$V(Hzu-vUZGYfsf!-)Te3=nVue#Hpwtx8%P700960%$?<1lS0@ZzaB#&CaXucm>WUh6Yt$FNAr?EYg~2mczpLBXY(}3N+s|&O zh_Q=P>Ly;O_wf(`W0U$TSIRV)B4pM%A{)CIw{bT%DT);eIv0#|#`J3Vb&Ik4Qceu& z`Pdo3O)@fr2BtMRnN=1qm=ji`BkIvJjxYxi4we~np6ObQQjMDmjg;Cp0!ef9j&dyz z-Yq$-;FYvl_|TxiqsWdU#a1G*pTsufUOt0X#x}fXhKyy1B&+RQQBC6X zZm5p;VKx`tGIC^nppNHKaI_T->1#RT$L5baOZz4f^(g3T1eZ6SbC&7Y{gu@T2Swyz)&+^<1ARsf$S?IeP^6xR&x}` zAkXP>1N6dXLnF|tdU`k1-WKn%u_a}}y{{#K>;5vN=Lzt-3$m1+bn@L@?xYj0_&M0S zCLqr77L%8&6B7;5FUXbh z{bgb#76DE*w>{<{PfZZz9D*F zMubimikQ&W{Dtn7RiuC+Z4F1Y~6!4e4~_z96tb8;Lm^(Pn6 z=0?$j=BZOGI4IAD_3j}|ZsOg|3N5NlgM-@mw>2%jn>ep`PSoo&M?@g_39UaeLP~zs@z$Sf*w9-!=i^<^zx_-AOMv-5+qqRZ{bys70 zYVfZ_K{H7q%6ck7VM22FJbz4x{gLtTqcSh$p5kY<9ZFqKsy0^IgpDknu-K86&{#5x zKK&wOC9~@HV9J6%it-c)L_vMBD?(RB>d8Z8-cMzPkmbW$JRz}s()0{BExCJ|eO)B! zc$<9j3U->vge)Uxe7F_&zCjTAcnU?^cl|bm^_^_fPgd0!8^JW`3$+XF&R&q)|6i^dB^?39?Q55ATpJ z(BF4OL4WOvg2etq=@J9{->uT1f1|+(0{tEWivop#;&<%V1A%`J0)djkK)@X-0g(9b zK`{xSFyM}7`u_LJ{5S1n0o@f^1B?IrFH~pz%hp0xeh8k3!=ojaRn8u1PO+PQw*E6g zwkfi3Uc+f59bodR{`x0NY%$k@(t4qAtPM0Y3RUj0-WDJlBYMr5GVo-8e$q@OZWQ0U zJy<2^bP?aJiYBo%yis09B*>p#Sy^<___d?IJdLVc@3m&2s>&}s{Av0_8I>DLCv$Px@G@gv|E7d33^kMrl^k2V7A<;+sUD7~ zyePV?D`$GE9p`J}d~5)pd)~>989w~hdbuh-OKV)arqU@KG`~=TGMgWLuCy9{?%h&> zS*aR2b-p^A)mRV*=P0TRR3w&JU_!kKiCZ(MqN3j#y13gO$wLk4M5;-&u2Nz+=atqz zw58S^Y)N%F89dlO;1&Wg3$h+dxx|*xdd$V7S}8T+H?~TA>ZtP`?X9gpI`VcAv)=L_ z%}%&7;ZPhKuAwl+zp2}Yx8e@$*{eht9iCsd8se1TUst*ikwwo@w~5lB|!sYnLp zRg07F(|*AhiKlB-Pygf?i z=R|8A;V&Ti!!#)6JSe||ng*r7()}W@a*N(HyRy%nz)icRz7$D9DIZoAW0&kvkf#Oy6Lvs!%&r5cwpc9SVvMCdV1YAHOfM(z19u`sFO$^=KF!N#5-N(p*P8L# z7drxduyWeT^>_vARF}<2KfL}W72L(5nIZ0IlPqEf^V3)*j$Z8nF}XTCYVqzx$1RmQ2oi)5m`9b?V|~ zpn=PADdN7;;&gb~^(uxf|LprG_p(*o{_3YAh-nZx_KU290}9|MG&-|pj}@4((H<&^ z%*4@j=`Rpo4Mb*g+MiFr_e#RGe@rMk%syb2x81_FKhp(t!!pV|Su_ zH2x(=tGUf~lL9cqjuBt)hbihtd^o zz}2K<^i<)YlSO<7Tnj9v_zN>dKkYM0J0HUu*Lu#sjIOvjuHjIsBu4OfUymE=sxwl4 z==DA+$>E|O1_W*u2Wm@=Z2;KJqQwo2m|i;H5v@~JqG{+gvBKQcesSaf0;{w!FNR!|6iRSkHuEnpz*p1 z(+ZGH3==jc+exr}q164w(A2ISkQIt@)_OikTTwhzcLc#wqohflzb~EZ4Ule(QdkY> zZVMt{FT%UwyihMp_2A&yjw||ciqbre5;LVA1^cItE1lE0wRk^Y;a2ZB1>Nsi`Fg}qD>bgGd z_eA56XygY#%@CeyL`XX~oH9=&j5djA{VX}#D+Qc<>&Q)sT1zEqOnn;Ku>4*J>U43j z&leMkD$=pv?Ion6z%M#*{Jti_uB-%!ZzDH-gRNU?qcLf%0EwH@zbLq}X%tYrN8@*YfN|B^rG9R!VHfeOkAA4p>V3AM} ze+b-O6=4bU`Hl?23 zk@fro`YK*(hYAMn0d4%H?n~9bBYGT0c;F+{mS?9n{*A^KZ?mEM z$%AU+L*sPYjp)&t)9hUi-zSVtOBSH!urI~nFwOYwlKM;4Ys=1Fm~xZbW7;%>KQBX; z2cl!gCOF5-&X7mit+wWJb~}0(e-5&`OFKDuGAVrf-uy+@&g+U{sivt5&|ctXnse;> zjX37167|ko7<|7Mb{;_Abs_h1?&O-*kRdp?I6_5}Q{C$jSNcn!)fs#5XnrnRRhyJk z;*-sXPt-4k7o|=x;i2O#GlEAKV^Ib-gxjw0D3yndUn!LK8)|K`3ow~hWZ_JJp3Y`@ zc?^4qaW9h9^+)H6&P#0$gUS4W@)C5bh7|y0hXdU~Hks*qDHAfx7ed53i8M zR6Oac5%Q5TdP<|n$~?~&!@`hNt}P{B?D|$Y`F!E9L}7OB5@!a1C3xkp7imVc%d-Zh zle_#Y2U*tpriZn1+Zno`H2Wx3(aJofqgFcIKTp_B$ez1ZbZQ;l!}dBE!wsZ*&xE)1 zS(-fXipKxr4KC)@Rrpe%MEli44jic-+9;sOWpvek$$_m^VrxitjB{etJh*|Pci%@rF2g`|`kZ0a&4vP%56&@Y09 zjGBWv{Bfn)i5s6qOzM}V91c9VC+O{>L4H&ZO8^P@3{goap@j)6LLS7CZo*pkmfg=K zyiqsaVn@N=Y}b>9Ui9_jlfh@PjBMi^PK^b^6*$9qbj96JN!vhkcXZ_+{rUjQG`Xy= zYRRxCG&kV#c7tdgN-H&#flB*87pG&~kV^v}ikm+95>l5kk8n#W*?U^r|3G#*a5dzJ@Q8SsAS(e7o(#lhot$qtA8z+4gPq0dfoC z!ckBuawL&vKH;uJUk4yqYpBj$GUD0vvTHG+*=kV8vT$i=M^*2Q4sRN&@uG7zQ=o(F z4uI6#;&}MY<+|hzWYPyeffl5n!+KdwW$E>7w?)?K#e7IZIldPfn2}bf9!4`ekFcKF zI$*U_#!F?qYQRgYhB8{vmH#X@kgaySO#6j~tsE4hAdQTpBxRr;t5e=;*E8pV8u@7f z>vpUwEZ}GLoLJUJ0F5%UFimS`@$`@R&r^)NQxA^qhh3TIPst-ZqTCefRk!qB&7G-Q zA3`p}N^r-ljhb8f{z$-V(0RxQq0@b`Y310yCKcOAt3LdcHS%@r^G z`L_3e6#`{EV`Tilm;~V)q6-KJ^vQ_lC6?t1deCNQF@92iL8j?c%~@DS;u2Fu*tXS zc|$BY2&A${AFw~h+Q(}E;mJfECW{^Pj*Dz#>ywq!`#dfP6N3zxKR6xj7g6j52BG&`Sd^SK_lF>6^$y7|P&_33!wj1sUk6NeW$Wizxg~dfMw$GVI z_$*c{!7;rC(i6kHyg7Q?0kg?t^QX@do_h?Z6t3xYmx|==~JQt(m}M zPv)9Tgz9*sS9>Kp&Z+R?OH%GKnob_%cK?`7nk`JOM)wXQPO*{9`h>%rs=Pc zSzISLrn{|APP?!+S!LmO$TJx9xAF`I|3#j`!2ejD|8H;XUkCU*c^3aY^w04p5Ol{B z6D;w25Cj1Vi$j2SfReul0TLi#5a=!t_+K_R{T~1T0RR6oGsL=ml<1MTwc)oR*Xo_O-t;uN*8`OVX+1Qyo>)HM9Cnw3+6dFA_(%vdJX^r;F zyXE(VISu}J2t0N$Y)e|#{P#C!+1~#w_kQI%%`t6VdAWP1{d+b0yBvZ7JxMZ?6TVmM zyzx$858w0SPp&KpHA(Gh{p4!$G^S`e*HMms!DnS!!KZY-|KjE2Gx%Y2 zpd(wbCTICReu+h0jZ@jbPqt@sWObIXdvSQ3ypofL#qL<$eJ#spD4cq!@j--phS2wi z`O{y=m+jwYaKc|!lSL@zK-b$NcMW@&F`4}`SKH%J^n1CD`SRlAx4TwudNg%p2E&!1cUHeY1rv#@!_T9)8Lnun$|9~2NQ;|>kl_6fCw$rn(&TpR5Jo{P1H;v;WZ)c>w zVcu~kVClAc?t=9XXKehQn)v6wN?V4H<)WDrXTEGdylwAtEmN6)=lLZ0?50iqyV*D? zWS`cimC1^WHLmSCerWIA0}EAO_fPKPTJmV32WvLx!-Va}_RkJ~eKc?PE@=TVF7@EW z2ZC1#u&w|4Kz`cot7qexcO1xG`^4hFf!8xO*nKF<_TMK900030|D2uoHyexshN&Gz zjo7nlD@Buv5u-J0Qz7n3A%MlH71r?p)WOv7=tjOQW!*5`teseZ#P1+R%(sc8 zr%cp=!ig9C+qxbtlVw(JRS3h? zr>L)Gz`w?Y<<^=9+*5mF`=JdlI-Y$03DId!Q#281yYy}o6e1*Ksq>HZ81)MDd%516 zV^7O83!Zy=hxBanZ9W=3%Frpgz8uh^UTID67o!ozZc$$NaBUFp1T^HcLM^)%)jsLb z5bEFkRFsV-VOvcVHx^J$3>G^h{yOoO<9n|r^k|yB>m6lA{&867xQfoQZAbWPq{+hZ z$xY+Wm!&vDQklT}t8CWU6k#U;0f~eg6h2O0q zb&<+rU~Wd}^}@)KkMbJymgbq~P5XE?_OM#zm8Wu2tcFYFSYJN&n8nR`oPS%Dehm5q zPif}w_3$+@5tQ(FsN|UIQgOD@3e*I&hv%>XXdKjGeL0(^hDsmnkMGS^ZGsV_8Rywd zMic^JVVi#Y`$oU+&7{tTz!n&o7v@T{a`YMQI$>IaXN`V}%+Q(f7nW}Z8v;Z{8TNi8{H@2Mv zWE%VI^}nO14obcD@p@<{dv4wJ036sdL~pY!34?F*qZ_R`m?^UA3XggX zhs>z@+?Rl;87Y{!LC?K$pY!WOWU{UGNs!>%-MhC7mD6QNIhZld&iM)6?vc~cE_#{O zqUPP}K0;(^k}~``JUWzz`Qm^~qd4t{TC02`D05(uTzQ=^1m#L?m<>`IM2Gqo>s?XWgv+nIcg9(t8YpAgBHjGum}vRM@1 z)X1ETTbc!%CFplelipl6L5S(hPffr~;+=-QKcP+&lX2BTZSAOo@NFKKp1uisSZ*RQ zmYa=gmc^DwMSd1UEJ4ufReyKBL0a@OmFze2*7k&4t9P@URTJgjuw_nRqy*B+P8_LzQ%*S8dsY?K2h3lEYtDbRA! z%jIfXj&Ldd=X1#->znEN2h%KbP+o#tI?8_XNE?;I89@O6#AV;DT=m07xG9=&`-^U` z3EVasYrfltXTM#L2U2{vqoRrwr{0`7pl;wdDygHcvY|Xgi+>&F!l+aF)m_W` zn(lJlM0y25+C}@=OOj=VhD+`AtT~RZek(r;sl(y*33UBq4%*7!SvX}T;lwL}!!?R% zu8NNmK}om&fO;t!e<8vdoXev*S@StQUmRy=1TXdR_}%3F09DWO>Gi%}e__0@E2zQ! zwG#9-L5XHccgHsdP`JPaui)|-KME)4kUfkgb#I_H)k+lRjpqVBM0cOzaCp{PU|o)u z%~?s@%j3*Y71r||ioamRz(R#XXbvTten_Hz7~Y_I3Q*>lnk$XxXD>>7_Tx=vWm=TC zT0ywqGpZ15*S;9Udv=AqFfPQa=^=OA9RmZ&MdRD0JMs^j4|dp38WAcgK6&A-{Uyo! z@$3om6Z2t&`@0YHz7HmoJ2gt%SzoVxirxr64{Q|?+qpSheShSKI8dJf%~q6A&~q+-=1gBLKOS+-mRV0B|D;H&Y)vyxMi1 z;aglXmF3pwfqF?MUk>Zx3=vO}m9i@T?i=fkN}iY44;ZLt_=8|-<0iw3c@Jd*rN~CTlg$pd(F-KcYmW@Yj5C&`4IEMDof*P0cpnzr z<1YxX2?#tq^M-liKXQ3zJa92?bxbb;JWaE(@aV%`@md`AjgjY?MKG7#Nm*$O>l&m+ zI7U%9H2VG~;S{1L6;_x1>q0_7WDNXfgruP!^X9$ge4w6|Zg$w(ILlz-+(<@chDuu+ zD?HIDFixn&^>m_5cHm%#V^PRll@}lZilX7vC@ExMVWf;ynzKPY*m~`rRn;FTxvgsNf z%mQG3%g_Uj@1h!b^J!~C2~cbpDKk7gj!HzGANvP^Zn%c1$io0!8qja`#zcG3sw5sj z?^QjeG7=h?`Mzqv|H|D{>;bmQB;9b`()@TY^MF^8P65 zWI9rK>uyDq?(gYv(_L{&-_MN3CaF|0lHEo5=FA?duaXfm<&5(E^aHDhAMQdoH{*+8 zCbhh(jI}Jz#mY~dH6zG7(&#zgoYyeHyQxuzLX+gr9eLGhXxDW@O63mUL8f03D&?u#n`c$>?!C$<%N?j*+fUrFFgd3ay!!QhO|V zlqSiO2BY)NLYPIkeUMM7989q*2tV}_=QK9;&LM$7GKd%2VbNdxB^R83gJJe6$h4<2 zmGVW`FVBt_qlzJEKVuq>lH^}m1YSXqi~ccLw}6fwG9HwZh{={-G4FVodaz^6Y@c#& zH=RG7?;mrI;m7^YEgyj*6+#tWdeq#C%VE|D)r4%fuw!&ZTF6}|qXZJe@ZjJ7#4>Dwu0{TUJDHuL^2iI85 z6tSLsGXDPn00960;&9k-QSAMzKS$?Z)Lc=V@uH1Wf&FJgPD6givP1e0YOjmb%{nZ5 z?EeOd`?49Y?L8Hn_}usXi;dJ^QNOX`?$zT(#bR3|R;}d^c2Z83=%}4lFw0MQA7A1U zM*kMPzdbRX$7XUsOQ%)q&%KDQ$&-gpt zeCom7t2t_G&dfhk=%M0!=;4pu)9hv5P4|=S&@Bw%ob`3h8_gSw_a`xFCQVA(wqr?v z;iQXGueO`-x2gX2=B5(A(EBCcJ>2Sk7ze=riq5X|zH$EsIY21Cp z$Y90M;Q9C7eR{?BaB1g0feT#fQxZRA|Gd=FVm0mQ(VQNMS%PkEl|O&o_mAIOQ`a6i zrB~gJ@t5TPIc+vMUxlu`vwN|GW5?>U`rVUre_U&SUm)VPrvB>f-Cx6l#Dwnnq*>qp zdPjBQ;g^wtPF96G7jQe)Z&i8rU@7~m3mez$WIxiv$nWz>K|nbD==#R#{D*EGJUwsw zOS}L7H$HtHSb1!M{1^O-ETO1XGYJwM@AV+3(uNNeZDbrN(YAt6Nlu|`|M|v zI8{u7E=~N&m69gMHZ!tYe8K&;)Bhf`>7Oj0oYqo*C)AkH{Cha(=hy>hll31rL^mDi z{ny|4;oVR9Z(27lW9z;U-h^O=xe39Hv`q;5j(K_cK%=68Iw6Olp>`iIk97lU;L>*j zHrIe12e9b|u^=ZT1N$My#+G`fCT0pIX2yD!#-<7;=4N`9mX<&o%m=CqE=?){o8yz2 zmkl%x+}#OQ&<_prgb*4TB_#z``uZg~DajexdP%88IhpyzdMT-zpe_&cs3H0Qpc&y! z6UIiCq-!!WGsmyV*u-4V&=Si$y_p4mjfO_%dL|}VChE<|-D!ccr)JGEW@e_CV`la;GutsUJC2!gnVDi{ zrkI&=nHghdW{R2SoV%ItZ0)n>8;$f!ebX29sxMmVs_J^4BHL^$mSNxHnomt8$uMJ! z7MIGJE0R;aAL!}s@KB~y7_=)qj30e60)qHnv{qKHVoU`#Ale3Fmja!#geRt0WJ;y1`caJs9^jy;+@g%RTl~Urg4p5NX76r-6;xYVpBE|?Fe;#Ix2gG=#c#*i7Fl`#dtLnZ=1-p)Y&n{11zuOMTs*F+oGT^6 z1y=8$)K?D*$@XC)jrvdq`b{#-C@xKj_Y(z;BeGFs(V~pqyv$Y4Fbz`=~(Xp zpYA9LXB|!$Z@-Dj)UWGnaqA{DV3kqPzv6F1P>oN-G6ox`x*KZj@G`U$%(~LUa^5;I zD)l+Lh5|{=RI%P|v&wU@jk1%HZ#f%tjM>LQX0BGXPrmb5Ac%Kgqcr=Wd9j1B(-}<* z;k*|)c2cU)D>`az2Xc2%$q~itZ`lL}7|UwFzV^+b`q6$5oYdC-ZMB8WcQ}U#v$Zo4 z7U9m6f}&eOm(Q1-=MBfw@)n*OiIKQ^465r~2u>FYArY}EM}EFqdZ5-uN57oLL2AoG zI_ky8j6uxn^6oVnfrQ6|l{vt5kU}LH_{8o#ix1{vx~iQCRmO?GhOw{b+Fula(Zc}A zyP$p@^I_cybQs+0^jN(=ZWJR!qtC53{@kKa6{YcKrV91Q70y``VHcG^ZS=3XXNLK- z*rhS&V}P2p`0WPiFv5dcsXP_AvTBlNL}W7_WogfBAmsbUh{D}7)Z?X8X&?Zy5)oI0M zHv{QpNjR{C$i(Sm{z}OpOPD`U#%2)?Q%m^nvjiShtP7ec)$z0yN}yk5FA7#@!*1hd zOm-_QI3~`kbxj#JIAl+-yglL1=8?u`s|2uzsi7cve!l|x54Y=qyR}%(cL(%aLoi|9 zZ(`I2H%WK|P(jo_Z9gMvn2ocmX`}2$(<`)f0u6v)R?kBGL=pwH~IyQV_;*JO3eo`a_8Vzvw)u7|a$K<6sBlMfL5jYSs z{l;l|)|cW5j#2f4kmA9PA9Xt&iH0SR%@y=eK5S6zRffS zoddnn*@Q+=+{BOBuGeCtCOaJhoo#6f-el&@tggfAD7G{QD#ZYL3y7_>2Wcq@VcdZd6(B|;ktPygrYAo2^ppkZ`-bUj{`pu&$KxEO^Ez;3X2 za8JZEc&Vz9`3>1dRKafEMd7b~m>T&+8%|zXPOZgttRISplyWlwI!P%ZK(j*vhPe`j zt^=J2DTS_Ly>&ceq5j~-d%HxgYRmeRO5y>C<0;KyXE+#fA_aY4kxcgw!yaV6Hd#zuybwS735XmmI*!Q__3%x&zXd&S`-|w|_Ni*|BW^OG_cjvp2XQ-lA=J=Y@5^nh zTW641f_trRv^$5)g<#{Ca3P<3_r@SZ$<;otIg}6gMzQij;&W7M*wm$+C8kT zo;@Pk-vZiFlrTNsj@Q#p-bXFzUqUj4g9G-GD)RXdwh(=e4ql$ef6nX0Y(Bxx;0ILx zf?0C^cVnFUKaFv&e`t(zbNJ)mFeH( zyZ;H~_2^TdBdxnW^Yw7~Y@j1FVPKU3Z5XW#UzS2X0fE;P^m@;`vA7?v9>=h@+5$iewdLx# z)F_Sg8N43Wq5|Te_O|^Shm2 zk=8`KF~Zr{0=o8?C9eOis$(np^A3 zfoJzBT=pS#;l@?TgZACNuLpaOxOH`tgS}l*NIkOF&6Tb3=sST0F#T+U7yVC*@C<6B zFUrm|O{JObSfmkyxhM+kN0>Fv@!|XrdTd#yGTFYw3!UZtb_XUJyl{*V{BeAxw#hK} zpy$*h#1sS}43E>;L^VE3)*6-m5;nC8`91DbIY@f;Ri%>tk+yf7TbYD85xupLd!rJ) zUg8NG$SCK@lV?;F>m45*^TNib{SgS?KQdvq93AtqBZ3&@oF?XbgU6q^$*%cl;PT3R zX%1m-MPU)^)k*4cdQ-?hWZgVb)5X6Ihx)k_wg3LL+D3Ba@Yg;ZA1J=2Re^Kf9hu{3 z<~gMa(f5PU#bb_~PuIj{)L_;%1TkXzPit57snmY?VPPWC7w!_;m}7heRnF847*Ueu zS24{8@w@tqaDvK>(mqptyLvCCbHfB^{Z*xhB`ST7PqcLSsmrA|$IF5|(j&f(!G|ca zLf!N6f;GOcdYUtG&YbbbtDwdEz)g+&*)DCa(os^*a9bX&IeCr#Ky~u*kA`3-0$EJb zB|f>x7v&GU`C{X84%46M-Q2%8%$k~m-0Zt@n}EApS1H2NSlqQ2&5R{a7vPMGqKalpKXY(GEBB*&@{$kVUS0Rq(lA5 zG&Jmql}#qUk15bh-OpACPx=5fnIJ8w?6g*it{XOoS>Q$sG1n4)SNozrIuSp94_ONB znP90~$+BFg7%wIGP4sr|rUAE60E1Z;6X2=IQaUmHtHj?2!d;7Va>lTqSZ92`6;d3| zT^au>H#DujzvG^vr0jHkM^X`S0TekVv|Rn;6j+Pm%c88W?;`P-Zs%64G;3yQNCC+N zaXyuhVF}g`qA17f!*Umyy7(5_I}y~V_4Syhx1jc&PM_F|e(Qq;k10!&b1K!SVKz+* z$-42eCUPJj8L#>(yG0#$`B-9Ls4r1o)c7iBp)fBZRtjy0^1%tf%S5rJdn7L5ixl$V z;H|3}w5GJ+j9_)bYlNYF2~2SVjE~|C>fn=IvZ9pMD9ZM9Z18#Nl9Cjs3epy=XarOJ z>w9RtY&{XOn~^TV$paf>l~rer<8@k~50KGweb13zWDMv=mD&X#k%Y6S%&@d;(8kcG zJbIlGIA1`*f&5)q>0EaDUScx>bX~j>+u=hO7nR@J+oT=qhRBHu?5l9JiF~oY-%M)y}R&iV|RC zcQez6&yab!P-5w5ap3RkDo>~y*2u9na-VnPFqlB-Mqi>^hvckuUSDiz|8SL1@t2M5 z8k+~H_?D0~(kTrj-40=r!#C0)6ifI`9H!vJdt+x=A4Ysxl{vLQ^q)+t;uh z8#ls3YVs+_OOp7tA5xhu=BP6}C!Kl8Z09Z~zc#|ooPy~tfMeWH z0*6f)GFnXPH-`>;9F9BrGAl8lE_+q!EHMgx(^+1@E`nTTh;a*>zLTvb5((8KmIhtK zyf5Qm6(zoIb;LdR8pcJ^g=BMGqJw8+nDUs2>^y?jKJ7Ip9`d&gp$;>Hy06zcgVA)R zs~F${UYual*!fkrEJSA=4<*+Qh|@s8?BS1~%WH?cT3MOh+G0nYnL0nb$Sb@ z8`WI`CJUjDftI{N!1|YYxs77n?UMo=Ch~ z=)22xk8@(ECpd9#3u02`)+pPs5Nb-GQ2jb)Js~KBkC@fKT4~Kx$SMb+O?PKpW|vEf zVCEsM*qp#_J@JmMz=Ao~9~ufF(lPi|5)HB)!;;vNPehxxZhIiBM{~90o3QdYrA%xx zR8HxlUi|}6GnYqi>w->8dVe&9(n^kbFQF59p~|qIAUzfOmhb@!T|P|d?9TQgSYLdM z^l2O|IMxjfP=y(u9@b6_+UnZaeX_0&{+hx&-qCU$5(^LEh!Oeuwv- z;$~WJEP6f_Gq=r%e(_(YasgJzB&%!LS?R27p+kA8tmplq;j}@Im!l{hMeek%gP(}7+<9nm z0wikA#_#qAt@A`uV%6q4^~UviI+T7vJvR@I(+*VhqT7W?2@T@y1C5p7KgZo$`K@FT zVLJ&freg)xpj6zg8Xp(|qOT{s*dq_wPafPL*=} zg?8X!`Fk8EJ2w+I&tEvbJgk2YWM^k%Vq;A8~6# z=pTMPqNL>%CXc?U&nbMY+Y2nKI(7kkp?!%Sy!`?Bg5ir79H|1Br$6L79Home)#YChyF`+s8Y9;s*CQa*l*Ph;s|}T z8kM`5+-%ES;Q)Gx1vH|TH2rfs;+@GHZ;CUE_eX#1_zO+w)oA}}?3lRM3G%h|>3P9s z7Uam?XEK*$`X*W|Y9{{TW>Z3?v>B2O10}~^1%0U}1IyRa8@8o(*-o`ATIjT8512x| zdL=~8+#E?)%qD(#AK*Y7wp3#?l8VT&g4~=-fV~*sP+cxc+|>#bwan|VHAa$a<5SPC z4}vkLuZ-rz+hU5APo71Dq_L2PZ6Qbbz$%Jt>{BR;;*ID9q;m*Pa=U2he&`S(27Yr? z)dQf>iJ!_paEJhf9JDzmeK)3LzL4ukLPA@QC<2f_f}w_(zL9aEK2}@qDXyspNlW%k zuGl9e6QVd$yvuxhtUp}RK;O^C*1B1EcDUWYXC`xMV_fB3f>zAN#+*KI&d_$G0@~w? zAHfQtTPlUGdK*^iF7C&{90jfhn{7NHb(!x0ce88{|xW@? Grv12;H>2MVX}Jpr)`Ub+Qc1^ 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≤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 Welc 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

c)iC0NyvtHS8p6n|dOg9h-SwYMhXXymi^ugJ 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%0A%Sg0PuYtrlS(KL*%Et>Alq(W2JaF;TU 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 z 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¬gazK4krb9Z1!SDYRVwkMpD-S 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

YCgVaBfDlqh|jqV|(P9KE@_(AT9{W^G~?BOk`; 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

5$tm5PgLf!;xO+ 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 z z(xfF&B0^=I)mcGAYIvC40LhlB`?U#E(YKvKE={HQemk+8D^h{5G}o6S(~Wa?u%j*1 z-PzRB5EqvM#xSBH2uTPNDkLHQyVwV%9{_ssMLy@Tk)CFPjA&3aZrLE~g2!{BfY5W= zWQ4`XsrfThV_)?{1}IC3eBoDsH3hj(2pJ$O3Zm<=-Q#+r(kL-HF_6bJj2z)w*G`4F zcEI_J7Ab5}oa0^b|0UC^OuEJMw4u z?$44~!ogz_OJq$w&Pi)3<3`HYGbc zO1|@Ls?E7VxABH~c80A_7Oed)iWLb~MJlvGnIXk2vi_qd+)gPQ>+ze9e|1*9g4Ki& zNc{PW3_vP&)V3aM2ys8HihK0G?S_Xd9 zw=tHv>P@yXO0-PnapFVi)NM_oA9u)VnkTnEDoT*G%n0fUJ@YAJp|#?(Mu3^fZ~KN7 zp4Zpd-#brPhp?73rZmA*MW%?zOgn=H$K^$)i7;EQXuF+rj&ODiAWQ@yC zksf*jlS^;mcgJjeOW@_5(=gpM3B$?9C-2k_JDq4gk@%xOg?bPvd4B$JacL`0K!sHj zqY2v@WN2Ol6PJz%?6l?Y;s@V3JamCRriPQH?VoB-&8Mi~AOC!bRYJVo6Nv%nT9FT& z`2JVtL_Zc;7R~jZpX5A>*lT5?a#w5#W1sD_rz>KEPXZ1y1+2p%>lXL**;!dVd7^uK zJS}|nGNkP{=<M1v z`$q@Ndf?6TnV=EgZ`pVqxl`?@ zt+M-R|E{WW^JdfCjW>C4?+kI1JNeKx6nU8HlX$2_Qy?&+eN&G!%Qx&O6R zG(GtT8PPHHV)E^f*rWFZ0Xgf}B^W2ZY>r^qQN+#Ir^ALOVwkTNC0!9t&J0LChN+|i zI1QrZ5I9PgBn#V5?L`q-F2jmgQz-Vp2_`K_w0iF18X*BAL2_=%RYiOlhEA66EDsA^ zg0+1iQ4w2vMv>NuJ}F{{~m zDJMMy2_SIsYYx<);c2Urd^>{*x|{1-x7KhRsYD46hR!jq$upZ*jeV6MEj3H>@>0AK zPVrJng#ggHQ`a04smZ=vlVjGpNG zfR_1^jvU7v&>~+-9b8;Sk@nk+x4$IrDMvmZ@Z2E(TAVm)XelLhz{Ds%Ja92CGO~(y z=8HZ7yEd~zc%fq?SAoC5QLfTV34Ck#YV9`If98rg^e6=)1n~1d4p;qO7zB%uU1QL5 z$HUlMRJHQJywiAcvCswH%K1CwOq#K|N}fmX69~|yv=$3}sTf3*Z(B7UWzZ*%6UlSR z#|G^QBGfsHlp~WQSDY22rWX^p@mD9u?y7q75CjD@W@%^zjN_5DxIwjOvic# zQE}v2A`>+GSCH7`@)>InAOP>gv1EC>N3Gmbu%TW^8cBx0 z#kg?Np&u6j`EtJ0nox!E7*Y+gldCP?JqmR;z9@whfD{E`*aOpyiUO>;(cdTpk?Y>zV$M=BYOwbN^fA(ee^PB6ow`*#)<#WpN_&@N0?rJi_n&~3Xf3?`$y#2v5wZ1t(C0WbjF#F4c#_6v$%K@C+`B57hzTa;6LA&7x|7*h$X{FvT z!?=^;lJiHRatxY!R(kSO-reQ{wE5da)>;G58d3=LnB2vA_WMNE2JZ>tYQw8$IA^KL zMdY`ZaFC{e#?;#(0&uXIk&2I6ZPVY%`i4cXGswyIo0s^!UfLx6RTWRcS zdrFFRIS*Lf#9Qel7GZIAv-Mcj$B7kk3A5cta@UB6-tmDQo@7TX5251m7?t6NG0|lh zy5r-)I*Rw?5MRkN(wg-@qoF>uLYE*)W>qowRMJfl_bhkShdi-=TgA<`1i{f?(-;Q? zOsb~g-oc2CuB8wkEn{<#x3f#ay*yVmR9SIm4) z$KHalgP}IIeNay%?utoX6;f81>_gVQD?aOIRSDJPRvP~%XWkBmK&@GQ5A}l}8Q6wh z=8LMtQHRFg$#Q%Bx1$fIZ$2VbA}~>tAdN}S#Bi)E4YdOepT0ZJz*WL>4)eVGeS8X? z+0)swC;IczzdfG%e(_s@^6zDCKcb(KZ0RdLv`UPVxjGM>v>;1xT3Y#_AR{ul5uBzQ zfJu`6MbB0VQr!5z_cULbEti=Z^Tts5U#PqiIkd{_jp&h@9tpH3|42yU7H4~|r_-aN z300)hs?P}}RMC(8OVHz5hE(=V*)E$>S&H1Er~^d0aRXnAfo;)&p_y(e z-tUao9O_zzb%_rutP2vOvo<4GpnV|RUG;?m>b*1C+s&o_#`c~1plHG$?TZLS)KCiGz{@w+>9b-E8?zL3#EkpmL#z{-G$G&IWCD7*G~a#f_WZ5InDa)z0*Dib~7 z_V(k*p#~&W+MwnX&d)TKJ<|Rin@NP32v6*ENjs9nlSQAZRs!ME(^$c0HZa~$PNxyI z#&?PI@~h+1lm6l1!T0^=32!-T!qW@}gS&i7-hZK-=lrG~G$#+92H_WXVc3{|rS))F z5JmKh|9l7aT;PYF4fX~H=5;l{W@@C}XU}$f^zR-8AlnA~T-DimU6V&6(8eibP4?(_ zC&{lzA3hwt`}kYWr$9Aeo27uoM${y7{y~x8qnt@zGqpTzp!1y1ErK^NXfK?g8J)6K z=SGR*-`XLv_kNOO?e`SHI=0V^g~y)H0&oQH*A+YCdB+AVdr- zgskd@p+vP0`)TZ`v>V*{?aJui>BhFYW&3eaElK8HR8<3K>`$T` zdzk`Brb;}9M-o9&jw_~+EnN$>kSLMoUX9J315(c^`O4}PF*LIa3DM(cCas5L)QqF` z=78FsG2ly_rTY8swT6W`I|f-VM&1Z1-_wkbqP_0!W#7umdgCwdKHJ^x|NP#?sp%P@ zKZavJlI=A<@I+dr6$?#X7^Ma5Xdg$@(ps0m+w8I`U~zG(QCX7gw@ul?m-4%M6j55( zeq)=FYG4soZ&N?gexWHVU}@vnT`TM2VeV>0GLfEO@0E)&WSHOG7+WNerb$bP&f zxtDMaFi%EVk=yo$Rv(Uq2lp%sR#S9&Jbo-QC9J|(d}kQ&C$`E>i@|QjdBfJZ#+@C# zJ3apN_r1Y>|M~ZSvNJ{$1DQpqoHo4LR)%X0w4zfS1jGZA+wq4*-#Et^Ee=gTR=yA? zTA_#w-HxnDu^`cbZ;#&n^s2u6boyq1FMKJ~=!R~rXpW@P)}2va?$j46dhKl9VB-^2 zBWx5hYLJn} zz)>8%aZ3(7M6*$*Q1CU7D5CzN#DlbCpN2B52kBW4leX5ZCbq5@M42RrhU3s`3p6CM zB&cUehc0Vnp7s1S2+KDbj(`ONPdmQe@x^)$y;@^7xl5+D@^POh3v+A#n2qwZ z+}2nKnQ63MaymOcDmn6~tN$^R83wXe?c2>Mz_Mo91Oc3WW~-;2<7atWppm$sDNhkY z>4c_?T|OSDUx}P4;DT^`T`p<2q^$AK(y56~2;}F6m&^r0oGz9nMM z;kUSU@U_hbm(ODE874m>q!l{0&YO-V1Sb(AKGz>36CA??>2I9BH(c+;h3(=cFrDzC zf&vs6(+MNi6NFKS&e3&~1<@)p6#oSP0RR8gT{~~vKn&jRR~VXXG!1OalH;L6;bv%2 z6dl^B=%BHtlfI!1lWn)o_2+OBkC8)vDBAG zdX!{BpD~?*Wp6)w$$oNUq(% zubGl&%Br%Tmr4u#Pn4ztvB=d zrbRKXp0}0=nC^Yv3MOPzT^IP5{yT#6h_~ZJSM}A4q5%{1g*EDGNsMkFki>Atp*)DP z2%?@BTfD8n`6MkHmGVJ(++s^(OHqZRH;&D4R5T?x6E1O+)yxC`gqPhQs>}Vd@t2`6 zv-^5o-8L}K+mwkY$$jLWGf+0t@^;^XCtI#q!30DUAW6Lyw8mjG4Q>3nZtie^xR>os+9$K;7pt}QcJ$OijMceWVxfHfPY!UPhQ8B*961I6iU zVSF_3c64K>*HFmSJS`BLvaFZ2BA~A!9wn`;cwf&GOM}@bh(*ktD3*6V)ASnGqX_tF zm1L#4+`zOf!t%W+Qod_(Su5A}<8_d)TEc?h-dYYg8Q9`LN1Lww1F6YlVpJfxRgzYY z_;Z%Ou(ArJ5)u*<(3gleQ6;DXJJblKv;G|wg6#a?>LW@TzD#-8mtjwstx|NyAFha# z%w-)ZSdjCqcNH?BhZV^&@<~DzC3G(kkU4l=5#dG~<$u!y&4|9ed8pRY`C0w<^Xoy3 z#uSQe7|qDORg0^zF&NZ`m6Hn#52~iL2H;fH6eiaT|E{AT%TyITB}&32dYzxDT@^c> zN|7kAVoTmp4=^Xsa21vE+@GN-BQ06r$LI?OdF z*wf#yRxc~D2v$%c-?IZ6PJ!%Uj z0EoZPHblTu8TukaE_{b{gAe+2)Pzs$>OqemhMjo^+SmiyIRvcIq45h!hOluD*p0s6 zd#ezmfAH(mp~E8()2jt8Bgk6oZBHjHxG5GO3Pgge+JiIOw=Ay{#ts8C@0fOIo2r6!Z^yAKz*!mOX zaQA@(g`|O%fg40fvBk;WuYUq~6OO7+V%x+VUvw9@!3rqj?wO2hB%?A;gx1LhaC8IXX_M6@d$u7@u{*Q1f11-7J{J5 z(Np+>iEHAN`+Qo9kxBR`{U(Sz&|f5Gtn5Nta=aqK608Ea3*HG~{sDSR<|?f>XDO@B zbiMBMt3*Wur7mV&@nA4(iRB~pqpCc>Jg_%gss`VRhLpEfD>)h)=B46w6kAg~RU^W1eMBOZwcN`6%>7nbIn zlZpFnTVt)do7__Zvq;G$UD*a2s8_@yHq3*{I~87PjsD=+>ngvq57^PPq}b^xo84~- zWY||5?oN+i@f9X#Zii6Q>>)OL#>m^SBd9tjooJ3j?U;S1H2_exubvSIi>UQTlxfrETBL3?6pC{~RF;LVCf)qcH<33RJ-X5HNKg;u{H7&ve<;ve+#V&LxVDECw!RC|S;nJzlQV_@QkL_Q&PNL0esH25 za_Q>nU0Okl^jN|*k!q#Nt-SwxT-lM?=6HI#?&>w#1;cb#f)hsMbmZ|lq7*k@VNVm^ z1aOzwD0{3_{esPPzKpdNq^Am4(Ht{uSr~tQ6Mr z>u9E+WWGEOLi_NLcS?C+l3gge{yYS6kgFDDdIej>uCIHjeUGLmFnyW$f`Dc!N9k?7 z&0>{?b;?!vqJ~`Utb)O;6R06vM9KMB03>W6PhefbJn=(pz3`fW@ibYrGQ}ARV($s*U$ER5K>i@n%iarjAvqI>}UHqCPrN9 zL#(u#6Xr0Z`*hF}F9c`4guoprQ7gxpL~g;Mb1h3*)*$p`TOlnp4BLP}gNiU0qe6Z8 zc<|vihMzvXS%Xjd*(AiP{uliN3`KW%;7P#~hG}T>+=sSTf{O87$COy&AKRG(8&eNC zjb6g&H)m}Hy`Ei2&)(oBQvz(60Boh)C@L+)%U&^=a*k-7xZ4b2`S!~SlF?yieMnU~ z6#caLChw8RVDbBnhpG6=sG&wMHD;c)m zemy@fqUR}VuYR9rpL?rJw+Zb4lnXroLVFGWII#LL!!?ixy z&vU5IR%BaSY?mz>WFaQcFmL5qCv?pl#n7~za`y$wM0Ir}O zkYgIUwE}+VAcU$L&rX!AtL9L}RwN9VrZLUi)_Dac@crql3il%KyWh znkt4d8kL3CU_mv}ODld%IP5{4J4{LMIY4!C%H4l@IR5&#g%zAuHi&C7kU~UGdMNbA%D0+z zV;)+RBvCv@P{QFpV{r2=!<+`ri5nA*rgbwfJ5bUeXcWcXKtH*Pp4-s~(~7yPk>AwF z#hnIlfrixJF5JXNQ}*5mNs=H+Ix#59Wl*3?CxWkFG+sk>YCN1YfCIl4=c-%RPATHr zwhweKn!};9e4}Atf=LW>G{DHB-BykY*G0+tFCil`Kb|F%x*#2?!;S}(1b~1}3-sM_ zf1cle*)Wap@65u1xc-8iL}R8g?LK~-z~(eVELV|N?GTT}dflyR2nWU;aU5KOiTkQ= zsFN9$z(aPRUli=ZEf&n^^bz)Aj?`8G3_lZyzB$O>URZTZJU=ePk zu6L(jT)?g=dQG`$96sMDeCW)M2i+CTHc6t;aFQ8>Qa~L2=*lKfQAlk?CIH5@#A!lH+OCgj7TExc~+qDmS3(UtPeBn_w5I9*W~!Eh)tSv=38x-X`mBL(GqatSy7e3-X|tBd5GCb$B=4LSGqnUr%ba` zk2Vl|D#d}*Z7@U$uj8F!?`;F~21U#6q|+Zf8rqxPtv9T^b9W08w7Dw~8Cd;d7>n_U;~eyyyIBVf>UF?fMk22O3eOQwr6|os7x&sHxcU#6jEuJLGZM|CF)0G znv)Y16;%1AkK_1NU@+TEt+|Z%cqslc<7@6tNmNq@m&z{<#sdv^DN-F(Q%|3&(l|)c z!{HFr7d7?ut1^E-X{+I|TvpePqd`SUxR7eg)&`mUIORMr*OtwcDO_niLp-n%+bFLb zFc52`(+o!c4|G+XyGnX|IiqttJUPTs_RwNsAATN|$~+fz*(2P&{8Vfk{>JB?j?1MS z@+B^vq(2W2h3W7goR$%XeqUDE*U|6G&QJO+^>ktKa#^yy)<#_k%VgDEBJXT05#&}< zAi>+aqNC^>B6f+Ui*od{I%!(Xa#drA!^us?p2u8(7#Yk6DD+rM@D0S0GYd&M!qK#x zNqV+d56wk(?p7trMLq#RwD;z1cVA+_@x5|PyK>rs`Aj=EpXK%tMQX>`=xx(3e&o}R4X7|e$J9)XE+ z8A<#!&b|}z-pn`!M={GF;b+T{7m7bsh03d(h+kjI)!++q&E}S+Ha-^4EL~jA>n!Kt zrx7d#qurcGAS{-hER_e-zCA72N#3Z|tF>hfUaBiRm;VM9rCjFK0uYI9C2@)OOAi!%9Oi z&d83?uo?PDY;D0ryCGoi$Qsb+AZ|EXjMZv#Vc%syNK0^?ZnMTlVByap5iDi(=GtQm z@|ny64eO#U$!xQCfLX#hij6ugz`9%bb`9*F7uPI-=fpH0fJt2S1L{+CAo!>8G|3%; z7d>Ufij3mK_{QdM&WEG{Cnc;C+? z#?R`tdebTG?sV1G?m+ds8(ZD|vfRTzt2bY4s?t{PO>dyKdw=Vy?f3n@IvDKk8OkbC zduB(qyeHZ=CZVr}&Xk@;)0w~ri7DWH+%zbp9eFfjh-0{~>eALq=A{h15jL4{7IT2OfiaW9Mu( zKu!*d0-!+}c~$(Fd7&PKC($GWM8FynQ>v3UrRvTPVVAZSD>*23MqHO$@iYg2;bhqX zmOTR=(gs>#lb_6Rap&M=w{{L@89psb-x%{-E(FE+JU*eVIXykgp{?Kwi_-}_3^Rxt zW{_NvNt8G<_^lShNJ`Pbv{=|@Z0uuPh{S)(+?U|SNnZwO_de-@!pgtl?L^?P>~q~~ zP@puD7uUmBSIu6VM?;b-&UBSto1&G$q1$OR*J_gdN?n2I?mNgP0}O`@<{=9(Z)FxS zoQXzh&cT|jUpIIr@xNv^*;(elD9k2ZR+hFfqe!8do?KwgXcsG>qR2HdZ04z$*{9mH zD^^fGfQS~6L%m`5>seMTN_SKNQ1ls8UcG};LxQ~H*nY+_qkfC0pMoh|r%A&}GlezN zS`gV~0a?XY5Wzr2q(aSj1O@L%{P7UL$SO)|v33n%gkT>*qobxemMKzS-f0^Rsj!)$ zCWq;kPdH4PvkA>bWX?>Yac7)_!DSqc@}yA$dc^%H zCuEVX3|#?8Z|t`rNoRH+VBRb?+l#9aw0})toG{|H4$h)w{@D(IEa;<9f*wU1<$SxB z)aC3RY;ZQJOft%6sU#?*ZIQYrI0%P>vzEY%PVw5oIIzuD_^`o*8c zxn$mRI+wdMxiuH#YrBA>*p<;bdokq1*sE(maV%cku zjcH0#R?hmxM2ugwWbR7mtTQH|lz%+QR?h^6h6R}wpA=pnf;RQ&Ds+|}_|c)Ne$`*` zM)A<&z|*D2{lL$5b#;~hrO)iY{JZbh{f7U1rGa$5-&m^_v~w3T#VIppw0^ulo9j-javA3u=J9kVx$2u{WJO8-?!25m^*gQe znSMTs(-agDG*82+i!#n{UrUnME~g*s=KpownCay~h(n^&Yn`PZpFcHODd zJg@&a|NRe)|LrQ@qn-c!=YFGBJpa{ejg^%j=fCgq@qSUakFmq7c80X4v{@DhB(^dh znDDY~7=pEv4I&BkeXa=^$|FoMXw7+$B3!TVHxd@&>RuU+j3Pr*!~jAbM=Xz`<0}VO zfpY{+Htc4x&5zv`@eLhFENb9wZF;4`h%X(DUt68YI7@>0Jk_L|WygAsWB@{HzKvN^ ztP9g=e6AfuqSU(GiSN8zDg4$Oyxo02P#ZfREWy<)tHv>`y$M&2*hoK}29p%QT+X}h z{^naszwv9Y-y3{D#kYHdo$kSb+TPt)8)|Q3f6&`}-{07$^Zfqa?m<_B3+NtnZt1~e z6Ei-dV`wzSodvFJv@0cFPwLxXxIe)%e*dsIptaDkriG4sRiwu<#8}L-#xb1i;HIxO zoVzFIvRYYFgOD%v_u&4rtPU>l_P+rD0RR6oHa5^vaLNbmDAQ5!b>uQIGBh;Q1(r*f0RR82 zUE6NLFbsX)S9C~|Hi<+~G-+a=GVuVkK((xmXe*fZ^Rshl?$8b1ASdxHwwttWYGa!Q zYtx~TpCJ*jsxT0jHKu^gcqdF1k%6c+{B$L zd$JnFk%c{K2O&*PrHoDaFxmrKPynMXS9;lM>9bt|#hj6IJ^c`%kL$ zO9}>-&9Lm=Zdl4{8cT9mV&VZ0OGW!VaIoBV)oXg*s)1SQh&9bJ>yPYN$xnH`e=%Le z;oI9a(@qVGLR?OJ_Rt<`8)Y_G{lzfD?Ds57koyGy0RR7_T-y$UFbw?_pN%w&kr4H3 zFkpNjk{F-;cH3RxP|HAlV}W(uS$BFm2(#LY!OP)f1+f{OOK}W=su93h7IL15#2o+9 zc?v)KW&I7-y=%q(koYLE0(t3X(tAd^IWG(iL%bB*@ATI=|9e~9+N59|!z6;g?NMQ>cg+%}11Y|^e(*11KIK=wrg{Sa0RR6&3lWsM4d!e}VuJ1@NCo8s zG!ccA6wm3f+s>0?@^2IBhW0!(XGIg$TSA3mJdZ z1J#ct6}XTA3p}P_Z5k6}F4A}i#Q4-=1wGI*PhDW=9h?h^txusrkGJ%I1q;{$a!j|t z8|+3X<^uo#0RR627P%<-38j>?z!yVEngBv?%)x6BqGA@OZqU>@mX0j8Fhp{8g)X9t z1I_men4M{SmLll@&0ObUDPU3i9N>XIa0L%;#g!K&7SOJ?!s5t8^aw<$QLqjm7(xfu zG7NEzFu*L!Fv6t*)+Ed@#yLuXKH30F0$4I4s%K5XV+~jv&Zr|VrdUdCblb2OwkYNh z=+wbu&y;{VL`)Jg5f-UNSbR{DqE}iBs&_CeJe&y^vNTu^oS|`f8Ev!+7CWd~vr{Vx zL<^p{fEbvPTA&LpabZz`-$973wKXBfg3K<-PsWm`G2(!@au9AH)*1(?WrVY?#M3&( zo7-{w7UsCp96eB{57gZSEf+^=(W7-VL0e2v^pxh{>e%A3*brXm1FZxfFo@4iSm%0l zWyP?V|3@0Cq1pOx17ibo^!48+K;@(J|8xMI0e#0(D0wfg+Yx?=-`73 zALh$QKbR%q$)oC)-3j}C-@obT!C=d#Wzp=mTD({TNdURE*1 zSp!f0H#0ObMa%yt=0;|t`JbNae}Hk!Mb26u1)>)FC{Sm$j{;Se`zTOjy^jLc1wRT@ zS@EMl!IB>Z%GdlT5Wnb0f$~*93e;Klqd=u~KML3v{%CP2Xn{frv?m(8n;NmB1spE$ zqdLIL>VZiCs11IuU~y^*c%@Jn}PKUT+KZVW(d${HiTUf!ME~2bPLc| z-BJoQiAQ|vuD^;!cXbQC9!w5uYfRap({y;eU5FvSGphB zjM7C4Qnt+}x}^*=8v6mJKlXy2Sj{;m6FOle5kbyhjRJOyGk5o7%q=}3DT}DaE~bx3#mWHScz4LM-RhE7D0NLu6R7*r%yrZm+-CKTDF5cuDMBxN*8w zkg1ndx#qp|w+~+2DRDm6N9*=1ZreQwmVUZNwit8?}f)#ug zQS2b%OmPxKq%@3b9n2h;d`Xr+jw4${!w&s$annX&UeY*Gmo7<|&>wl{C_459|)c-8?Ki}+KZEM>w5dIwh z3Nek+j>NTNCw9X&NE{owQ5bC*gRK;kmo?O>Lz-?Y`}5PCEK8AJk}loohlpb0=<%K8 zTJqyq_uM}I=jF%$1TZO*i_s0EvxM4tAdtQ+tN9o4AI-{W4z(tayB7<$Ye787r6eju zhAOqP&?FlAVLyu2SDEp(2CuI2FJLj-njvKoBU<5eqC%7PiY?6NyMm+FdW^A@coY>+ z@yH*I*8ElVY`0Tb=W)G*gtoD4T>T+h;bB2|{1syKuaJ3*YTLELfv;BgAQK%-R4U90 z>~=Tg!2*0Zv_y8f8+MaO;6?!=cr7soOrem2<+t7(#;46y{9Qh1Nra095x0}apRD&f zV&HTK?A!x_cihBW#0tV9IW;}l`YE;Mn9M1;+XL%jlvO6}$ z|66j+D$+Y}NV?k_C3bwxxh?WY==1JWlB#c&R>~<wX=*@Wux*~bH$vqj94Wrb z*N#<|_>iJtQMR~QcB2RhL@K9%hu>zMsltj-oO<98bcY4>dWeOic5b{b5p@g9DzJ0Cw0#ZW!4xKv(QypOe-!_XzUA)BSIf+wi~H-M{C59mn<@ z`TL*aApdi$J^%Xy00960qD%V^xlISXa0PtddnKX)2)+#(d{GHf#{gJWgN~8UOUq0z zElQ0CpZ4#-h0!WBw6p}a3W204m^1^E=3vqSOj?55h6Z5L5KJ0@S}maaoOOt4Q{rxk z0ZjpqM*;u<0RR7jHlmRIi8=0B(Z-C19;Bls>6dBU2%k1w=X^~W`rYE%A2kjo8d=4;Q$l+`q|OZ??03m>?$hC zI7|O=^2gCPXkcXo^%PWD(S3$q*lh0It+zYy^Vs$S8w6D#6RWUpr#I{LRvqvMC^Ijz zQ4x$A$dpxvMVwbnq&O|BAW7H-|B*G$P!J}f>+v7T;y>GiHd${>qw-C9nib<9VKOLC z&%C^dY&|P03y@(ZsT;~cFq{qDJl-wmkcPYaCI7I;=Ya2h*lc$cM&0+ekFs8so93Z+ z&BAOv&QhK$~4b`s$$ca3KbPJFtRiW8Q(=@QHnR5(`G5^#S5?-V;A=)|)ThALhz|uqO_m9pYo= z7rplnPvh+l@m7z^-QDzIb|~}P-TY>=SsrHHt#=1W518fI!D{&x@0oAp2>Xi{qKfxW z&}HO}7&%RZ*%qF0zb6JkXl+D-w0L+}Z$txXF>m%|g!?&L{;Qeoq}v5xyL|-R-ogEN z5^rCY*qv}7TMK)+ z+dkg56!dbZe9hLt|J&SbH!!;`8Y5UQTb~R5OJk7xO=}2f6ZqT1ZFceV;XUyJv3DTl zpQg)OXz|VUh3`vm?(k=e+k*2EmNmDrU!kqA=2Yrc_Q`Z6JTtxQ)^l>hT-^mY%+g^z znt(Sli1H{ML}?gDWmi1IcmZ8+^-+3M@WgH1!EU zTwnTLKd#F7hbSAeyebCqaLCZ}^&4QyEuoab9UsS`OQ#k)#1B!Oix_2H!(y#)X%e(} zaaz@A9P_;}L_7>pg625R29W@y0{AcqM!ZagBoTHMm$6(YDjUIomFL`$=Ug_iNEy%) zlA1&NAx0Zg92Q<=aTpnf1i=1o#9Qt)w<*Q<2GNj5h<{Pb2XP^ElmJPRD$95qlp@E} zVoKsl1zY)UJgH(4K+1ql#(6&$Y$5ty1W9AORD~pwR3nO0X$0ya8Wj;QFD`&S4nm#* zE=WDef`MA6S^(N7NflpYIlG7lFr)~IjZxNBkW3<*#3A6MSrVt0G#(2v3=;Fib>pO z{VKZ_(GXo*q2*ks#L9JJO|mkgR@Ak1Fv(vMBdXdKrB`v0(U>J-7?XGqgdy$=5t0Tq zZx~+4Zf60;UcO6d{d? z!7%BtHBQ+VSy|O%Rw!jA*(gp~VG|`td3i8uc)CIcZsInT#BM9t zd8rjtV=JS`GNP`n<9?AuG-d%%yVHgxLKtNjlun{fW#l}pjI8I>s=}#>T75fpU1gWdVQ|QBqA~nO862SYJj~zO1VkvqEe(Na zMiE>CWOFoTSm0(lJxxKH1I@@PFs>VGd3|VCJwX z08l$j+nMt$4pB~8izIboar%fvD8p&{5}^#cB?`c@$D=fG@+&Zl<(8aNYHoW}5apno zV0S_TY96d`%4)zaaE*}1Ih_t%lMZto!o$XWLX`+%@PPw*iA7Q%rZ|JyTzTj<(D0gQ4r>sF33bJ4Am!QaMH5chW=M1~hoy$S8c2C& z5O6VvrH6t#>M+x$2-A9uYFMa&4$pM$2H4^14qQhmQ#XAFvN^f~)Ii0Pez;a7ZhP1c zBsto9Hkz_f&)G&KqvjRYQNpx5;yP-W)Ejm&!=fIpiy4;X-PS~ zYR=V)!n1TF{(&HdKvBswUM^9M%^E+ne=9ZZOH$ofiErmXhEu253~HljZImIHVj1s; z>e8Cga?MPMTKqUdw&RCnx4n_988eoU3_rB_=Vk)1@Xv$IzkZ8(4 z0oraAp7O?&k~+qeTB#rAK!l@xFdH!pYpAqGN#Yez-B`=W3R;qUQy;~F6z5&Z`mx*j zER--C`l$^QE`Gc)c8C%qtfuJfxRjfuDGJbb*&3P$f@ZS}Yj1u!kmQK=XdW+hZPmUS z)wPxSX%1vKb&Acf8^6`+Szm5{8VxK_lD`}WVyKg{&p)(hawA8{z88mCdL^ngBFKn z&p{~*6e3k1h#brMZ%T=w$T0;7t%A{~#6%3DTv;qkuw=uLB4T+afII^&Wg;y61r1;C zfd9dBq!o=<1)EgEe-WcZfKgewt4RJTn#0QEv7))GOg^D0jUoXu{wWpw4JSnriSBMR zZYd({%EId=s_)_ZAbg>P1|Fr*%+iP$3(!E}g$5A2Dr)1x2=>UxE zh##P|$3c4T0ZMxuFpvhtXn!P%vo{t!!5-r5i=~LugJ}_*_E_k2afs6%3mNneP-Gl# zh1#{}R+U{ZwMuYGyjHwUS=I{9DWzJGIQe%oYjVbi#&nEQG!Xu;kbDpNB)%&{NQxYj zGlq}=QKL*I#u)zRyH^_d?v?M!FC!7tA4y7q^(VM{kQEiN8qo06YK7{?D$0Y}1!5Rg zP`FV@$Z#e_LhYa$8+n)HK**sVa|#MYfDy^4BOd4Fh>4f_9Mc+D#$g!rMJk2pj-6$Bl-5Wbb(t^+)`{F>c#?$-7ITu#A3Mhq}R6w&`VqgvN&X+TSqNsBe8*31(p0rq6QM4-s`dv!?2fP zb<|?Y)s~G|486(>H&uZ(z?gg+>YBPaq;$5Hg2klY8N`vhb#YJic8-_Ter0)U-NsAet&371D277EAp z^lD~Sz7P-)2)?Ix>(v^p%)-l;B2=3VLX|KVCA=o2=zCW|GJ@HM7m$(xH8Y5wIj&&} zV&=mgqJqs#+Iqg0TPLJoYy=p*4bwO&0Cv8%q!Ca6?9emAOB$X6zV}vsNr5IM8&vtt zR3}#PaaopEkonT$Sr*@$-fY?Q@iP-2?fXO(HudS8GAdnI#kYUTrVfgrOh3C*c8VF6 z9fv`HF=MkG6R#GOtWffukp+lDA@VzAZZ)c~Ef-Tfqs!)-ow5^1aQ^$a+3C<+5%_NU zpimG6_P8b}SA6g0ZY}d9Bww7OAg3q9sfy|HZo1W|P?c?V|7a|rD11W#Y&84RVm;qH z7>m%QRi#Cjy*bC@OHp7Co6U~kQU%*a)sc_@`E;icF8Lmw&tc+AUxbP3d$&tQ7NSNI zmddeJ#EKuqZtcJpL^xFw%fyA}Q_MLPetJb0ztN;c7QT`tx-sO9Vw!>{D%f_br7R#R z`kr+*$~PKX-fuL_MW37~60p*IZ)q3jl9uPvEzqT1qRWONUDnEU*;uH{hEmn%xO^dT z#GKsnjfR%(y@t667(bGtP^Cy5vb?iw3IO|#;fI3UB1GR?O;xWG5+EPp54-1(5Pfe0 zm0?wc1^C|m{Jk^?2@u_=ReNqenI#xa76`Fbk#2dMTQfv#)fj>kjS2R zJqZo*^qWea7V6-oCC$^R8 zo21Gj6A4x4GrFB#52~(HyC>!NTpXwor>490IQUba5RrG17f~2zlk!a8SK%q)tobl+ z+esXp+a9-2qq6G0H}&+~qL|wH>Y7poYoc-s)QOR=r@NgKJF%F-M{#8R$d@e?niFPp z%U09hZWi6+^FxXK>ZnB~c-z2RiS`t#dsmU}5cdX`i~{w-$X}0jmVno_N;U zlfV91*2ysa0QYp+UwcARjAx#=0#ASWoAd|70md`$Z#{8=)AN(%Mqlk@8z0`|k9FQ` zI}HB?5A7Bzse z&d%uj?nG znRku@zNZyR*n=S@`hnrog9DrvpCqBUx?Ys9d9=Fu4nKdv`JtcNFHSGd!;w`PdO!E! zy6GBpodb|1&C~A3+A(%)bH}!An>)5`+qQOW+qP$RY}+_@-uM6E#*MfU-Eq1j`czkC z^f^_X`Q$Hu=Ht?8*9r6d+HS;z@;A>^rMwIny7H}M{gt}i;we5@qL0ara)vw&FW`{z zyUi#eX4it1n%3P>QCnrm6c*H*eH4zP)dgF!+wJS@!3<0Bn)J6*7=77H0`Tg8F? zkHL8~iL(4ai~3Yu`(WL2h3nr}9B)Kob@>;m^O;xu@n+M@G%=YfA(awHuOt(c7Uwx+ zZ#Je0AyJHH_nFc@NS=X2QNH@!6H#Wh7bU57_9pkuLz>0Y@0)sWf!Pn-R+YwTDQbp zbv=V^JNW*uoh%S`H0EC=mfi>W3`G*xhzH9Ys03HSVku&?5OV=bBfP- zdJ3eY?gk+%Y%L}YAb;lt>F9u(iUdOj6_&P4X|*fBn^-J+LyXBKX*B+!>Rz>R@^W~H z;fH*GMRD*6ahp?PGwNf^(!NJUxBw`?TO?gymHt_#OZ^1qT;3cLiW(W}(OA0p#NS zcgRW4c7qks_qtS{!%7^_Y7M>?xNNe&PHmAt1*{JAqAHHI_?Aj5hoqFY7NLg=k1~<* zkiuSbu*#n{`Sm!alM7F7QH~REnd**&;^N-1wkK`bHDN0nz4eC==dNWh8Q@{JHqwH3 zx^;ARbm6sX+PUlghP{%*hJmoUjhqSsF_dykWn=^$^XlGbV0(wLAFr&Fc+7gw}mJLmZe zX0FOP#BMR~V7}O$6oliIUb<(Ut>TH?=d@~KPn?{+UwzzIaaK;9SaD$avUFm$zbR~%&Aj*(%`clO@&#^ zLfnxnE{CA4_mT{<9|#-5d_Y|+Kaw-E#U>0Bg7nfQ5y~B>5`QwtxgiJX@OJQMLQs;0 zZHv?UYOB~AlPB|qED5;Fpiw7RGG=WW!FW{4>;h`*v1-cC>P>1XR1C>v>HMEtG4>v-m8IMS=paP;ra|fC!?ho7 z)(K8L^Y~vfLtn_9F?uU=_9R=WW;L)jmG<pjyV35~m4L|w;By&Q1l zJ>I3OW!hAnUm?vyuZ`RGG-fMdGOYSJ^&sZxl)A;!1U`V%qeuPZ4AwDA?&yc_A{noS zFKHtBZo^$)YOrqglA0Ema8zAWN-HR>$Y#ra`NmV}?BR?CVat9cMHbR|E_radQbNkT z{hW}J_c5Y0f=Gx~gawnuX@YCIYg=92>lMr4uW7D8e-$U3ir^@W=xAoWi#DKawWv)q zZ1;n5d#_MuW1!NA-0zlG39J=0uuJOk{*_};N|kUanP4qbzpUHSC#&mLvD%(+-y_8n zidbJ0X`C+5ShS?HNfebwkgQ?%fRUP%5{&hh7!lLD;OIKbhBO5GSCT5sxWXif${WQo zott2CwS<1O%sSl}Lt&J>w4SW@iU2Q?!Lpv4KN%E4ths1>Um;}E@cIG$t;s6HUnMfmAhTc4EOZVG_kYf5jbMx%C$#8-Z zWaO_`@ZNwl)Lf{SOKdsND~^WR)4n{C9&x5*J?yRQ#FSmM>)ycySzfFe#!_sLM&y)I zac3oX)7^aBFp=8U9zY96sYO7z~+0vs2<#WOO$MRXsK`NoJ8q-s_OQ_ z4mlo*pQ5sxicdZU+Z`_T6wT4ZY`H9E+L*2iM9KRCd8;nhmrK3B-n8GCLH$kVN+oWN z=S#g84mpt+*ft%kl)D}?ZY4h9+_bU?N9wBjt{{$hf4e97t02S~z&xRL zZH+1%1x(f$+uJoJ50vCFlZ~B%3Jc*WBhg_qW~moFYRi7;T`N>W{Gdrc|!co zS?$s%O)CLFHv_FLWULrCCi?(TIbTI{#ysEuf!bt7vSj1hk>Qo9eP-A*f%@ss{MoQd%6817QlNL zsj=4+4$w^oV8M|?cwvIFKK(fCJ?l*Xvh$TmAA(q>Sr(xcq+x2;jSR(JNRo_KLvhx@oW;jhsza{}oh!`3;aKU5t}2>n zJmVjwLzvbHhl0yHTtO2ju2ZHH$1`7L4O) z0i2Ny4K$6L3|)$BL{=e(T}5@U7CeSkp5!VvNE5>uA?xni%v!AmBOtjg zG`*|{qxZ(M@BI-~Qg6leU-kN4OMJS%%coCCyqwR275jsQqGv^g>9rZ`Ac!3^XOScF zpozsjr`(9L36-oS_NsOOOKW%k5WK6bdN-c*6Vjs*XxT!)k1ZbRKjixF|4M5wvb(s<`Nz;fTY@Kx(>HS1>0OwxAUP2t)B3`*AR#sx6OsfgqF7paRnid# z-OU6)1Mkfwp1dCMqN^}^o>!ZaHM#5TdDiHpwe_-xm zNst6GnS?SWVbeqG zv_J>4KsKF z0Dq8N=n+4`zu|SkR$nK2J16?MoagHK-`w6q9Bh1twxLc-Sp{1_Wf(26h?7z zk#TU5!T$Zqg^rfg06pp#^*d-lV!18oCJxlz;CZ1{1HA!uebvkJcRBWiqaumSBFjy8 z>M8U4Vwpt8R}XlqV_X+#%{Rd6&c1g8GXK(7&wa)2qX-9pm_rnR{|4xM1E5ZEHSvYR zHOkDwrL_agO;d{LDlm?!vWey5JoZ-+Ni@VfgRb{sf)ZPy?8IaW9r1=#BFsjWbc|6c z(&lzfNRNC1V?U35*X)v&V~Q63dqiR%V35kgVEMEfprLy4ba$f+s-6N7^6N(!*J%Kj zude+>WsBr&8$}emEgaMezkb6GHt;O4t{fMrU$$M!7xDsss~*v+eygieZ1y;i{OM`$ zD07cbKjIGqxaIkoJOTa+k<1+jE}+5AN-+XsyAm01A7LQE86gau;>Soex<9>}!(jTS zFu#aVE~H_BGMm7HMx`V(vhi;e775|4>kUNZiy06Je^SU(M+D#GXHJ9&M}@Q_anVA_7!^z* zl_;(YKmKt1g87?M1WnoG$QIJ^ehkw;?~A|w{aZZHVSxEoDt<_I zBaY5W%$z7PI*q0@0e)3kdDU}*k)Q=Nud)Z&O-qntQ4sGZ(Cw#=dfJ680m)cEcP5mn2D@?yhuZ^x|o<+nhtL2&l9lfTPhXqUeOGJ2|xoi z+(e);tKs}D{s`Je>3Qj&Yez6VyuQA}r=Jwr()?s!a_Ue7K1GoeYMAXX+Qi4=pWMqWp zXjVWj zokgoZ04_ZMS8}9~dPv-i6CZdOhNEvnlm{GGz+yELqTbkC2^e>_(!{FT0kmi6=>B}^ zxjA9_0}%XdG5V@`M%t1miCp4A4aBGXOr_|#TNV2OCm-akzKC%1d&iXmgd6M`vXgJi z*PK~yR2x-TWH=%9tCfTB4rh?#=sO|D+u;>T32jd8xoEv=5JIK6O6ikrE&oV`TbF(^ z(p5`vK)6RH#E?LXQZ;{K0;p$zrHTWuRi^DOb!Fwx;9y&m=|sow(CnR4y7}$V%5QJZ z#J?X$zR|0kY`Q&+D{)6E5=9QT#Zvl_Q=ONG*@YNRgHaVs@RCO_M$C>{6O ze2STw=2axhQDz^htKwIyB-NuwtMoJw7&=wLwTc`UNa=9CxZ8=4iXw%|!8MkBiyB-%T1Q!l22ox3?jORTuK|A%_asFz|x|7?N?ZjtGJ@aOJ)? z1OyQ@QtSfyL`qi7cEV&=ar|L=X3b*0NPriArr*HMyD2g#d^nc&jM?!ELr`Ly#!}=2 z>SDeF#i1#;5F=3Kgsj~dyUNhJe_^NUHf4DRE2b*9ZqG=YM7&h!qCfvtl*o8cJ>B*PV#b|bb#O=W%ujPc9D;M4FQ*IEeu z7E@WE8@vsd6vJbcoq7t@6eC?EKN_r9ZJP91a1GF#+dEfw3daK>E*i)(W~e^x(Bv7~ z>fV((PJt2DN<+Ctj?l;CZNhTO$^ta7j;2_aF;m$rFT0MYz*p zkM(U@l zr9$F`HmbXOsq6|RH!zIR?6N!h_4%fY2k|>P`AT5Dx3agFKvEw)=0iG<0G|8L3PZs5 z#02IJ02r`s4S;mR%$u74D$o#w!6o*|;ctPu<;{WJMr@CrcT{^2`Ic|x=+KE>o4FXd ztk}0eEidJlumm+Tm=Gs-!Lm8#1oD9yQP?blj>l#1t_H$-UgH~p;jx_coQX0(UXnr- zC%j*w45-YQJ4OhUtu?v^YlK(p(byH$W*V8_qmBxg1rO<>(1y>yT9(o!nXOM04waif zjYw5*u&>2A7ydXAtZCll(>x(JQ4jHQ>`jv90f#2Y2?=EukS*p&7Yo96#=CkU8bX=bWnl#sjGfWcoji%7nwFWpg)b(&Bi;bl=+a893z zgt1_!p3RHs=pW}NiAw_C8;}zEq3F z9#GRRV#}U4OltTNr+Euy86!^$Zx9kaj9=g#gyk?7;l8roI_==kYG+#Lk+f{7_& z^&e3LYfm9%&yAVQ8HMW?JiwK&;)n5u37(m061OP{D_abdJB}8!X*wN<>SthY`tfo4 z@&ussA-8=YxLb23UjvxvnOJ&T0W*VUPM_N+Z+vIffI!<+44qf8>2W@@8^Yy}=;}0V z9R{}bz3=|~6F#`0KC*L?8q?wp?Jl(3L7y|&WEOirbd1v=FG8~*(a8%{d(Knugs7no z-4$`O>w!ymwzNY>C^^3w-PYuE``H-n@-9Zb8{c&tKl;U|IV3mr)dP))ng0lwnu>}N zdj}ML`j$Td;$weee5>P3p@5JA2CqIqCHxjG&5-k1`GU=wYS{(<;NwPP;70#fm#m@S zp5~yEt~iU05Kn}#KzT9z&wH`oqQ&&D76Lc*p}L9@&y4FssDb)dgT+=a1Q^o3e;(gs z5v+a*-F1Vge-4?9gQzcrT=)a=D4U{qLj&B_LV)k|32}na*yuHzjTpu>-+TEdpx~oX zTK~N-LaGk}m8;h*;BWHpKR}jTz$W@gFbVa{jPhYOa8UAoO{u+*pM-2-`dIvPQ^h-w znghUHJHRI`lYaxUl;w30T$ul?$%osOe6!gVe?#w8!w~cp%f}%+9O`d{uzT!s5+Y%!?FgFW%tq6JjYKe`9qmi7!uunO*)M6-jxOCqmsw=liG;+LPJ zxwpL!R^9l^7UTtpZ8-golOd%0gF!B`LMip;S>h?ot-8Q(c#Yr-`6OsoV*g4qw6>yo z+4?`E#h3QJnwY>06n$X(yV_Xsr_DlkEhX$S_8EJKLv;&sY3r+s&`CdMdXfs5+YQ!t z8I-34HiK4B3K!K^$lpL@;FA-DD!C~`PWVIU*T)bmQIeb=%Q1zx1XhHYY02W=HuGD( zgX9)D?9+7|bB}nZyqTZvQ(2L&?Q4>bxjkfRV6W}5{&bNF9j+hIx=AxDu3OGe+LJlX z!Z`m%MF_2|JAFK`8OXWWR`##V;f-@jXi&eg5EuvzjysV8kYvVHxyghfs59b|Ufq-nuk+QTirT@Go$ey|dCAnD5|{~@Fy}OZW8_qMe>m0b6QfIKO^&6lo9&c3bk@SfHzJYApeb#E$-oRhl7%oEER1CyUZo^$qp z=@cgr98k;%!}!L`nG3yMc+CzDPQ{b*AGbG^(T575Ld|~iUWu(?qy8ZUMroI2aHEI+lvN#EW5dK+!w}AM>98j*iOu#-H>`ZT9-X! z$FHA;YJqU=CGOkW_4@a9q?kYkX5;)Gu6BkE@$MBuMGne;Ft>@_xikFI2eUw^msM}OB0CB5vzV*kj!4;j zhx_5*n!@lu((|AS{(*qmbUN3#6#Sa*_ZT9B* z$V(vDIbz(LE2PA;&G`1H1yE#8P#%gW_qBqEO^4aCeu0Wt5!ND_sw4R16+mN^pU}an zS{&XY92o`Ygp&j)@??JyzbF=|u<=PLfPK>dP!NHxDQQ6nkp@e^Ths&7n#TeHFL6Nt z@LxwbJEGam{q%T76_zx{&e0Y1?Jv`I&zp@~CRn;??|(TA)ASjng9ho#L|~If{%)o% zi>6bQJ5E=qC;!b_9@+7%4b5CkH0tu2fV6-od9BOB@A3viSC}`RJ%PX8gTIDxc55kz zpCPfHlCUc^)+C}fy#Nr|pneA_z9&E;3$p;p)UG)jRdCB*qc%hYo!`tve`eny;QIRM zh1+0lC-@+yV9~!R4H;T07A;I0uLg*;cPjf+pddvw#S3I5Iys2N2 z;Lsh8=tsf1ZK;KrbSTFmI;i#%NiSjK$=vR%%f}_AYr;}$$VZ^c=aC~bj9(*|KfjY>Q0wBuyq+ix| z3Ab8{*P}ZcZFZ1-Wp3%sPv9fc`e1?V)c!7lX?pUzCoN)9Kp>-JiMuGaBmY1S%R^Kf z4UQr-(uob$bO0BUtky61-Z`ta1aP&%o9G-A^9N?dv*zs0{kE}6GK7}#E8m1%r}1zOsWb(D#1d3U(F;ti3E&Q7UIn|LB`GaQ`dQrH4o#K< z(ThyMf|->l{Qzs;q>7?tH^6BwuEPNWBU%{9`U6tv<8$Bp6jX)3sr%ra%tTa@>U$e9`3 z1FMAVE4J6_wM@gV{5@JSE(TJ*>c z0a6Vy(UxDTY_o5+nh7X{lfs?zoqz=LOR_^gTmASuJy`IGJNz1uqOn(x_7}lAwi)SZ z*CaW0Y=UIXVtXL=7R5ApW3dz~_wL^$3j%N0$NI@FsG+CUP54@rZ>$o|b6QQ7{qV+a zCyeylTBxSnAFa8<@_ay&;-FT@?9siJy$0B_8=ElCs8L)7WX-pf5ifwJ<}VL;K#RAh zHGu6b{j+Ba763TJsZsPzsNyy=1v}OwzulaO`e?vz5Te%m>ADXw%5q-oI2^`s?3y1| zfpxsY!wLBc8eC`>ihx9V7|2QKI}H<*v63p>ohAI5*=i`*L&Gw z^Ha{=+Y}DGQ+>gXAtEc%oK4-yuB`i6 zck{Mh3%xAY9%_@SBaP>ay(|WAIqfzZ9bMY$w6aICV_%nPrbwB%8?s~ySr<+~nNY3t zv~TDupjwaV-WNajt`xpKnQcMWcn-#2_4q6ZH);HkuFwaVh6g%u4zcDQJ*Tt*=q71P z7{QJ<0CI98ST^m+_PQYS1iq6V(#QaXQW(hk_7jI6*9xnZgdm2V;_zMq(#G-g%C-M0Hl$F(G^Bd3R{7IGaKDJ-thCaF z#Mk=>8ea0wAvQmCx?|Aa7cZ>g3sKtvi* z{VR7ega_QTX3q*Y=7_zcmDd!lv}z`p{GH>@y@K7^+b8Bd)T>D)tGTak0dC zU;vHyy&^THTgOY!%0x=Lc!nhTcWEc^ChIz@utpZBGq9wNOx zjo+T>Z_!uxx!MhK9uEnUh+X08<=C$W2-7jHt50A}LUh3cWUA^cO<*OO1(tn24XU>M1XVFY>~buW{^&|vo1 zkthC6`W}>Hc!VWy-d40@Yk)IzYv|nP{cbk<_4>jpw7d)Z)q78?1_J%tZ0@RhOHkia zm?#Z;?8khn)2UR?+O1`&(`BPZbdpf-DOKkJlfsdxFBsn&@uCJRq@b>N&ytS~5y7bonb2evDmD?EBEwY&0y-Rqxl*LSb*uL@5t% zXtd8yL9^R#Wcf|5b~=&w=Q{zM9Nr(KdD08PmrCS6E0zFaPtUbx%_1+6e7kaHS|4ipruBsYijR=HRHvfzpwG zFtq7Nnshec(l)Jks{CeZEpMDP^xw)VN+hmBP2xl0yEL9Z<2%FSDFQY)5;aF>8Q}>j zw$QEzXEHtKe81-DVqYc>tIy?_VSVuk5?-{hKUjV+_r4Uec-=(A^6a9$tK5ohe+Jgw zsG@IKoZox6QspVA4nv(bB5CE9lj#ep6i4~hx2*mmOp;H*^AyK>e?nR}Q)l)E{nbu~ z9b4Vttiu)$2Sv3(vZ0l5(J>yv>>I1+D?sdp7&qwH;#yE{iH2KgaY6}&QeJD-A4)9> z2A@`0l+yQ7VMVHgyXIG9IZo+POS0~o?7bnd#*U7g6b;`GCBu%v?uNY^#dWA}k_Y!_ zC5!?O0k464=~)&iS;9q8!3jmoe3*B1tns*|rpJk{xzNJqaKx6s$0ntuuz%0E5HucY%my|nru|nz}DLBE3m|- zQMhEtM*E*o`!mZxBs&IhW=2bsEO8g(j|Xp%*)?H)i-BbQeU|2MBLdU|kNO%3Oc6j1 zieMi>8c6yshaL`}Z*W8e(b5^*Pr6ct|J-?mN`rND7l}YNia(8>9OQ4cwp_Jdw+NWz z8i`C$;0oy@5hlDQrYf06%0U#7Usf9Q!2dKAIIULgA7{_~v=(bPRXf9uQ<0Pp!GXTa zAK{lvPmbcy;lR`8^ZGL#F=Ig487dS;-GFk&{trK_QrC?N)fna>@ZO-s3HfAsNSjVu zj<#>fJ=)UjpT>3WCu%)REr$y=>=Cl6X@TiKSVZJU-zJ%++xd3{XK*h5E_CL1tDaSv z@ti zy{tj1%7nec&FP&PdDShV51G$-o{+1+x?w}__EgTRzM*}WaT|Qq2-8cw?(y?y*}zr> zp20yBL(Y1orD4s_VFNg~jD&uR=8!|KSI)`6ytJRow*zG`GsHTREmSTJocVZ zN5#j@Pv@NLEsSwj!?5&al*f)$8iE zEK^FpUse07*`8pecgS9?q=IvB(;=0$>K_d4SpKVpdL{9EWn12x?`z&gZ)5*=8{&Br zP`t2C^^k$iA1pgkslUMlq+Wr9-S0df?wzs+WiC0&+gyCG+IJqVyEs~ zW~3J@RllLsD*)I$2h33AM+3KVc*J9IH#>I`e_#db<11@b?V1T0go(uKH^z!ufGxom z?|XkSa6_GGbUd0V9ed*q2N0|yY{#y-jfggQ72g->biN(%{7Q9K9~>qe)ssz!jWkHS zUO-8{=iBp5(YV{Sl_w@XaPIB}4Esy~U`YXq2oSbrPJ6yzi7(r--7z&}HNyb>kWZ-F zV*#2I$U@*fd=c_5K*h&zWZ!i-o<|QS>*8{Ssbu;#@janQ$bc^Hnnn@9&L16RS+D6S z4^MlzFU>-8TbN@{+RgD+S~7SUnJjL-&9fB+wXeWGgq2EJrm(FEG6HaD8Z1-k?pHJK zC3begD^s9Mf5ah)-~t1Ww{pi9$we*5BiF1aki*$@>m(~%Ia#Tq@f4BClFq0Oks>eN z%z7rL4<>^Aj+k-C^e%vQITvOIjrKe*swZN6mG}8wce560g|Kj8*k`jOvPH>Ls*<8Y zfYI{i4@a7dk@ok0i4D^_~!Jm$SdXB>rjQNa?kiH zQudVydc}=VsS*!pQz%`PhPD6yD2}T{{>zpy=W9pn`A3#>RXRKnpIJnAVELX7cLOMM13NOWXY|se@#6qJZ2= zhp*rUy(+>we^g0KAoN=y^SwC}m28fSl&dm|&``}@<6yHr%VI09?5%tnF+QF+#E>M; zRHvgny}Y>yzlY{!_f2S43@OVqw-%Oac4G+fa9d38OA8H=GVNk)Yp**F9>U9u0LB7B zkU*<#9rk~~ODe|Tc#;OymI5oMpJheEEc$zPo!m^7`2g>+>n+S!1baWOUc316?BmSx1V(mC49%>NSsfq;O2s7F%5z#SAh9uwA)_~-L|}JjvC*P`SV83n zMVzhC;01X?PE!r3CXc;J=hv;r8Fa-M6jaFX7~pc=PE zSkw^V=9cDKC#}d2lb59z;4^BIHtiAfMzv53Z4I&Q`4el9@q)<9pC}>aiVLpUJ)L~m zV9+lIvgdF}Aw6gu(~k_A*rE-GAA2kBS6JB6W6MkhnPaN6SL_oIP0hnJh_@m!%u)Ik zmDn6>tOWGrX7g0n@7cd2YhvSjYD`jk^9)R@6 zutnAD$yxN&Hp(G~0|&z3^qjTKOk2R}J)qFn9xKyf(EerE9`T#JA2uxh1jUMqW%+jO z7DL3(l&WK&jvMn(oZ(ubSenK+WjP>mn39tQw;~RXP4x0L>>%@URWMML+kaOG1%zjd z_@nMZl|}1Si+GpvlenwU%jb9iLMNo&yqR@kZDIl`D5CnI&p(EO&EVtJ0;xjZrNSnF z0_OMaW!Zo={M(>}+9CmNJfrzW5kvwTIEJ=tVZ%%w6mJN+ftM7+9(R=K!nvjJhd8(e zp0K@Jb1M`Pi=Oa(#W`hvG0&R+7i2xHIu~uRi8!4kv1fNMr*%$k{yF04fMZcMX6eSp zNbWf-cS8MX!^dV06y?w_in|^8AaEbIk{D}B?ny098|hSgRIgW5BH%ZzHR7hM(cU25 zP5|WB`5X8R;NWEQJ^yRq*0}!#@HM0M;fwSE__xr}x98?x2ocT~jO_4&aND?hTjR?5 z0;PFG0;Up4XwgNH41$XBkbNO~E@|o5gGbM&%WXT51Z868`?4(6HSar6Ki5wJ{yBzh z8m-=i6%-)mm{PCJU6dK1kt?9Tp0_yuIyL&INN&-Cz+cz_|ug82Z$F3ju zp1f?_ySZ|&$4ofBJJ;JiUzHrij?%&E`t9t>1B6qhT$ni5IN5{{+C>8}wnH_<0=IUh zE(4(!op(X|ky)&jZD0$v6G9;-$kM1@v*|W8fD{DY^{&qz_*1~BSrIW_^k+j{LUqX?qh85wZZCleH7NYV{iA@&2G=38lC4A`L@Su* z*TjT<8Y3p^pKm4UaC44Y6Zj~7;w0Q50mgL5%Q9Zk?i+-!1@Jm3B*^uqM?*3FnSV=L z;v-cy7ebff&%=HD9L(c~oqRK8p7tkOA%jhHQFAm-e5(~U>A8}IArDp^9J<{5 z5(1TGuW7ntwoC}zTy$+(ykEKdnNR$?wzvVkUzXRp==WIKF$fo%rgi!>nwNxhbnor%I+(k> z^C5h`CuBNPz#CUYCr|J>6Q;K=CKB*xR^Z_q0$Tlz@C~OCfJqm&%ikQCGTW26yXWYx zvw5G=wl(b$NLbU|38A$Rc#_$8^2XmL-$Y7^RjvZgccn{NSo65Aqo!evZoVpzUa5HQ2_P8LTP9#T zpGKS|YrdB;?b_b-TVT14L>GH_F8Ua7vInQ_?&{{%w$%@>Yu)lWgP9gnU)~z_32p9Q zS1MCG30+9PnR!UinHi&XbVk^rmVEdQ( zvr_^2klAVeqV34NflwS_4xgVU@@rjiLnrW!j34%hWY5)BqYk($Nqdm;Ydr}9Hsup69E z7DqNXmPj65DyT<-RTt@l6X`QSiA(~nA}9lI#5Zgt95R?Q&k?RO5C^)b5$!zGwaZil zu|-614|+jwGK@R<2d48BXLx0xp6*G1kr^37{S9jU+UW zN-d8gNiY|-w}|HF87yQxIvfI@9WfYW>IE+=b!V5aQ2D|CPEwV)(5YWK1{8uSP{%ON ziLfAHmB)ApWn(yUQ6~{j zlUK(-{3QWTuISeNXB(^e+| zZ|^Lp%j5>4-71^lXu4F1=K$lUARbFt|4kr>X;V$jwW6||QC3N+ra@dj86BCbei#QP z?mi^p{yPz|4x_4!N>fpV6{gNfvW`|^idm)Z-bBU9Tdt5QE5mHDMQO#^XBY<}6qX!s zfNy*Us0m%+cAV^=hRvabnZ|EG2r>&920+*rPR(KFam++j{p~l^Ey>G3@}4RMMy*8G zE<_+2-AYME;iHX`z?nj2fc@4D)~BC9wDW|4NX#?3_w zB&>7L(VBQ6N%{sbfm}0l$437HU<#-DzX42evp4Ji0GPxmorkdg1u$X%FMtW+e*sKn zXY>utPz}Go0Ze9o{{WbN{sUn8EBrqICg%SifN2+v?Oy;B+5ZDzV&xx`s>kx>tTX&y z0Moq{2`@nyp}aCfQ!N+%7XEYv4M?I)({UiTdz+etY9l zqqd_`K}wGiafE;u?vFT^3y<5pI;Lfl2BCQGnt%G(RYO*uHh#>QQNIXElEEnN*Q^y> z+R0FC9K%qkdKSuoxNC+#DGED)MRlo=;3lHXwoKI=ph~j6C}vME9HuQTndfVdhLik?*lf5Q4cIY>Ni81ey-Q*ttlYgqPy9?bv0H%71Y*@pTvHt*= zRISqdz5z@_3fWmBHhw=PchXU?{ZUy;;9J4Ijp6u*)Q(_aPD~R7n=lINp}Ca?^zIy0 zdtFjKh(`V|^<+hAlqTg*w_k$;QRpwsLfj9%X=Q1W#7Uh$DqcNV}7e;*OK)qDU+g5qyX{i#Z zd=PWsI@ze`AVIXuyqrJ2Oc$6{ujeD?|)5~{Q(m^W;03MH9f>@K45)2DTpO3;_ zJ}Q<=#);^3mLMls0L5U0<@)!K2Z!-qAc2X&R;LI$T8ek z1ut$oBQPHhvek2Lx^luHz57T85~iE!uK}u9Ry4u+f<= z9Y&LenRq4eMz>gHHEM!rFsLHDt`v)6)Vh?-!_iI}xI)*?s}td%qIMrTqPyzfF48YS zO&xtC|IW$6*We>Q#BB<~AVrvH9Ufuh1}LCEOa+-8sH8ghmKwitR~M@?G~a~;1PH-$ zcWTtF>#5>qaw8OU*`QPhbdn!3jAl}*$;>aO}A-Kw@JMf~2^rCrZ*K?m{O^^;lw;jb$@QH5GC{GW%k@uYYV z$F#t$0z^0J(x}UGu_7VW*7fO}2LHl4R_OYbD}=}8ktRZySr3)6bc_Ca;rUET1?GwY*`JfF*Ouw{K)OK0NQYe3%1k< z82gI!O{y>WC_3LF$tW6cGHDmvaqAHlaCwz_+cX$W0VP+~q#4s}w4 z67Zctx*2fV*%0k~m@W|vTG396{fAF9;!fA zVMj@(xiStW-fxn$^Lj2Ocmb@T^Jxk8KleWtOHT13IT>qXyH~Od#C^wl7(I%&_$+rG zZ@}G0kWIR2Jns%0{5nRPj(YirUNLzs;GTdwvX4IF;NgM1mXteh`Jc?wZVa8e<=yWP zbs2bO@M1gIM=5S|`E_4D6++vb&w5C)35LD`=(~nuk6w2_Ac6akdLK>+>e_yijQx83 zNqakT|eip0amW3 zUAG4A4m30Wv{orSW~g7%uVaUJ=%%=2@5NjT?EAcAxGnn6mt19Wv;aHMXG-cDab@W^ zn#hVO`dSLrYI3SJjvUO6w(UoR>tQ2^+u@d#Ac0nS3z;ufQyb3jC$k+dhi>`?ecYCD zFng@rwkCzRuh>hR4?c*YlEdQ0TNC%!-gbZ0Kkj+}YtQ?LVW(07g8cxj>T9G9p`u0Z7$Cb% z9-sQn-Fn#$e^rmt<{EK*YCdMaP`tEsN6ugVJhrCkatws{#BR6Cu`rxVFVb&0mk1YU z3%}9YEHs;^9X;NPx?(?o$0WweAv`lQPs^xfEzxBOR{VXfl--ht`4^XP=-Mi< zKYc<^D*})HTV_76yn48Q*(;9wM-Ft>Yn*Q2;^EUX+$l^oWK7M(@_7X=w5j`t2i#*Q zd7xn#MB6&a?B}vRBm_f>rIQM{;*H<9tfS?&oxpGnA-oifE+~bz@BjV-9Lk z|7m>^61x4C&1Gco5TU)kI-eNP$t+*Nts!nIS*;|yCe|_Z?m%Z7&7~OR<{ll2 z?2C2yp_=d*kWNN%?Df_E;S&VIso3=~$k#XG$T{NtX1+~S^i-nleSWNsZ}S1HGnNEy(bo^2i91CjVd!N2O9)}jgo zG5Dkc>)DJ?DPpine?&Rz8I6;Q1cU+-=Oz1`$_|ZOE z9G&LbyNZ*6e%WBDuF1F ziHJ7RIb{7nTjK~VflC& zUkbUpcNfmI?nVqn_B(3@_eEgo*=IX7=4ns_8H)D!YI%=d;~{+wev~bTqw#_#afTz1 zYT7SAMP>j7hmyyZSHMu`${ak>&Q}%468FDC7NM7`jB_$Ya_i5dZauoVr+7A(ZHe@B@h)=ryDqx=4pT(p3Z&TzH^4 znhB~pVX5liAF@})~L7*|r<6sEKBNGoC$Ioa(G<58_C8Gs7w^RxssK7>OXvkBs zNSw)M3vl%{H1bCm5UHjKPA04xGXDq&c^@d}8i?c+ls`UVO#;|bs1yAxa_O^#!aPK( zi0@4M>?u1-F^i@<8dM^YgrRJMPg#T%=9rC|XVl;)?1+2C%@E|83cz5 z5TRCvg-+zb#xUPmEJ(YsW{vK$b3_ful%`9P_d*OykU295j+vWNM4U9560kYw$V7SX zzi`qg8$y@`WAI$B0~$8FaG5k24Ab;reVC42UTh!;4nyE+;6$$7rA~lPXxF;;uP4qm z+eCxAv1#<+v?T|ZY)R_u?e8H?w6!thU3zSx)*>7>kycbu0|#qCWHPl8ANhY(n^EzW zV85@lfYypiy+D#KW>jYbsKVp{4-B!STM9%mvixm%llqF*QN^ZseuR(AaIEaq%@Mk?`%X&BAKv-fy%F>QmY3!UfE<1lUmn2h)@Iiw z;QaQx50C^(py`$ zy``ZBv>UAQ)Cw%!7iapxr#RFf`x_vJIHe)NQTBt2n+nlQOS{M_mAWpBFg#G+yCaId z$Q%jXiXl~N-Pxph7EzM_rQ>KDAXz)*y(2WvYs71mf@V^Tpj->E2aWT&TeyVrWl%qw zuM6S_cLM_lmrgpn!Jk9dX4Jc%*C`WEfQdTGn>#zzcan^lkns)MsnMy*soOgXR+j(U zXE@1gr*8Vf>dW%xI8KV@J6v6r4(>~P*%$t z&`m>p3nfc4?7GT%9HA9B>3YiKlWD$}a5w|dj})6kBbadM<6tuFH%Dl;Fk_H}@TUV9 zM?0+MuSh$DZqB>{z}eE-)%DB_4!zdSi=Nru?_-ZDgW=7`SJ zjGkky$#fors;QpsHUvA~J%DV_AmA_S1}>lr#C&Cfflh2MTD8G_GI!g`!Dn2g;r}I?w7hQHLm+HG<_)2Xf9E7;kb)MfazwILmfH_ z8~wq2kL00BC`vuvCKe~r8weDpo7nDNBSbqc z4O^xy5`diebzQo|_BWk7GIf(Qd?77`!|=W-;jNNSo#W0wrsxOWDHyqpmYz~AYpq|b5X|Rr2GS@focCYrW_arAB5k@N zM;<8a>LpQW)fIp<-@pWo?;T+E6}a}y%;%87IL+kz4X+THm$(=j8el8_bMGy%U*RM= zr>QULpP%Dmsn3h5t8*JW2ErOPdL8oA>r9$jD__$=n2Np}!xE_QHW_+Vwi_K4b!WdF z>`cE#!j3lKULUj)**2}3zG;=z5O=c^a?5gy-l+BsX=$0|F>pChjPIZZ-OMts#~hmB z2apP-yQIGY$T_HSc>=}C77*~>)$oc}ylgr!i;21RkiE$LKx3C#wKUA$?YK18#5Oge zXqZ4$Am5YOu8Jl-95QH{e*Sy*V-i{Nu5D^66=m<))V7) zyrn4evbMo1nBORG8EIV^g+|4K-r*GPQ+3-&+_0458}_bQC*WwzP!dVgz&@e-P7d+T%>xXuYu85IJGDEPu|E=l#nLdI@wGxQ z#VRCaM@H_nrwk^DK|rx64Ru6P<63a%2t%Qhdfan&|Uh-yt?opLoSOdTJ)(!q*oofOjpmwd;7>WI*yA&M^qY87NDJf>& zH(&61P=n}{N>pt5lb#~_12k0icoY1~E}CctCWqXgg~u|{eJGfBM#}1!Q$(G{;DY`= zC^Bm*DI55AUFy&o1F93-_zhtgj{2DqkM$OwboU4!tp1&JwH7hNb9bJrn2HzUHznpY z;RQ3PztMpC!G~@Pk;4p>K7M8G(!sm?+A65yGVcSdE9d*RoF<-V=o-}iwthtm>BcOE z(S)1>Fc=J^Xu6oy1Dxzr@0uWru0bo8m<(!jM1{W%W&i{hux2F%m0V)skpVah8u zkp-1{{{lXgB<`h-C;0|uO;3kRlbjN-Dn&M!2-ZST zN*W-h6E7Hb31@FrnucA=wr^!h2+Ogv+XT|NcKPZ_`}5Gjjgb45WZo_vSeVzvjciYT z2Qktn`;T?(BJbLuXI)5!{bKs3%3o7qh2vmOs0f@tOCAKiw%4fv@AeH*XbSNGq_mW* zE{XW|N~N<68HFbHy)1&qs9^?q;0bGqz{4F9Bu0OhLFB_Ab89JX10>ft_wm_pqKd9; z5~Dt<{RI<0$S&^?(mbzs_r`fDkrrdj>zUipJwFP~+C*r|dKG4U7IiJxY>gdW3?8Y{ z&4^QVs>#_E+dN}>v?;DwKTR3C)`l!qUpXVSVrLhqiF)F#;QY$$B_gW>i>)~vGwXMj z)KMV!Il{GW>`G!hRqylPa2(EL7p6H*PG8Xh?Topw)gu$uz zoqK}OW-d>x_g1~p$?C+oWycMqJPY)vPuKhA9Z&-4*jeU}hu0 z@Y2Sq&5-@6p9cvf< z_x3sXbV2Lngo&Sg))T=x^IqLgfVqO467eOj6{G};Ooc8#+XP5q5eOsW*RhxW2{dt}C`rPT> z_Fzu>>q!(lQhu*LMm??C<444TjS9fS#ud90A^L{T#Q>&N~Tl2XFPh=?{14GL-2zj1my*=JARAThd-or zh2ulm2XfX!R%(Jo?UC%^gq~{L0+4Z&d;=-(6xip#_Z-?%%laYvu@q2GblN5X-P)J> ztXn{@L1Au1w|mfcf_JPAm^?5Wd#hb7`l|vi8NT4Rzp0tR)Zj#mzr>me+3R&BXx1&}i~Ss@LRwZ>_O=8?8?-;4PAGklkU9AE3_PaeGI& zZA+>XFE~y9mm$Ht;9VA94nY6Ig^#UY*uYOL z@AWu3*AJ2h*f&A3!_UN}yR%ViCvVx4te(JoBzd)QV`rp#@{_Xa`a5O$zJaEv4=UDw zaS!;suH^6~rR33Zd*Q{m)us2RS!D-b`}rZf#%aaode&5X>{eU*ShuOAXV)gBi@EI4 zk>OwGDSK34%bq#sP#f^s^Wsc-g>IKUNm02qnYj*iC2PE~`E3p-s!lc~m0K`d&FR5y z%=z}60$M4ipx)=h3C}W~z&G_csiAR_{Um+jP;Y8G<-SW{Eprm)f`8;5u7Y6_5jFF| zzLd~H;Ys04J4;L7hO_?xR&oo;JqCc^kCGyQ_GhECpY>!n;kuy*LHDhE;l(#Z-qpXEi->my~JrIb-xht+sP%D*nB~u8kR`vH};r} zEGGsku31@WJY`6jASKOZR3VwRV)YSRB-%z1R*TbD(V;3k6p6+HQoT+;nBO?7`#5c9wrV%Xqh=Gwt@ z8M676@^!vk5`v{}2ha2&EA0e+(V&nq%N=#oh-31WMfFVGb`hNMW9)}<^_c3CtD8_@i#;$J>8`(c>2o6=zZo0D2)Yqt`Wn-=zcP7= zt3ulwgu17N?lZQ!?P37aeMhPOYHa#x(0&Gq`SAlQSR)O$6ynRYAK6K&W!;JDxE~4VUEfssqf zg#oibk065!9eV$c7GPOAWg(HX8)+H+VCWF%2K|Bap6U>P6wWTNoxB2OFfy;ph8CF! zPbVChEvJ{$7abA-aDn|@{H^6@YG=@Ay$ne!sgPrk^{qUP0|OOlxM3>(s$_BGNZGr` z8%LfMS@Bhf*7_?iy0eaCFJld^5HE@6RsiIoe z`CI?&CFRg`;GQ6c^RSjYp$5_8ZN_JfUzl07ne?5H?ZM)GF%k$BL}LK*MidJGUfBRnT{SrjrXrIeu8V00(wVCIqS7MrZ-gR39Ii|wqhzpt z6L(EphTv>*}r46*&X;ARINVOb^(N=)!6+}|r{9qf!M_+hq{ zeh7WNh=O27$F$rw9Ck^lrK}laA4b|m()%vaPJ9|L+Gi9;YX0K4Z4Krk(ZG`?bzf>) znTMRQEUH#QHI{a?p)uk1dNBKE-Iu`-+Vk?5oYw~U8tlue3^U8#9ScvN9<%4B4Rfb~ zWk}?Z)*{U8=7L?+7cDa2Mda{hTjEd2a|UJ)Jy`+3^4jxe`3iDbb!3w1hBTVT%Oy4D zf8cs=Y(`Ve1L$m<;oL4`-tx74FZy`cHMzL$>wDVeKtJB=WBh021DM_K zLjQa^RRPrQcbR@RNBqLxZlM6Y2Yu9EuaSVxyIqDG?IN}x?jgU~H+w`t%w8YaS6cvJ zGOm1kew-6!XyDf820v%D3<`% zk?(0&m?rNw$EZ_o;2Bq^Z12Olz0-jgbhR(fsMp6Y{rEn}aHVcFOcVZcNXFhVegDfU z{T)!y&4**g`DL5_e6BwPdwaPL;N7k2E%dfO!TI}2Zqmz6``CjLhBa{(bt<{|LNbNQS>eOvm@u7-xTlCZ6-R!pAgFX-F?K*?X zKWk0nVQyL7!1OJD$*9n9zYQb3s~r|Bf>-TE5W_TC5h4&8>>_dG;``g|L+T&AKETks z)~9QC?pXcUWdQcA@5mg06}TyL|T2lW=F+GH;*u97MF--_G35G@1p+TYrPn>!0j3{5q7Vr+0m-x7w^Z z(Sbim9_$s{P%Dt&iyfh&6uZk97%vT>fr`bSEQ%gF*YM zW$5oT$g>DwA^~*^0iAwDNxS>Q>^=i=cc2{2NS}!)2fqUf+O16v&o~4ufMw4Q)+)G5 zj|Yu1XW^|PO|#KSEz_(eo<5LgXt?xy4B1r!^7`zqqTIPHPL13!o(lkC(qRk)-w$uX zd{e7E?RG6O2|vTJ#_9d5(h5Fe}8d^x2znq z=0u!p<0H2yvSe?c%^-$NTnB7|W!E*HprFia9@V&kUmCf+i{VYaA7!qj?u(8GmqALk zBX}?5e$@xa25h#NX3i6MHcm8RTXwbEcKCuhvjI|t(68^#1I0L2(_ z*6?yT73i=vu`=f9WF>-|Ag|RD$h#*k0;75V--Cex_MyP)*y@aH##3~!AOa_7jnQyZ z;^zf`h*)dhlL=L>Ck3nb27^vKJWK8J`6HDElesm&XYvWh_TZZoSRl~SUHlfWs!$QG z*tl@ynwl9k4N(Vp>$Ysdvw6SRL+qZf^C!pm>GaZ`0yawnh2Wd-GSOM!}Ee^ z;>P;RyimRW6yo!dxVf0nM&jePde9TH?XbSb? zH_JIWUKtTuMNr)|MIGWbhBQ{Ok%BR80_Q=UpV4%l%v zpmv@j-?20xL1OS}nFnp>otzlV)g8ZU*^T#Io?dcMfiQgB@13Fr0XzXeMOweRo`ot8 zJ|NI@m3cQkj-T_G%x6dY0O{j0WK1ab{eYldKX2(>zp?0I#TM#DQo<@Azv7-xTFrFR zLcOZ|L$A%iL-htQBGVq1Y~j41(+@8VeI)*0_S{dknny4{wlsTTkM`@TvvHC3J5Kjg z#!uwS3|6YOQv)dl^`VNQW3NZ>z9xF?G+hd(>Xl@x+r`Dit3OR!i4*ocs$}0ydiwV2 z@^R6nyK1fFx%B8d9m}jp>c5kze_AWu&spD!-ndqhhX4LbwS@H=F%{w$Q$xFCJdKyH zR8o;4%Tu4ZOhmD*A|xDh71HPlS0CY7Mjo9^rZVv6tJ_l4YxoXx9a0Tn*$qDL3;xc_ z$jtOEn);!b&Ba>-w3z@3#wm9j{>VBQK`q8NHfPez|4W!W928m=mC>?&7q=FX$>wHH z3G6Ga2zG#&nw2Zc(4$wiT}z!A`T_IX^BFk8@x-g!v|4{z4%F=Wtt+OXAmlsq*Ma)2 z3fcuV8RTT6#<8Le#LjoT$KaR8`k05xZoe~TDJo()>1ya0jq4#<>suFBTOTc3F(J<}$JXj2(fM*@G&_tWEFM*q_n5LfR{QN+ zC6`f`FdD7hwqjf5l#`+^9R+S$#oB zSInBEuZ7Vvh(gJG7n29o2F6FGZR0XQyzqN2I(xykU&eiGua`#qT;glygGwdz#3W*4 zCnzVHuRzSJeov{hH#Uj1liRn{)3Wnt<=9^4o5M+~_lSDJ5l&?RF{n!xQqcxgtaztU z&FQBP=%jbD?y!YMHW|zixRezaF-P}vi8jf@#mJ31PIFyM7Twv9>bRkNL*q&9i5pq*Vj&kzg zV)Wp6*#=(wxCfn;%Wn4MI&gI*cS=S^)F)VBjgjk*k1-J>g7bRTx`~pdHWk=K6-wiM$)^)v_)mZUXS)$ysiYYDHInT1p=D`$28r2gz+v3emQ0r5; zBViX(No30WU9hQ+YNLrKBa60(^mV+q@lUts@6d6%zGgl)?!?ovcj+{_L_46X&5%aQ zzUgagDn-$UFkgelc%wn?-Uqs7)t)=8@*J!$*4G7ZQKEv;=ht1@Y~m1UvFq2f4V+F*nm1Wyz}e`?72yys?p%EeXTMM;e#A3wb4 zo*mhceiY{9SpW%RL6O)sB_K-jsqQOVf`r2r+1V%`o$+FAFLUVjFl4 zZ8w&YzAYevGpR~c)>Cr6&AYrBg})#Zj*Tef-@`2#23Lu7oqrzky;g>4qkt&CEX_M= zA;EMHL`ZQ5(8K!<$NE@EpmM=|2U**t9b=O?gs(7&kT<^7SV}k7yCXi443UY&%B}mg zq_UXVDUC}yBFvNq8n3Du;B%|7fTF}SThk@p151`hMqGFgMH2o%ZjecvYe$1DM5MN+ z8c?pT;d;{K(8B`NRBE-ZgOcXMvu9w-T_`syorcF|v%f1@w_SO&L~w@e5!Sw+C_r}m zOD;t5aKw=si8RhXy3PCiH6tC=Ut|fIrc|Yymca;Ek6KSooQJBT%k6}!^BCih$*3^U zWDRXM$DaCq_-5WZlC0~)A33}~+hcq9%b7xUx2D{#RaDa7g>W8w8YZJ4u`02WQ*fJl za2@f>#xZH+7TuA_+^|#r`1<0?zKIgS2{O4ecq{ri=>3fbYeO{ftS(<$blByaG6*!YhAsYSEZU{LA$%XqZnYn5}+08QCH-X8m$f)W8w3Ty8oKk zycF4Joq3Agn!&@K7v-aTw18TWL;BB@SDmaukW+FOs`pTc1h+wtZPZBk@@74FpM1E5 z(o!xmw66pl2QeJaIx_T|d7=8ohL4lS1)FAbM?@%?u5o7DF$j}0#{poE zz?@Q^5WLH_gN}`(?Zph2t@8@f0z$d#lP`6RByPd-7$m5>+(UJTB zI{)oloc*pw9M?DZGlA4?_qvr;`kqtK4(CHjQLSw;yygb~=AU8`NWxxulKml*!7B3W zsi>f)o%4a?cTxIgS{*DxIgqT)p{Lga0dp6d$ZB1my}~~o-rA<08)R39-6Xk&Lh!SG zAIF7W4~NIgai?YCV;H0uYH+zC1W9L?lBC)O9#+B27*k%gu1rv`Ej;`>a2)d5DW4Bp~o_F%V ztsV_R{(wej0Nx7}NgdU=t>+oVi9@mZixNfW`fyy-5j z#+HXVMmmPvc3H91W9P->ilpC^EWg4>Wc>8>Jf2ZS?s=}i5kmOl`zcf21DZ%@XP|kx zsa<|)#S$|=um;5!r->1K1B;l=oM}@?ER`MZ94o#SYVNxHi`+eF7dsW`o9bM4Ae_CE zVm_r`O4j?XgXnNXS1)CfCvD3URlUm#Bk`2b9ih!LVY(cP`1oTS_{s|AoKInWgv`jl z9Z=Sl!h4!gSdDE=0kcY#iD@7=gj`}Ld*SBg=i%V( zEv(?;B~$;CBYOa+Y( zu99lKnm{xA1y`ynRm8F5G>5WpP7F1N7}K}nB+q<&QJ7tqkOe}v?2?$8vZY0G1tMD& z6x0IY)A3j^q?+*c;f*e~$379jY&8?-+VNYNZstqNYJu{zqFHx$7P72lx%kHc{zEx9 z{)b( zFMcFq*089C@Y1*7Zmt+5&m{RE;aP3c(GB)Er_FJ{htmC%(A+FM^hm#*KlhrgU$+)= z7$3p5W$~o!Ie<`FvR%k(S(9nFedj$hL8cNNXmIJ!3e2szVHT9d0fnt;3S-7NJ7z}@ zhXoWLU!J4W8>EQ?(&>}Ku^*0D#66M>D&CG{%@co3il_Sy(l6o8zCG~TKeG1Vl3xNL zs0mnP#Y=EzLK?Up_+K?tx~1i2)6}qPBJt2jq)t$MgMx^?Oz5-TqJs*|3C>p@*Hs7? zF--7Hl6TwOKd8w>{dx99DLv}Utow2?V~jOS+=zzAybE_d+R!~Db5KR#lKm4bOkq)9mfSv9HL^~>HZAYzKMN_dQp5RYn_9$(HMm{Mm!I-F;O}AfWe~X|~-3mi1DV>yr zib@q`F$m@;aN`JABsK4e=qYYquv|}QjSCkk<#M#G*Bb?7uU#4m#AkIh({QS=_?3u< z2~7x7V|H9fP{8mY2oAiT3$|Yfgw7hM2wE>DPF{i|z}Yj+EuXN$VdvT4hujRJW&CAKZ3M+?9%LP??Hh>yV!xMzLVhGD(PVcHYV#)W@M9pl|!fDw9t~y+nX+U zd44i<*e0ftb3$3Ulwc<2$&)c;aYCXn!?Fo!;U|UX;y1I>LOHr1hW9z4>4>2l@P9jp0JBg6tB1*`-m z?toB(gcJi0fC4GT7%g-6fs=&Dh6&m+yIOQUA242ig#4f%r>}RmZ?1D@3kivcT5de- z?N2u|*4H~c&B;Bo;xQ--e_7})i0M!8eZ@;OPJ?;cxFS!5E`C>R785965t`b1ml@|a z$OYobn1hLzBk;L78vI=152_k0GaOyI?F>*uT^7Aa@WB1hs*169jQ)aoXmu6-MUJSs3@d94#aM5bu}Ee{%KW#A_M3U0Kj5N0-+W})WlNQ+Q<4n zDa^4Zz9SxkMkz(viDJ5TpLd2N4To)VZ5ph{YUQ(SmufofdwfoPa9J;xexwbj#J=2a z)0a;3pknA^0WWS}VzobE@@;@Pz)#u(KdxUOh)qUkq6RC$Nanp2-*}eE;@;a$X_Md9 zHJ4i)ANM=@&H&%fqHu1r2dE>-x`CaDG5%A#8KxfELinX#c7)C-&1<_Xk~*X^?b6E@ zKAvJdRp$w()5>=fQ*&v#b#e>@TMoS@<=1nem+9k_nn{TF=2UI9h!1o@ah|7t-Z-Zg z#hZVG>#3Tm$H`tVdw`ktt@SKz6kkhP#`0!)K&S=5jQ07??G@Y8NnPwWua#YEj9JD< zxc%{{R1%?~$l*MS=W_3^<#LMH_|sg4Q8<60vLkKjJOUZRrdoQ98k3b`=>=@gZun?M zu`5w3vBR+I5(e{6b|g4>Mf`|;^Zr@P9+KwTC7QPUM;VmMhzr)DYPHcIv1iRil0M{xo8{vSO)Mj2# zClS&Ntk`xCpbx|Xl4k=MKWMT$lf6dYy?=#-tsu>64_{YO3gxNAOvQADPw`;x(BGV7 zln48mGAv*MR&MGJ#tq4)(W@*pddPy6(<0u3xWL1}M>2W$fq~77f{_Ew zE_$lJB@GT2F{y_CBB2~ip(Lv1N~&TVE!(DAv$rt5Z#`ql^aaWOjRtSBCg-j-1>vbv zG}7YTZ6lTev!-_{)P|{UjOP%=Afo(9P6gqk2zCN8)vq@Y#vHX!F{9zBvvm-Ye%7~e z2W|ZIG;*Z&-{6B=bE7zv=T-U45V zFon13t84~~f?@jVQLTuPW+ybZT(TeswkILcK-~mWsx3{LvvS3}`o~e1FAh-Go{e6lHk#(@&mRfrn7FFb>_U4#Ki>Ke8}1(dvv8jg7+a+xr#OE{XS+)PzqNwlw5&sGr8 zn{PSnGlurXhG%EgHaT@-LCxw97Xg<6r&#DPAa!9IwWOBTMVVFreHIeVdg!e}y_`Jo zrfhX0n5^nI9_37aeM-Zfiux1JJCQ;|ia@Ga5HeB#dkw-}i`%-ZG>|;ySE=WK>eFS) zj(GIa%cE)hx)@$fJ|_oVt>`E2{F8cj=`KyZHByS+7e%^fgFJN?%4opbMW|hRyUhkr z=pA5FGFE7j(1Ca^k+lWpuvY;MgrhXl*5a@+#Apa<`=u}_{Z@%K!Zge_U}XfvX#NB8 zKe-IL|JAF{mJzanVa;)*d{MN9!CTB@3vZIrUKID&UkkRN1*MWe{Gix)UV%cc)7|avn#E-Q1uY4dOkucS*5CDtOafoEA>`(b zP$r%hYCe6|6MLVtaHB}D)HKc%6&s8{^wKmTCl$&tp&*r7H~Af%nJ!x@MBHN0Iw(m+Pr#+njzCdd} zjVkf-z~_laVV|E5K4x|{V@`Q5;AAb8*&2n~@`Q_&VmSu&3h(2CwFoefc1>bqy6lYq z(X>SbKQ(>6k!WQE;TZl^ImRw_kA@2g*iHKt@H7W*AJa>cygNKAW)(sxyPyJTYD3{! zDTh<3fjSzyG;*eJk|5)8NMIqx>!|)z-BhcOE+c+jr8S?QdgU7|7k8&?0lz(FuQDup znoY`^H@EctG)MGgtEbbgl>KG6s4)=6XZ{XvEkuYE*SL_`HubK~OlYek?kLw%!bxEm zi%Nq|+uRm!Rs^wAcN*==sgyjxL6UjTff2hnlv7WEV)FM9`Jgldr22i0YIsSziSEm0 z)j-IwGv|@Uwwbf8(q^ZGTC_Dkvgh77$BuYIhPx0nv!b<=pfa%y1f~OV>A8h6VN1s!)&FdMM?H8fDo=-+TyusR!)%S!^@Zj! znY-e|1YQ&pqm-_5K%yw*%K%3Ioni4skUYTQy; z`-W+Aea4N0;I^IrtbmE+Do5=B=2^qBD~fm+ys0@GNpO5;az!GX>bcMhIWjZ9f#sPF z^|$H=#dg(QewsQJ>h~f|y4@7RF)~1#A$8?-Zh24e<&K?MtA8TQ{_b5TFrbh<07#%@ zMz#eth8HEWdZ&2*cPMgcU)R5M72suV3aoa@UpLP6l%MdRqb5Uv+G`n3-960rv6iNv zM8>3SN48xid4M`C{%>4g8{we<({IMj9s2rHfXxZO81JR0v|#lj<^juO^;f(0(F^#j zoBRHs##q*FG<%QeTLH?o;8Nld(5=>R)OvQsJHER^Nza!ToBW22LtRLBkD=180}3bx zs7E^EgN}Kz)O$;CRg)Pg>^9FT%^=KrB!evr4fNm(+cbV?#yk~#igvHH%d7Bb7oj>t zMAy3Z^?^1n&yr1`0H6&-=hH`%3COQQ0C-xrz};TB7DM8v@#^&>hCfB>?C0h_v(>lcho=rfr7kCQQUNB^j%LLrs;v? z`(Dx*=;r|pG~)uLlPJ_JUE|s8{5xMQI#5W1OC!!se&5sDUG$pe5mt4RsB|T*9c_}M zu5g|3UZ{9_^ALz7tjs zmBFp9!I@A(Kt0F)S!Il&n{}?fXJCq|Gack1e-M%MLZhAdc8(t!?^yedtIHq~7F(XS zh4l#ojUSA;!CrFfw7|!CW{$94??7WA{!S3%H!tUa3;ON-wYMySHo&*~6&yBP(M;{j zwk1?R+XN=Enkwr~#t94#ZsFzL)$dq|b($ghKrA(^gcTr)7!o1(5FG=OVOnEp*2W}< zoiVgz;||%-WQEX>6%hk>w|^~A!>lsJ%=+z>|I&ch%6&9Nm7~M6!But_`4(Gc2qdE? zN;`Un%7C@2#D={BSAaueI?R;jJbyQJgE5Uu6<9wGf`gZJw#0@h4oV1q!r9Q>sS0Z= z9nnZHAWR)MN=;x}(>UNIn zereqzekSbAhr>u$2mK$zo}q9|Q@j;!KZ3T9SHf&=nNq3at{)LBV*UyO!Ir9dJ=jsT z6ekzMnGo_keJ_wWm>R!yDl2t$pS*2aJnA$7igRm~oD~EXMnPVjrgEy}N6Ty5)qE6=##$3B- z3-6$7c;Da*zK0tE1t}iv`1W;T&xQp7ArsVUQa5Pv9&>r8i#WQ`zL5VXj%fd&<}|TE zkOl-kBOE?J$-&Nx>%IZL_lTp@ZFjKFv&S|4-B0$Z3(cDr3G!+Ah(L1m48Yt&VlCt$ z;Dttpu!1{%t6}o8>pbTLt5)%@e+?r#H>B^pv8S?*P-c!89n1?H;w)pRc{QFaCY#2A z)k`Z8OWC-EDKIU30R6;omA4rb_Q=*M%>G2C;Rvr}NF(GIjq+h66buc)D#FuBQ~>vn zN}>EbA&pHwPbcU_K8&*Rw%4W42(qz*tYisSZ~zg(bZyCf046uGauPObz&thsc+Xm! z80w@i;#@KLamIDSl-Lx?tl&_dMDe#HNGh|kd=@>0_4BshGLWPOq2x-1uZvj_;W?Nq zbQzN5y^9K;%Y3b{|9NLzD_`3}QK?sC>JWyZzWlJ-CSGoEQAxv_{&<7;48}dm(%lqu_WDN zn>qfN*(f`QWJzuQvcw7L>v_)uehEwa z^VAlUY6-2V#@c|vbxcl60~aX3_DTkXqcGdeN_kZUTVK3QN(nfl3?~%Wanajl64)pz zFvA`Xh4GbE`lF4ieh_2d*;}S|7e0`Aw*E!oLH3U2&%!?uKqgiu-{edrI2tqzKlfX5 z_eY4vhc46`OS9AHuY{-A#nbhy&&+%&H0=Y&^&OI&ARiPsF?{F}^El_Qu_56i0r3Lr zxD=2_heZOkr#sam!egrD-H7cg=r<)5wC+S)ZP0EUGOkKfV?<)JyzSR&ejae{k&%C zF7s$tPk|k^LzwX~z90rAod!Bbx_MK`pCFkBu0qoH0zj%(W0g^_>Et%k! zTo88*Q@3Eu)?c1#XUL_KEwdkeU4H#2g%QP10q# zc?`dBM<7sxHS#J*Rxy~kc7epu);vs%)^ka?cNi}z|J>2G#5{+Yxys7}4{Ah`s8!#jr++I28F)1R?!Bdho$obA}KV>xbueczTif@(^A z{pL>|23HoI@Fq_F(5uKA-dgFT3`HSVr_Pi(LK#u*YQ_#?4S z^_adb!t1njf+Sr~8vQ>KJWBI~!WL=&20cw1 znfQa2pAE~a$oKb|G@wvtyZ_>uk4!@*6>1p$%mk^oq`34*))@BfmIqhbhb%gXWfu(<4z7i;m!SOW}l#%7^`cjcT$Xnb@0vVD)^tRqaTQ zZ?p@m7W{)C-cJj z?4r2VEgCE4#4A~sqBtu#wmABU#p;~deg2ztm}rnAv@$+7UA4iyI``{#nvNV}qWX(Q zHhY45z#}e<0G%NJslt;<72n|m0Hc1`!N+u2wq-@o9h15zv>u9#{aAU;t-^{>zNb=u z%KHv&?#hue^S>rnU-oB#L+XK1QR~ou1=AK+*HrJaW<)}#j425$5VLViaXm80MI0S9 z5)wi!avK7aJSI<#4e7~y^VPu!qSn|)(0J;Eoxy{PnBR*GWGu1BL)4)8)<(^> z7VxshIZ$%lgL61P1K#Gl48?4Dk?A65P#9M^1~!M1RAp<+V86Y~ukUiJk*TuQ{_PH$ zgV$Pi^!p(60WKc5^!txrd5B_F(AWiR4xmZba81%p;w(ikPTedQgd6kt{10sFbaJJE zPJNMnH`!&0iq=tnD=WDDse8+>g4RaqmeC4WtXx0@zjo${qw$5G(=;OrhCh!&gk; zGql7vYL4NO_g_fHMc4k}3!WG;1p-Ik#(8)Ij69y&v}~Xme1S2pJ=iH2JacGb1iJ9O zH_C^4b_ABNR%(5i4oKyYH@o+iOTLfCY)-~_6;R($KtR*4V0t8IinwgQ8 zk8p~n6L-w{+)9#yrx<-%IZq+14Ku-wxBr)2BddxliS$j2cR%29yw9aRF`(YtLDTWG zg;imQ0CRCd2(9Y3MwaRVk*39!=szl40lIKf|EU7lcjQAEDXEO&=YC;+DLl7o@g zHAm7pfA=|<*Azf~H9;OpNBhP8W4&|>TqcCRvT)q|8>pp!-xqM8f`nDXmt!1Yui_RJ zaU%yM7t8VPjMn@+;ZyiZlMt$T zU;^J@@bvZff7yorc2_pVtxw6vP62I?WR$aU!#bcJ-N+Bigz9+5`mj|g@k__ERFG89 z37cV>XmA=|2kB`I_D>>OXwj^wYIWr=nVBS2!uP}mWPq2(|3dMJtCed~s)clVZp}4p zAF>r)S0r~!t3}X0>tWwYC!te4_DEg*nx&++wE!6P#d#d9OM#7PwiQyLL zQa14@59hgZp`5J2p8RpnO~*rHw%+GJSVTgc;B#llWgjQhQCxvklIGyC-R$7RWH`G_+2yO&Ak>{VaH!562(% zbK-j}Nhs<&eojQtheOM?Lb(nBe8Eh%}cnk87=aBdr#qr~kEEWssMUEi_ z4d*GA0hDQ+MwDqPAFvJ*&KKz!q?kku^UZ=^5rqeAJdpP=^q2*m@T>vC*Zs<9{{j`h zCOz7TKz|&NaTaX~Y}Z3Wj_?EurVFN~;Iu=)a;^ila|#$oz>>+50uW{sg*|kMk8^cYc@yhhaD?X0wvC@ry-c@ zC2qjxM`Hi|&B;1OuGdPRfZQO?D?$fuslot`8%#?oXq$4GFrEY6Wu z`}zIuNR_2|9%zyNcf<$ggJA4XA{cZ6OqVPuGK8rP4VXo{5pUmxW2%yo^nKH*T z&qTwGTWvRF$!nZ+RA2J-A2Ew+o3YW7?p-vTyU9K!hxHgsvWQRB$ z-HHgic^+0i=rZo{Z554@W^58 zvtSdO(D51uvy~j*=fXQ?(~X|+D>k=j&v3nTzpoPMYdBD|e9Z;!ar2vp*z{CteeL#aHC zm>l{lIdHj_sBxSO2rQ!xiUrm`hSnwG&q^p)monsZ_}wO1)AH32VV11FSyeS-$dvi! z@zRk0UI|KVt8e1+dxVeQ0jaX|r?}-h0(J4_*MNNfki4Q67XOGm;4*n3GhmU=gPE%S zX$9l?+3*Z&<%D?ek8U@EiAyj4xkL}7rAur$Fvo#EDViPu5Q%oi%4~=&3n`87ltVf&qNBJHwg^?c$G~kqiw)>rz1>2)jTV8zr)U5|Dy) zM}Pk`Fvs-%1k?pcgK@!8=p7vu8w>FvePl@q=s$=*`;Z7`cGNIdC^|(hp=9Jv zGq?dIU!$D*ED3=t+u;Gm z6t`pJxX>9_?W+HLRo-PT`~E5$s=bb0wPGJf&_9`njK4vKzkN>cw48f$Wt&iwIOdsQ z-dJaH+UW+~jZW^rx>G6I4a*jpFqzd49+E>Kvk@}QddCO&A$2Jn?_|m3CuQ2@vLPPp zy?X6z(8fVmQ&4Nxcm24(i5h;9aEO|Q`V`$usuUC1lQ;3xOSEdb;aUjDqUKDbDCUxb zr<+(PB^%{A43)U(|50qImU9@Pst{qCLIE3sACMD2h78|T_9B%qUI;RMs!q3!bh5(4 z3q?`dm9s@aV{)D)=_s@5}amf4yyKX_-?z?9)uEH`wbd4*~dxxPQg8BALxF!&6)o5vyYSgjO&3S;y<;Wv$e@zT! zt{VL_uc)`_wR{lLVMG z{o;^td>pZBJZdZ20}2rzNE?$QeR#2_BZc{eQyuP@i3{$iwG74E`FacNDl}+*|KLLX z;K{EM^%?KL^jk_bil@&pQA#*$#E$f8-OlURI=Jrv*4>w(@|}uh_zDT3<-ol+P2yR| z)n+KoRi{xBAdUZi5TQBhcd_M@es79vFUhF#vc2w;9mVm#z@X(3vbAb%H z4V`r9@h=^U$(F=gP*j%0D{czW7OS>2R7~|~Rl=TPAN*tV(-$6GCR7Ily?!qwOlv`T z#=EG4EVDm92Q$eb^*=QQAJ`%4rQ;P zUnI-^x{0ODFewU7WpzM2`3fo`2uU0(SExg0i`LFV_)W}xvbwy()HMhpj=zGH?@}F} zfj)*Ib21vmvc&QYT#ku8?!{b#I~$MKfG-R>P1=NCC10~O^_T$IZ^O|Gkmd!qlqcP{ za0u;8G)9KgSh@L->?-&&CGa)an>}QduwLKWX4dQ#fxq_~Ajgze4g}Od)_8TPdzvWI`dl3_CW0InaPS)T1(MeK6qLD&?EB ze_eZeXAC^Hn||MLD&I}@tdqR&m+J1tQe*vNwd|D3DZTVK19gj?#n6jhF~N@UI)pZV z=21Ze$qTe;f&}kAS zblUzkpi{{twEp9XN5ktxNa1GLIpo};bE0g1LDCvR26W~8IcSb$ZpZ=f5G8{Q&)-4-o71o z`;@5-_Sga9V}7xmWfTN@pOv8euUT?utN1Rm0?Z3$Z|5>b4QbV9R*NJpMKze~n+B3IQ4HaOqcCd<*n{j1vPfiDB-K9Z^z*-v^~ z!yxK{Z`fnH%UuGbr)jE0kRM%y5fJ2!MbV6ha*)&y53*OP0(bkyxFLU&HhR}742rvd z<~-G@vua@z)18;6lcJo2ORdF4acad(z(6ohRD zIeVB<35$Y~1sdr#DxEhJz8q23YDyuk4J7D`vp)6%Ve0?&7}j-@yiRM1ggxer;&U(d zj^(Eq2#3gR;5K0K-i)aEkZu6^mCm?61TiwguAR$B{2`Rm)|JX%{#lt$Cz;}d@-V)dnd&&j zsHReT-jAAi#*uW&F<~Zs23YUF)&)wzLnS5x`uzNCX;T0RFM@iEb`D2xfaVFnE@w6T zP~}s==hxl@s~8ZOAJ8|37?nH|k6<(2+n_U@>%$LK3&WFdbx^4iPS#LTjhk9egK8Im zQT7hN@+@6i$hopdXnG~EJCGTvQl7z^0kOChDoNZCC$n^G=US@RQaYrA z_BdSQCl$$HrThKeF>CpKbfr_%V)4hu!Enk0=3eC~QeI?Hr+_83V9?#@gg=rYK&3X8>5gs=v#*z}4yhO}GMQ9d$ zoHk+0wo~&E%uQ{B2ml22=xv8WkL9kI;Hut*ZcVH74W)dEC@XEr{!?NSR@(y?pFVAC ze_~-{CR?{{B^o)aQKV2+zhFqzxSbC)N{tCAUTd@Fc^sXro7eSPz~wX5Vw+ z0^-~#CY6y|@4ym>lheLp1-BfG$3MtMd1>U zVyy7g$)n_0QGd!h!A+GWuI8nRS5@20Yb$k|SUM0)mmV^S6C|q3#DY?PmoihYS(OZ~ z@5Lln$5IBJ-;6~1a8nvB6uc}N#vp$@qx46TBs7m9$?F8rq$nNT9j~`S_iT!2!418wwXM~)#LU%nzkxE1x=UEc8d?2Xk_|rWX$l}<@E!) zhNM?m+f6*`D)=8w8~_D^*DHa$X@92*^YH9<6>hzHw1GsYyLAIqB}Znl+(|ggL>QM^ zPVm*=r>lWU8_?9wKD-JMjzjJyfqPiaY`;{wt!8~cJWtv~_1V(raB^)q3}FeCq%4VCsW53hq}2?`gaa;=jB0B~-bq2o zdwMHJ4PPAbrK*Wgg!Ke#DeWm9QpMgEEy*;+%sYLlDFSFF5GnYBWG>zE;G7)U#|znG*cyqZUN zm7jMbD9C@vI)z%%+p3YC+iI?PlNaVM$gTT;+NB;b1*}zO!H)G-)U}300K?V5@^?Lk zXR}hc0ZzPvG=u+pfJN3^+%`yhi1;s2S@H#+xcY@{P&MorX#EDOGcTCbn-vamT0T+9 z@UbcO`Qh9W@eqoJP(Z+fP3tba{&%8~?In*H zjR|@_rQymNRX!1Oqg0x^`>Zr=ZM6LO_qY}+{PK*~1pHse_xl4Oi_MUd3D3_7!U;v= zm67jKdj-V*WJX3&>CZNr4<*-Rx-9m}&q=zu*t>Ct%eH*Mz=^h$@UOfrfQs%pb#gY9 zEaY=4hJ-1iwg;Y2OQU#SQB*gr`|&4oB{Pj^sAJWaS!qy2MV8?9InkS7hz42k4JxyZ z@n!+Yns1>%Vf9&kRU=FxmJWH^4n$etAPn`?`=3vjh}WM}Dk>jeOlHy5NKt2$mnw#rIKLq;X7PP1>wJl8V1B)rb!hp=g& z$+@$(??*~}NXH2){ZT2G{!7d<{VK}m79QZ`Uer-fAH*-X!|mhtr|Z!QVCQ-22G~1$ zbt1$v_*MVa7oGF^12k8OKJUo5qnVjf#hd0#v|F|VtX_L$}^~ab;g2@ujr=si7((Wy9 zDQQseRWg8k*kCwSQU@uzj_{O18&0B?qyRrtxjHGodlgP23u6cSs)XN`0RNpJNd1jG zZ{hMPHyN23d&i_5sCxpYH{nddJ!=M%Ga*t4@?iEQ_xou#DE4tGcac9~>6~xXds^>Q zTy`>dpK_(XKZ9@JkOE838NuSc%W*a5cBk&Zu<~1D$?&VIZE$cN-QVY~t1jDWrMihm z7Rjll6y90W?(e17+aE${(39Hpvm0Bh3z&vxEkdpGojfcRUpVEeHOPZs(!CaCm+g`f zQ(Yw?D%N{#<8r|I!O&oH8sgw?Z4&k87gWDYf6XLc?^D}V(&W0-8gnajQ;kVA>UTR< z7dP?$k-HNB*J{X;g@GiO$D>o2s$oSI-DvzWoUX4Pdyav1U8VYBuC)DazR$3ezVy2U z7&MP88v3u3<>&st4nJ~!gHAQCf7Wcuqt}5~8^SLFu^DDDUs1GO-6T$ocjZkhK)k=e zKNVg_Mv+Ax+Z9T)1G8PiuLEN@m_yT3*UIF3uHW9dn||&vw*nD&20H0~^?K~67DTYq zVHJtVZq(PQ`P1J-TdvljaTtpCW)m0^4a)XC!C@UH=B>yjs{X6K0;NqL+71N$hP!T1 zfTKb_7azWhTL}BkI=o9jTk}G|opp#ZK3pGy*Ikl+M_$5fBUIkxkT_&kAG60Fn*Bci z<%-7;o`@BJ%cMMn#&Y9+m4njynZXG>;4HDD7x^*LM4074Z);BeJP2CyPkGIfLAp39 zbVVU)-gd6{)w9DO)m}81mM_C8w1eP7pvuaJh8*S*e+H0z(&KjPk3|f)9DTN6P6mJz ze0$^pQg;D~|F_-+{O8<<(*rPG+XgWGdK^5Pfi31_jIGGV1iH$dlT}kj3rrA{xtPgb zT8MzxF=Er<+TbEzFAIap1Ql+!Q->~&qz?TnBMi36(3H9$f=NI4JRs(iDOgY-zKK#4 zM-TFGlhZ+L%mf{F;C=Vne%s@^({Z|eeC%h<%Fy0_XsuIWa$=#yG!%@DG2LJk4$exK zVLSi_YoWyz93Ey!Y@xx_9DMD?**rKf1Cx5}EEWrM{v`)IAEoz4NQo`K@#lhl%m}{d&JcpnfYt^)gX@*TeEM;Os=G z=W90$>PnFD*q;M=!pC$P#Epp1^|;se1wb|J39CF0Xkh=I`v9=6))}mS09Jut0IPNs zwjTh%*nMNiccp1~bFOQTgc;QH()rir6A9uzQ8(i19@SQu;NBT@5`&3DE?N}U99!h@ zK1(;8=Dy`kUx@W+y+TyU9%M#n3*EfI8ZhI4UYKk7(;KD}Seg;kCP|Jx{O24<9HYi7cwWRr#yGYYs6k-cK9Dci++bYB$`gi4Q+EXY9jaV^ZpI0s*BkyC zq0RS*(xo@P&9_O#n{44|0Bp+*MAqWTMS^W_Hu}loMxTh@Wllug9k;ItfMcJ3bXyNE zLY4`#ZQqkKpW@+BuT}eTSKex8BJ|l6*kdKSTh2;fw|26=0krk*L4Y$~s&6br>QIA3 zAJ@_UKY1%CA;TZKMD$QHhzD?Re+ynQBZfVB5;;J^`nbphG@?bPxk(YAcXx$!@XdO` zh69vQko?q967Q~30xLF&fT1H!QIH-1z}6f}-O?hT#ZVOp_H(L!%&z@s9lsHM2nWrU}5!AjGmg|BwW!J*S*R1&?s5KFLy z&r^YuXN8>M{_|hgWHllTGQo-Q2Zk!tKxH7I;C=#L7Sg?-B8e%|OYN5^?w?Gkd%F-m zBH0PTPhAZLK=AgKs9&(Sy^8~4@;yQo7f#E!Bb;$oi(T)N{q{uUcBLVFwOL=U_GF#~ zi%f^o!i(qjalh~BZ=-M#u2>1@4Hn+uA@(3G`#HaPIjWt^G?tbSQ&ST-LMn|`Ms?`F z$CVHke^JXVvuMHY5Ib2JY|VE!5a(AEk_(I8Z{pz+mZo0UTH`8kso75yT1=U^CQ1&Z z@vT7AZs3rm^T5-?7>s2+9`ykKkEgz7Qy8Y72o7j~`xJn9Q>uhkEPanVRin3X?uR@H zr=GcPOApPUTnq(j(W;pTv2bEHpHqh3QZ5S1V{5Doxn|q>3k?Gfpx5apn;c?$%Vh2j zul0!{bHccFHeo1-K>uv51uZABoCzGRF4)8<(3ExmzaAp_NIY>g2T&9&r)B+#?`gbu zlBld)Gf!t!K-v`p%BoRQJ4NJ8sYNHNzV0^v&_A{*gCa4lZg4bYM-eguG%+|YrTG}I z=*T_#d$PzKkR7lugPv7>R^H$1!faI2m1%WVn)L=fzn*&DD(K7S932(%cfoVN1v7a* zKGzPfzPv}Vy(Ax^1{+pMVTTOj=>GL!c%#HwoMLRhbx?r*zeI zOW7~R;6?YP;65Cy#pSusXkIR;7|)SUw5(N+`4?5{j`e(M8x2E^AENPRrlepu4{+N0 zb3g0KhUL+wh7l9KQeC;GHZein)W6f4H_0bkVY;$f)8d0Y%^{CUsw!4n5lvgJqocQ} ztdXc0U*HJJskPc~bogWu$jzDf49 zS3Q2R`^!pZDA+R%8{D3^i{g;eygG`0!Pnx9Cdcq&py`?g1|ZEF?nsocEs6?%#pR`W zio9E14J16V_ktq|nOLI&=O_yle!xM(iM@4Tu`TfjI|=l^@GUEaI$nf-PMG*!&o9P7 zIPVe_SqcHj!T1hwP_C`WJ7talGcnd5%1_>@jDJ~3&$EoT{iq-!ue09b( zV_TJK(i!}1Og&giG4j$*ip<3rE#@=;#-(z?$Wn}UkL0!H(R3~Z<{EY%Kj{jL-754Z zHqytom#gMHSG zSf8Xz5fwopWp>aW6wYR|Fg$uWgH7eS^Bm0j^t@=kL9%M$8Neh^mr(ZdCZ4(o&yQ&v z%`Vc|+ZwHkh|miZn**XHu#(;`Mfw;-Mprir$e9y%9td+&T$com`(Z0whdxBp+saNWa^z&YSvVeHbeT50VOM%D{!iZDN~-MWI+yGtS>6sp*R)!zL~}&L z!1NTwVFsw z2%G-~jz5E5tZ^~5KR^hMO)rByBu)E!T%hQ6RlUao`Afg1MU%(Hhv-YbEv-N3=B>8%MdpZ%YB9 zGQg%=+=W;@fSnP5#_z5<00RTv^Ftr(BkA{x!$aTWpu8X1=k4MkK!Eb|HtVjB5EkGA z=$Que(tO@d4FY-@K5x4Q0S2hwFFyMLeQ4h=ocjS|VSrrp9Z%Is{rvzz%k4>>y|#Dc_xY3a0Ux z{3FxkjB}c+ckq~xWAN&$YRWC4Q%*jm*6p_FG^)Qx zW{{jR0f zE@lkfOB~7O?KR2AI;6Nk0%3GFK_8m->;OuAgzkYygzR*X0afECr|fjCzrKmLVCuI3 zq3@O9LCER1us}PV@1660$f>07T_hsG{Q#+e*D&ONWjt|m5eae;e-Pb2E7X76|L^rm zzsKQF0?FdKeC;m?L+2E^5Q1EP<|p9173;NZ#XgKtsn4!P)(g2^2_OOqzrM8 z3M9P}SR+h>d+{6ThnYm#ziCBS(uru!#zJJC7M7O1xrA|PJKqmw0?YRRd)R=7f!_(k zzb*3x{4^3aZD12V-6$l0{m4JGW9No41OgZqE9Jr+8keE{4PJ#-JW$uiQT*2!Ws0Lw%)j+7ImvK2RqTAmSp z=^wU%7krVHERae!7tadNiPwz4B9GOQ7@dmfcU9Pz=RWEniO9s8hxa*p4PNf>NJQLl zTRsTk*r)AEk-()cN6u=4@MbKm2>o{O_ z;o9XrN?d~}x@U}CT!mS!5XqE@U?N!vwLG}vxHFV4Q80@7$VMLcoD!;Cn-R#lGMBZ6 zn#%qS!ksTNd*t(KxZ2v85rgR!a#}VRMVTLH-#p5R$;E^RYRko<%in>@wuzV+rXpPw z{H|vdW<#rQpr~dyTSg5m%;;CmVy~h-fHW*1JBgF3yp~N%6TN2%tV6ItCc@=1BdKDj zwk3Ne(bR^yBubDszuELQrV&?pN}X57WAq!w6n;@850}EU74mm-U9cezJ{}L3QJBu^ zrkL50lK8k*l8)p%vh}}QaJhrpGqy~AhwKKzkqn;)XN;+>L1)Wp{%dc~QqAyj^?lYN zGX)GrNGyEhz7ArpaIV5(;r7oBD$Q;b`>?Vz+zOsp?s9*yrpLlOP!6iAWS;}kMo&74 z(i#J`8l*AHeIw9%wpzB}0(-0uZsZ;hX2y}>qH3gt|Eh*yoxMqNI9M%Oj5gCEo7Jpd z)uWF?G&%>h%e^l2jownq_+KRkxKkAO*9^Am@ULKX5t3i|th$!-s9kNqsfZIH7kU^1 z`WM&N7kH>i8DR4n0`f;0qC^9fD>S5rkKZ%oGb(-TIH=2DlaBKstsd<=+yr^0^5~BC zw@sTPr5W>-+(riN6n7lTunf`eMwdh=d73h%^GSrRe4SN}jojn8X4Z8BQ3PkIxs4-d zMecXAk>5ce@@f+B*Nu+sXTh*Df7|OdR3`F}CP_44>RJ~}et6lygzD-^Sh z9VRWrivqcdwtVs-Re!YV($}_IU$0P$E;R49)}+-s7XZ01r__4D-bLI41Vl-HoY(Ek z2OOlX`h|MTKWs?scC)*yTa~n8kC!TUHmIuBz=z*YiYl9am7?ceVXgm*UcXmi0cC3$ zf#g`VciB-z>olLsTosWzbw9$KUSh4bUh{lu0J_|Wa13r+jrUF;&JN@C=(W(Hci|ra zou{Z6nWmY{LaD_za#a1Sykt9-X;VwY)1F$>y9r6uWOz`{% z5cE9*2>t^EK>m+m{;|Z4N2BP1?P}?0jc%R6jizS^jYr4+_0G(*t-b@?Jg3Qz*v@-E zg=xj;Ewm~p5x$)q(&+tCNhKOd74XTE?ngXQNi1QqwJ|_%pdd$naNMkV$y5CF2n^5B z#qB@j{zr?Go|o*G@aAa12k8$TsZ@ zNWKU34YhGv{_|9zO!~EIR>ur>_sPxW3!#Mgso50}pR{H>=;95MyaSU3i_oZXp)! zcg=VRcg?)NG;U5uzcyaKF*&ur0lgC+{i__AbB5!ufLji4zC1^ko<2L5tuMoDy4`xt zj@?zWPk>KbdtWbO{fmS1)%OHFf#FzN#_pWvJwW|403BdB0{H(l0T3gAd!~Ck_e1d$ zAh_1+_+_jg?wkWBk2p6FVy=^wA6YlFoX4dD8yt#S9Qx+KZ3GePEQr(Zeg0me<~hu3 zO-sQ!__tMVffsr{{x%lwy@7k_v%&yiolSV(fM`u7p2aUCu-Y0BU_|RU+@$__)QLqI zxJ32l3b4PKGsnR{{HWVqC@ncnp>AW_1#6ebPw$SZ=~>;=8V;JSWeBDcNYZltB4%AS7s z$iN`pY#f*rn1?{<2b_%kLSbGBZk+QhLVcXb(1Af?oW81r^yePBmG()m7?Jh+B<1OlZAMVdALp}O`*hZF-2}Yc zo-G8y86^*>3&yKc7s-aAJfO?O#pbvVA$%4;| zFT(*7eW^!;F5e?KC})h1SUIa^g*-BfhY^_~E_;0|4O5szYXUnVoj2WA<4@&5w#Xy% z6JP{MJP9tEEriP^Op@5+1-Ueo5tCCd6e?LDy9@7 zhu(d#1GXR8S0)@nUh91-G`c?%Z?0b=teH~+!xY?K0>zj#yK<%uVb3sry0+(p^)iQ^ zCw4MY_<>cvL-o1?yCt@3xQ`L-y&UFF*Jfab6!I4QI3o;DHg4dKQM_a2@O9zGfDU$)aZ=VuYk?Bt zY}5R(@g~MJ&_gKF*NLID2J>z7s(Lq&2(EI7$3EN-AL0d__lF$d?e~DN8!v<+8ebn> z;ES0^`E7UTDz4nnOHJD_(YoJgW>Q9d+E-v_M%xkO{@@?B; ztFD-$%|~xx49o(;bNSlc{Mz}|nhs}f`Ar5QT21E-2`om{w^PgYh)bi<`ZpVnw~C9) zw^r(!v*>5Q zDQoL=uH3*0&}{$NsZWYaFuqD|*UlvdzEBPxDiwy$^4mHWPAoXPCYtmMZ2FZ8bA}1c zTm||Wz0-5w+MqScA*HA#DtS1$Bi0$)Vur)yMTE~w9)5ofr))RpN}i<~kZ@}#eh9+O z8lq_0`_D)Zr0s7M0uB5mR|8wF<7R{gS#?^cB0O~8ce6=Q-YW0koIM>1hOL?oZ<>L#9qJeuIXKZ# zu^=n=NAo(#oANB?C{K&6BuhlO?Nq7Rc@YDlSI+cZp>&~jmFZmy#mk?PK+@nbsdV4= z*Zk+v3Lj;IEoGGKyr@~Sx2@3~lAjIi|M(kTiN(x%gIl-%Bj__=8VM#iE2hr*XjjFl zZ(J~)RD9mZ{+qtk)-77Dan@Wp9k6|c4qcgR0ZiglqIqvj>&4cBFf?D}x4VS0l=0`7 zXv%7ul(aP)MCuFftSn4{jB2GKUeZ)<5t=#2nL4faQkG`VvI?lo`2_i6h8o#!H(^@dSZ7rL%~cKd(dt zE^c8n4}_yPbqujoA8q)^OwY`Qwk?y2eD-WU2Z-)bffh#TvL%Uut<5)x|Lkn%91FOb z`*+PMoK1HY;qajMTtrGKk6@~JH_c#%BUW9qo_dB2%jUU7>LSNU|5%0Adelg6xxmF& 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%0Ars=Cb7MszlyQA55D`(#n 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 z zKl7ifMT*okd{?e>pia~~DNx=hU!X;bMunkfbs4p&Evv%TWBwLk(4`0l9uOAfc0g>3 z4f{Ea>92k^Runo4D_oLw+1JF*lQx^gdZ5K9u8%eB%X)A&Xy&wNYj6l-a437`a=EL> z@1cP?nOqL7TWZKIg`u=G7b=_XXU?Wa$|0CID{UDBt!72lfcD`u$q=xTQuHfVD9RD# zjBXnI^g}qjKn#}wCx=C%d$H?>ALi5DH-R zHcsZb`(qj}qa;>@(q2!;_vKk?Plws<^(}!1AJj?R-awx?a?TlITA5x(eBN&F%IIM= zEg65*8`y{rpShO~JUZF)y#D0l_p!31Jj0fOwQYivlj9s!uWyoFZ@2d`GT254`rRZo zE~ta9xEH5Evn1=Ch~5qGQwL3m^~MbbUJrMW3=ad~deA+!nI${=D4(_rd3Zcc&^0UjmuII!SONSg)LYxzr&YXrtmbH(7ZXuOI+%6l&`n(k7y;I5UV%j|b`z z7WC5(EG!mt$WYEkwLkK%wckxpHew!_4(PC5ty%l9Sz9%$V{&FWb(1W(^fWDY+Kr1S z5GgFB>lZM_{J({4V`Z87AU@>FN{6Q6bmn7}j^xH6Ok`EgOI z%nN54>we+=Tbb%K8Us?ibO;(f$^9-kS3pCB!(M2Oe|>i3G1^L0hLzvO7Zx=|R|Q@( zOYT$81kHh8sK8|*Q-+xESbI%R@!TG-4;wnXs zS>WQYw>O>6YaT}KA5W+u8Co1rVVho2MPKkmUthcEKL7v#|NnfQOA5j;5J2}mMK@v> zVxb^-0aqdl9zeuc5ei+j3#Ih#PUat5UFSDVGn2`09vFZY7vlw@1TiX#a6|do-(@N9 zrQ;ovPz#zGZ%~JtakelZK&+@a`_TkFCMDs!NiaPEZ{8H8 zQ?|+yNG%5P?zk2zNISXlyiEmm(z5ke>w(@BGdC!Bi$p-e)))%HUUq=hE*-AOCb`_hWU=kYX8 zhJaSpdZQ@BZ{(j8+{QeEW9cpOU0mwkdOsqZG1NJe2xV4b0ulFgNAM7Mci*DsP%t_D z@|7Nx_p$;dm9^^sb(vI~W>WF>>qgf@UFN5>DSc3th{p{$U)QF64CM)IYT2Dvz-b=<00960 z>|N_q8_5y>9Q_p=t0+SS#I9B#@BuL|UvYOiQ%0A32uVech3G6KN-Ki#TK{|I*N=JZ zu54U&mD~qk`KZ-w&rHwkOiy=DKd6{mhoS8AJRSV1k}0s6YTfp#x@pOHT*Sb24W8ks z`Gykz@XWzMv);d(S>H`!w{r-9KV_8BU@n3VLP){kx8ud;Oz29;&`Kse`&R&~I^)zj!J0ii zl9ft2M6+~pCYiQMxjro;sn*>3H41}d9c+-!c6IH#p2~IWYntgU=OYbM=+@T4w+yq6 zdX-jH@oPBv6$6?&Xb(2fx&@Kd-F{N_ztex>%pQ{7UG`dTRwAjj^T%^= z0|!$CKyE2mcfD2fRM8h1X@IAIeu0??XCyf4t;m4D*}6o$3v(Q(n$%t|mtc}$uepb$ zkRztgitFmdFEH1eknLgm!F(5Nk4V8MT5IxZS8LG4crme#lb*v;jWd)u1Jo%pRytp~ zV@cAd)3t@?DG-WuK9uB-?B8Ti$>ifjQA)w?!BP%(W~|(attn%ODP{#6YvsPPktZFZ zt>6pY-%iC6OB)+_mZBWyL0DtbOy$uCov?K~2b3D~{Q#-@Iegk$H08AP1MsbEhQ-k* zJqszicLTMaO^KoU&p3Nje@9A&G@p1Jut++Nl^sJJz4EmoP=F||YdJ16ashC|J|1!2 z3SoyZG;=h3r?MCjHPZ2rL^MRnrq~Mz7{g(FG!ZC*N8e@4V_q5oI(j?F`_`Gyd4> znuf~l+`uT%5CjTTv<`zraA16u3v)s9k8vbk&Z)gfF+yllJB)hB0<(1=c^(cUbn!$9 z7N;`~>W1uAw63OP!AKL+v6vHwZSf4aWf?p3%gv6ZpxwGDDJp0YMVXH@1$LlaVGVqpRcCyhE{t?xO<{glYK7-CAK zGbQ6$c8BXtQ6)+YYgOJ-m7tM)vjlcy+;Z%K)*s_j)c3v>P|(Y4x&vM5DSNv8isSQ1zV zY*Xw*b3{oFPb5{H&EEUMKC4hPZ4At~$R0ydG!?WKkd%E{$uJYvpWFImj!}qlEw$q6 z`w3|TV~hE_jIy*2&0d(0+2N*Uc$EwcAx)!8M>lURe`T9}4ucq?O-)j}Hw{H0lJW=Z z1_}rRSTsq(cI9R>qc{!=iC$`XSur7f8i@KXg9EBS$36yiy;qQWR{sR_925+g*V~Go znpX9&qOa$7N04FjE1LGdOk90cnS{^IkXu|7CmZ<>{gf5t89*dlqbpOkcJ&*vODM_~ zwjo4VCW1eka%8JbO;zsULlLG-#UfaVAtss6Ia;YjQWc{d2SmLQS*Tv_3%Fpvnk^{&s~T^QmWOKQq-15K(pvy zTQ9}4Vxf1+j+N9zEd4<~n>;L(t1#rrw&BQ>GJh0Jj9F>E-#{?28%ZMHw`uBI7y$>> zt&C8jy<66YZ4hi$7|Xom&n1OcKjL#=X4fanf++5m$3CMC(1WFUpW;tv`CRh%HQksd zzSzr3s`FJHQ7g~sYgKoAD$$kaSV7eoC!22NjyXsnoVkZHja>P_etQxp%LWN2u-WZw zn!P9K&$jXt1jeWxt;Zj-{szwQ-1=g(*xrvmc^)%}Sr0=@zm2O!KmTYN{#*ZX{`4M# z^6=wklC6BH*tsFE7z>k0~!g2O}81^906?0QCO3^Wnud8 zHN7g!L(!!)MeTzuluEgN6b!m>Leg(xIx7I3sT z@v9Onqzq|)x$shIRy@I%ewb6b6D%ePwCsrx=B2yQt&ttZ>d#MX5S^A}`TUeEY}^az zFwJ2lYRvC=txjido#WV}Eq*h;C0)_Og7qF09$H;~BuFB;qFZwtr_dz@#%qIbi$YWK z=K0kIf<=ZSwwT{k%P!6c&2hPGBlp=1k?A-XsWJfbOl%zb*31cN{4)KxX34v%B$fGm zUA%VZg=AI=MC?@xQ>N8^)T&#UJx4cvW-U1FS{Pu;OYVYMaO9dv`PQ({NweTZ39A2R zA5&9^1nEsD&qf~NHffDh8>$-8jn6H@{$epNwof>=@88MD;ve1)gu!01ef2Pat4y^0 z6RK<DEBb& z($8CD?4V}%Jfdd%)A`S5y|+JJeWINA92nrRnXuvSAvLT6Y`ei|i@Jq_fKc2xYbH_E zcHxs<5LN0d#;9VC7TY%o-X!JHHcH#&(iEj>T`L{D>6A-%P`Xnt-9_ncT`OI@>6T0P zP`Xzx-ACzu&2<)taeOFWh$~?tv6_QxCuyhUeL^^pgjY*7-`78Vf)#SIEbQkvTRJe? z)n;7{PDkcp<_@gS{Bvhnuv+*+pwi2lD8sDr4w)nYRPjAs@(Mh~whGsH?C(<4a%ajH z$V9C^jM8K&HzNed-gGQk?XK4rqAP|mPR7Af3q{V^A@RPkBRMf6$q}PNz9TrXDa@Ax z=U;nuM~QxB118q`3a4tNT<{9QVTel#-yYSq^x2obiqAC*hZ&eH1_toHs{@M!lJ_1q zwiSQMh%;w4yrt+dz?8wQu;SFcIr-W?RL#|DSl za;XWyk;I*Hla3et$#|G=a*PQb;GwgtLr#msWDe<&Vz2 z));m3yMi3)<0zP(Vt!|1%PttgJdmq>05)DISUxF&hz9{!K2fm2jereqs$heg~AwO=Gpv}ucFhP*GzYQqe-?WV~~IxxryN8 z4JB4CYNQFatpVVDMg6G5G{@Y6&jnn<`5KF+)~#9ja9A9r&qYguGE9pjrX;Uuc}Z2k zq-#!#DEM_4C26aDzu^5NUYCBxDj`4a+e$gf1C(zAAqXiKv3HF)c~Vsd$HIt4$X*ET z96B9jhzldJ-R}CgRn%Iu) z9#?d^v7#04rD?kKf_Aehi)6GbT3rAv%R#+0;a$;c?N* zTrauQ!F}+g8fwkAXYJ>Css+Df>5*9ZM3%sMIaTb@#o|uz!49KRt5VZ}`=H?j)wEaB zi}|qFB!zi$-Z9Ro#C##2RVPRAT)a{H_iuZ?`GYV8U#M`=`|2vanko$n z5=TDN$bVSC?hJpC#WhrWHhVZx$Y6pUTqII*5x6HcOiUHBXx%6_db4~x!Uc;4f>1VbMxJ|h^O z+H;I0p|K@97=Oa!dPDF$rc;7BXBf;&!sDQR+X;VF;NNcZ*TMH|cljCPPPxrvz@*$} z3Ye7V=!6!4d|AxN&Kt%bb$4SfM_=7DE=S!i*X`n4b{QY6Jz5pC3b2r|!R*Em(S>#) z?FymccB9_U?oo^WryZ^o1HazBVb=@)VjwtiGG{ASJ=UCxz@yKmaJx7AWjY>Gcp(Vv zVqgFcM0!9DD0{Q+xo&92b)O4D&YO8@&T$(Cg& z&N>)ld)a!jDe&MWTtQel>HYL84H5x(?sG*8>d$24186$@9;La32kWB@o`&xwKB&h!=QFsX!26_3B`yR=jGFPQckT zW;bK31BnTNz(fV@_FQoe3vEzvnk8f*F04V!Eth(C#nM??<;=lx90rz-#>>%Rl_(%# z(^m1=t6ot|XRM#rbn(u|FC4XLAyf5oyxPAjB2?#Vu$TMhg^M(rf*TE(gb4=Ou$Gaw zVXiax#xW2ioK8%rI+S)xq;|{1jg{Llfd|SoC&vV4ax^oNUbf%#Pw(qb?5>EM7ozV)Eh!ZlVLiVq$$LE z?ji1?AO45bnjnbnwN36R7ULz-MKQtW!s z9wA^qofyqt_T@4VsGNS>(*NefsQ0ozg#EW$)_`03Z=EjO#9p&r+_pM;I8K%0E9B<8 zsCTp za~CgCxp2CVaMNX|3xd^C1Z3`8nos~OqM=+ZD2WTHK_EM_l&UfJE$I)AtKBZ_cj(_P z4bJ^D&)SsSgd>^H+FVZXk*wa{`_C zh=%AD0eb7B#INY$2L(SE!D3+Q>!ZN17{qXW3{WhheF_|lK^*ljNr&X{I0cr!VD!-} z24>#Dv*^cD&j=AMe4@d$@Q|^n79CVEC56rpPgF9^HK^~6Z-W*IsY*Odu^kaLPwZ4V z_mXuyHE<&YRo5BiJ&zeomD#!%i!Oi2jY<<8%W~P}k9x;EBGQVNm~`IbsnI(EXVon1 z3Wa^t?j@&pQewU6L8Zh4h-M_2`W{o%p}^57fJ)}MO{Ig1>QpP~$DXoE){l4m@-v?* zVc>XXQNHucJyn3_m?o$YD`1W(Le^CTV2|lR*4KAT4OACXVvlM;)-Mq%fi!#kHKbbr zep;14HUfU;fsacR!CncTDD;_w&Ay(@Rbi6n8`R8Tr!JPYEd|k&-?!2mK z-WbTL$M5P<~9|Lk3DPvgoN{hnVjRd2+i8&W$g3$7HE z+ZC#iy0_AWs;ZhwIEevYoWyG%zUnZ5?c0AoekLvfImnZZ@x^0j8ykp&lcd z*UeB^(_5;GNBr{sC8O_-j1U8vFclSlh@+;vD@ttjxcwgI6i!SUn#*uXCj<%4&N!_z zJL@Rb2|~m3GfwNopB<$-p=Vc0dxq9|{r*skyg8b>ERHqpqq@hfPSTMiceJ*kvcBQ2 zdlSuE^d{hgF8YdS11^FF0euq-{D@&*)pH3IW!pjGnQ8z{GXY~nd|oX|a4Ha>Emdm&x0ggID= zV%s2(6MjL4c$}6Jt*&e33flOa*2Gr7MS*_XgSRoVy1Y#k;%IzcCfb#kNjhnnQ)f^z^e{=euw&TL3XEMZ9 zpHius8{GqSL?+UvQcvJuGG75NW4G5#{o1$ugIE>=OmDOiP$Mi18;mZ@p1d_vZcAyg@5Xp?@daJMn!`#(!-f_=MAU)+H*s_T_VYJ!d_bG-Z_IWay!Mnn zOV3bFqrLQ(OY%k0sA~2{;P$^-bLbV_53DMDc^* zR5?#2D(Xu-ltv%{1?70mn$+|`CE17Q&A%Xci0+rv0EqzvW^^EXo@M1)DKQv?C<}!^ znNzk(U-6ASq0HDsy6yOgahxp(pHLGFw^>)9v{z-KSP>za%3pv{MflZ+`i8?=05?2N zcap*+8UqVcEt(@S9?6>nBRo)V&1@vAK`Gb9VU*FJ^o4O4Wi!Ua0a?YYbunwJ7@fYp zWy41v7DqTN$a0juA*^Q*s~(^fGUUIy{^wsWv>0Tsuk^vh1kaGrxe`EBDk*fXFDKMd`L?~@E3d$TpfbZugozi3O>KSudt+2RU^8Yi3gYZDBYVx+>n3~76*pPZ7O^JTV#;@Wfg;xDzK}!A=Z>hdR*&4(P-^n3!Y5 z7UaYTc!(>aBLp~N>);L0T5vZ5z60zyX~32xgz>{5%z_U?O$$8?DIM@IhO@B4Fwuh! zgE|K}j1f)Xph^oj4Cy@BI1mk?rU#z^8VyMcH}z0>6S_|ZbXZOcdI9(X_yqwBAlL$7 z5JMkCAH^0JyKoEuiG$65jJ^#b-|TofO3j**fx1-luNB&bfz|=Hg|&`^Ex2{i>maTJ zYzuT9r_xdWmyp-Nt^>Y~mQDOsW2`RFL9EvcMtmIV2y3JogBp?lrgvH#4UMNS=4u(# zw3cU&YFcQshc&IKx#OBv?(Bh03t|4qrgb!TXwxE`HMX&OdvMeGm_NGJqFZoyHv`wf zR08EjycS1X1ua$>R;=91cace9UExq72pb2;`OM=83N#Iruro z6wNEWlpx5Dx?mVDHhGAk9dNyzg9Yqv^EJhpDE8H8>HiUlwzJ{Ma~zM)KFQzu^P}(g=Z00_#@VMddga-;1wcYhQDSg zA%NCH0DAT$AWTawYXG3qpl-HdL^CfA8(~8&Nt98YOZb3G-VSHD`R-~ZE)Nz!tSR>q zwFNIJIU4>mZRmVT*{My2sAXE^HGE12J01^s_vvk}L`l!N7kJ6Ty7<%By!KCY?WZSr z=_hA0<_DGlIJgEnTiZC3N9Yw&oQvx2-z2ek41g+q4^pxTcK8iycQ#syr5~O_BXGVVqsRv`uY2_ZOe#uj1+4 zD^Whmp*Z*hWzEnJ>OkS z<4^cMY1X`EELq`d#0&ip-JMKGq{!@em;R)#%Nn`1ef|Ci_EL%K3ntGRaB62bgJ#=y`N{$PT*fe4{i(HcMRy zW`->eU_3or$jDpej^@1F<0VHovpbmJqkk++;Bk9LzUC>s_5o-6UO82Kpvgy>qK`LS z6Rt!y?#wbkNl`8x=QY_Q%ugv?5rvEkLCRc~EF%k;7uIY+B%AmQMd0E()T0AC{3?PV z11R()(YdX?CuU=*Ev_!E*U!1m(BR-&ZTnU-b}73SA;f|0*)6-`AUHoIt!A=Ab<3rTS5+v!50>`4qvty8G=b8Nx$byW1*RLT~s2gDu`hrZmDrri!L`5 zdy!zg{yC0hiSo%em$Bol%BR^83sXWwEKndBJ-;PD{`rNftB{U653RI*n7`8G|*(Rv>*gQ0-^kS=e;*} zY(OgQsfq3JI5y+)^VqKrf%&oVES8if#!8qa9`t;9efv8)ts6G2|Di>RVnv6_K-7JP zS=M_|DTu@T*^D8Aa~w~KN6-?q0n>Om+Jd-Ms1Gc9$JJjqonVN%oGu)lARL-aL`-;` zmybV6{-pe`!ODb$go(yz%qp@JTdRL?XEO8z1BB86)`KhE=xkeLWGd7fZ#2FqCk$W9 zvG2xiE|l^}82h5xwe*B65TgLuFibV**zi@mK{v4Z5kDPzvJN~(ye{4~HMN*0h8|I_ zUIk5S-_p`D{#SU&)~2OBspwzsQW`D_ zeV-Ct9V@t6C0;CHEb@~($~U(@`t7wat{*nLby+=PPEI@fFAPN})~~AG1KC{7;50-w zPyQ}rL@L$VZ@4FZbst$}K1eJ35^w2JBjPqdR_3`%Z?gg+XoL>8;vpcljG)@E3Q(^PGAw>+Y=odQKcoZ1}*_*Z_ln*@{F*b3&w z<3`A=}WVMb<6*c*X* zS*bCFqFp826Zbx^610El>2J_^)-`tS`JjMf&2i2Ui>1?Wl2{Tp=1&`M*dr;?iqQj_-7&+vP5*14QIbmcZ#i*MxTsbO>f&U487-9XonzO zkpxYP4#SFI!M4kQ0lVyIpm7@qHR_MlRyuTn|NF>CiI(ED=q*-cTC!-8A}Kz0o7A-`TJ;%Vbq*>(icIB)3PcB+QDm^vw|&hE%Ht zH?&!qgL>2ocbPVi6eW{bs@}GO;45WgJ(3Q`g2s}qK8LE_HaYcf9W-t~)2e=Jvg>4i zMWpoVYjpL2uj1}sF2fEti|gQOy12Z)c*o$c-W+_eXaW&DdKWdfM}i2kf#~Sn;$EdW zM;fa$G8@ys3PEg6@P@j_s(n$2!RS4yB8|%3X~n?*bY$@*7I;p8&upGRM&wn%!0h*Y z%wB|%CF_-s9-E^6mysGE>GQ)U$8I3qSaJJGitLB=p+h3_>PgLU;=5?({1|hf7ED2I z4suY@HG*SxAV_1jw^Q19;Mk!9Kh;2DM>jUrY<}@ME0bqi@8k}~O+v>9Mo*GHxL^J> zj?94W^Nw_(t;_HU9SeO=wWlPcC_wrfwha0R3`%Ba4e58jy@z1a4N3cN-vH3l5qw-}Y7jkPz*GE1;)|NFy|x?aLte zRn{zmj{)xXrD+0-6OE@$~R?&cE-E9db`+As&BH zG;3Zhd^jAom}*cWZGsA{B-{OWCE&9~woD`}!q;+(Yk`5uDhd^Si81qSexK^vStO=I z<+2;4mD3+>|14zVVnYG-=JLi{TGe`ANvR3mBsg(_&)3Tg5uS=^sT4GRhl3^(sPgkt z^%>NN#+3o( zR5pNGQ8@`0=29C12Y~&YBscB z{46t@nT9jY52Fy9VAjJNXxpvEAi|!L6Ft{qPY0aKp@Ai-%dmm^6;Hq^caf3sbd~U! z@9kY-hXFXlKuB`8PMJD#LO3{h2Rct5bV*#o`S||<00960yj^Wm+ei}ro?oFNp)j|` z*d&A`Rb1c_*v;MEW-pt)y$`MhzX+_tmb{V-xKzI1e*HY%Ga4DQ$?k`%R0WV`dPXzd zJ^eniKo0;3KBZ%XLp3jM=wszeVKV~;O@=bIyUQ6%u*a_&JM!VP z3qB*P^?RnZ3+BJx18k&3pr6PTuCC>>4|Gm%O$9(s)VCG zDb%=bK;=_#88d8K(=3~J^xQQ|4~#xDyXv`Ve&T1zgtxj!hv&EvSeRuIb&rMI6RdMv zQ>d2F(J?c5+R;3d_xFeA#}}O@G(FlMtVw-~w`;d)BexrEs{REpp!BY%fLhi2AH-6q0!0vOpS+WsqHEi#)2og2kjRE^we_ zR~HvSxhk|NlAM-Xrq0l&ZY8J$Hfz+AqLV9)mQzWMnk?j;NcJ@?apgc>Ccg6)p#tRWYzgU=rl~=Tmu>8 zaNZ|j`X*h^d=!qQTwv3*qTpuxW@Iz{)+RPy+5~p= zOEkk#=`OrBFpBXX8XuYEw9&De;?B+g3YJssJaH6zgCfZp3i>h|E27 ziA7mAvhzU)3b?^QRwfVxPbKMM14h$F|a9|QM$!2SdQG|}RB&|fKl3mqtx5muf|1mE@66JSZjr$TO|4B`b+BCDs* zgTL;pw{LNM3>IIS5~%J3-|7#j_si<(0UBa;{aNG|{}Ivz>8(~+uRqt#BFyvXgk{o1 zLS7(N6@hW>I_k{=4T@M~@I{)&BkXLh{(Y+N77|BCL=ES-ui<#~5u~@_p9a|;Q2~}C z^`?k_TfiPxog*MnpNX>eaW2fO)9JVaJ8X(`J4k_l+G`%&2A8{gBFcdr&Qa8=uZ`Yq zl6&2{s)wqA{5<~MCm@Bt5cw!-4Ti$hZM4BQCOUq6&koy}1YLhdmr;T*;@scDvn&v|3DDMZiqkw4WZdpFVFtePOTHv?0+y zWJOief1)=%$@Dyn)*H}qA-mbklIs+Lm)cTjU9z-~io4oN0BOaJcx^YZCmM`#9tDi*EXZ7Rz^Ec5!`pBFT53J!IcCh-Q zN0Up+8tn>;{P%~=u&8z?8Yv0vFepyT3SfJ1+d2Vh?IC3f%;sb<3>L{Cibay%JXs@M z^e&buvclE44m_~(8C>t3A_7P_SC>nJ{a8~ z0p11b_l{)pp!%rQ_4KRN-m>y#AO6LC}o z_Sz?Yqnn*%s`_g{4%ViAMT*!=4i5;TCJA&dvo}T=e+EzA{q`0y3Vu)!ex?bd62oB+ZuO96w~|xXOvVH=*8i% zurQB#=&m;!8TTeS8PC#cUams+$Y-mtD(@_%YB-TbG=@6k?^HCT!aVzdD;q<`!dfpc zi`vFXGg~p&o7{HVW~)-;9ng`55e60-0;ZfgdtCIv@^I3z3nkD>F!I4DUz|-5%7Y>* zC}bRu_rQ>S%E^Hs!0VSCL&zy*{AtoOi=SBG1uo&%`QJWlwWF;cPCtL#YWuVSV0_0F z{7F*F38E!1OI&pz%WZQ6nt(iEmK6ndY}1tndotBH9}R*iFPng3y_-z~@eS>L!zSXZ z_e;(zQD`)?UJFzNk>HFst_+jwKxMt$F67zV;#L*XPShj^3tg55H_2T1rm-#q-s#YR(B8XtBzf#!*7vNt+J$?S$BDt+rn$PuY9*PnGPRfGd@vQ1ku9E4qKA99dJ>!#A9ROjG>|Y7! z(<6ZD#a(xat^vTciDlO8ta}l5WCfT`Z}S{rV!d4(o_qL(p%J~thQ6;=@;PBlq38zQ zbBCZoloB0ltTO2BbNnB~SRr0RK$~EY#&_~ZpZ(<*c~rUTLC)Ncvj?Z)^LQqb%rC$N zXSb6cu$j=UB`rFKhx3w_cF_x5CL)}+h0T+mx2ScQ?*MT!C^C8#s2)OcuEjev=`rPy zvV5aL{8e;$SvSj1ckV`{xdV-iT<7`bs;Sf1SNx*!ph!l1pMk{-ws`!Ls)(PDlWK`f-4v~ zuHxnFFRn19BT|f1$bm15cZ1^3f-~R6X`b9D1tn9Ke6l+ftTLVj?zf%ou+0EHp0oVL znG`MUbSqnw2oN4`iRwRshB zmnGbs3AN=j>1gHZ7;2%%EKRzD(j;NFN!%5|Duu#hKLyS~Ii+N#IzM@jj)=St$RUcG zIyLN39_@uqZs@nSHE&aHUPiDK zPUG=4(dSer)9VsP0O!9)9Z^DpwEthGjY8Q#aqA=UJluvK#hVyGZlYmyt+T??1{M#e~EpqHnlvL z>Kbz9`Y1Hf%&j;b=q#a8h1mr@@7oKPbt!~B)jYxycWqaoQXP+??+8W=^!61+c2#8b z(-A$wFAaT3mVQkw3qUklNFgE8(^bawn@-$@j^MFU%f?x?SymX`bs6t!eb;Kl=3^a{ zPIq#Q#r4!MF*jhC&rcJy%WB^mP%7IB@{2}9r%)cJ^i4S4I6$P(*28;iuB(gNHlWVz z7XV{GoWH`<)0;STr63vYJ}j*ytQ8Ukm3HgQ5?@wSlToZW^DBo}{An4Mm?enp zjhRqb|4=kBk8#J|C!3TN$r2SkNUrh=5Y11oVXN|~P+tvs<{-~DLRPy@2tgI3Zz=NE z%>V3N7x8#6h4i6p$2y;flfq>h2Og0g7w z(T>72=4ab32-ot2S`pFBai2pNn!*FWY9pb4eJeyScMjx zS>z@dLJa#MsHq7{W?UDdk*$^g4TOvBOK7_6+iZyH#z;AVE96Te3Uo1>EyKVf02TI@ zFCpMAN_Rm{d>;va%@YtAgch%t&|rU1z<|w%hSamP2{+0efapZWtEa! z7>PZ)8u&I_YZ)UR6iaX46-C|3zxa}&3_&!WVWg+Cgk@{ZiqTuMVsMeL>!z{qGjd1y98#9g?5}IPCN?BDKWYy3*DZ9ter!}E+tNYFZ3Egm6CQR)* zt-K|6l#lZMLG-x=R)cPqmajb?0l)`{g+Z>4U{dL^q0XOE2Xa=pu0b>`%#M@D(jC9dL?XXI2eMo#Z&jb?kSw+zHJy#Tl6v$kfn_3>W!CXJ12?0`zPdM2x51L0+LmL<|+Uwa1q8t z1XzTKF6E1d*?6h(OG1drDBd3pa!Ocwo19gl-z3oJt2J3hdxf_O{4rVRPs>3glU3r; zFc4RgRdv6zk8s9I2rR(_zET>h;RoPLfuGO5Vt_y>8r34vi7O3+>WLJ(_o7d90z{)E zA2EvF)voqO$fssBC!%e=0X|yBmRj#BHJf5Nlw-veOB!dcCe2368STU!cx{`ZgS15C zPFpm4WOMqYl4rjPk$V0FJBKq;9+`n~&0udc{j?US=d2{k+CJt(7shZ>Al#EqSnh-|BxTOm(l5upQ3|q z_eIn_c=P-fX(l<$^&J31Fbd{b2HQcH z|2|z`EnVGj!PYp6#OtoEUaFVs+L}19;k%E2)N?@F;kbO4Wue5l9B0W2e&*%+c*E>Y{If`MWeJ?A>xU;|QMRwWC^5)D-v> zmT*nhy9i6?-fH1f>TePivpuk#IaC3eLxhU&RcE32N&ZbMrMBn<-`5JN3qk{;@Y-@F z4y^m7?n+Hm2}ei-%7Jp1*)lO(Ty;$Nhi*W;2FGK9*qog~VK=!E10qtbApvZaMwxqEk+6OeIO`vU zb?#L5)^yW%g8ZAXmxSYZwR2NLh#v_NpOsPB;#Zc3;$;tZMxy6n27^Jie{pORdj&{M z@xvI1z*U{{dCuO*+y=`{Iu^Q#@Eiv^R!2jwSbo0#?awb?|N0lcXWXhUf*$i5+n^}6 zV=s{f^Z#vCiL=JBjT)+b51?K&{wq2#rLZ)mU5FhA)&#+m@zmPY)uh(?k5}E=LKiVF zUo0#~z|jE>p;zAp4nu4ML|ba0O&m$DbuT2I^OV98hWqM9lr<(_Ay+>G|J1X%^78nG zJhx*p`|UxAy#rF;ArgAgY82nc3(}tCS-H;zP)M*yn%3dyD?Ld{+D37HwmoKnNy>-C z#Ez7>zwog_LZw0D5SgPz3lTnKM2LXBye~Q;9o^X{gIKWLg|Y_+y=5>fsJAXG+0|qt z_pH0gj*}228FFdS7SdG<(zB@YJb3e!cnp@ogCjBqr|?ZnyJs~mBb#7V@X z9L*QUS2G(Cuf#x+1_>!pZfEshUZEX;pga*cDo(OZ`PZba)i9E=u6}d{Z2eAUfZ4c{%7s(9bcYgtl=K|*(B@~=dF@w zOi?^p`6_rfCSkf${~On0wXCCUL>M75ucMc;8=#)d{tf_*bJHl247$zDG)c_D;+!R? zvJLLv9JV8Fcg3&o3;mg1(lk#n62Y9F@db@nMmH3$roiG_P6PSds)-6A|ba{B5!$PEdp?;t&rAQvJ$n9pIj83 z{n<0`-+I!w_lrsvzFObZwraJxZ?D#u4Aq{74TH2g0qc3l?-wUz+bhM+1vsQ$h14*U z&v_DxZZI7nat$qxhFMRetcOeC$(2WwhE>=7H$&$Nhg!38Y=4hsU!$U|p0&eEs|NckI3!}Q(1C;@I+0N17yV--hzb*uGq`mm zz6E2-`qM8S<|HanH7vaWvt3S?tL1i=Vq?LQueDmIUCu!HbrP1u*Xk9J|AB`GD#MeE zUKgI@dDUnM5xppZUJipfUVy5t z0&PqIsf@NoH49tnufW|q8p5d^TN)!6oDgLdwb(S%E|>t!U4L)eNRs_~{3!?o8Yehg zV>^?E{|M(X%}Nxe zKUwF&@CQegLP6#@8!9QMUY$uodVohIciU}!_{%Rq>tJ^ghM%xg38df(q15wvrA&;IKaq$9+N`KRAB_r zMg7`Qij^11kJIr}R2~jB7qz4gUEfqyuQT?F#?DS*1_z)O|~H|GL`ke|$a1z?K8_j1I^x(b_~u5F))oL5S9SsP~9= z;-lWITPfQr@EhC+(ix_dibWj3Kmvnfz%wZ5B%ba{sa~44sYDnY1cc^D^w6rQE=nOC zgpWvf6Wj%1QuxoqrO%rd-~;-X4k60vW$+cTLhbOsNKKjnfVhQdUX)v(KYzX-ctR*H zv`Iq`#72joMUP)&peEB%J}=HdH^@F#pUr^dL!p#gPLbcy+ZIh{SnHodDQ%eoJOj)QGXB1776wXk7eIsCz3`DjwF{2$-o`n$t+8nGY6(C(iAI3OQI(XR^lw(nk0-DT9z>oRu0v?kf4+150=JgP1opQ{}F{?qQJ|#5IcL(r_3v^{!Ur_DhCoToh zek}m4sjZh1V9y#7_P0r8h?9I$k(**?X^Dgzwsa zA4q|*#U^+$svHTyr7kB3N0*(f<{q-jGM1TBMb(e~rD3=q1JAsbT zG>G$yb}~V1HH!f4!(#v=zx4TeQh~LXisB=(4uv1ZcHZ1?mGcYvp+>!W=ereOe^bTR z-IpuAPAc}##VyMxT+hR4fp`+VVW?b z8{5!|Wufa}p}8@Lfeo5xGK_}WvPe7xN`(s10bq8B+FyibdFn5GZUj)`V%8P6)(uG) zyHbf8uI{4zUH0@{o)_X=07zKN)%i4Wde?|dYg*o94WcgVu{rs#eQn~yl88ffgN4E1 zvsqiDCUL|)dRjdCF_z)iWjjb5^`l3}e~!F0MXL2kyO#CBI?l?UNcr?!`sie+*wd`q zQ~?U@%O2nYcG_3>{aIV#uwo^r!s3Bu_baMyaZp}L2F0DXc)$SjT-b1HLJpjg4)rw6I@=IzeiTN}{Voco-1<(!GWZ1~g$`}z_Nhh-Q4*@5v#f+(xQ?p7 z(1#SoU*%YUB%Br-$vmaH73is$2^QLJF|%~V`w|SWUK>G+oOYC)Mb#v{!zlcP401)S zpIR2eyyWo0wjww}dPn`S#G=3VT}9tZX$Vr#rR9sYt9z_ao&Og$0gTx8;DU^OxJCTUT79 zHM5^Ln>n3>eCuIGf{)@s=AbB9jh{X3j3)?l=Yp#RZ4T95pEjf^N{iUAmKox+`sY`s zAi)F_EB!(L9NiY5tFC1Y`p7|{khXZ@VY~{Cf|f?xtl8lO?`*<^I>-@m2|A-2J(3z1 z6nXchKB0xEX4yjVxLmO;>#@X)$VP%TXASPRRSw9;?I>B1mf;l5itKo{(+f9|;;4*6 zK)aQs{Irzgg|QOttAYQrY9%taFg4*^hD%SIf0EPYQL?ehnT2rp>;UI%e3F&w{Bot1 zVh>s2sUkNR8KkYIJ^gDR_%t}`jz3F)t7J@L6~ z?-LM{y=<#-IiX@_)|ZL^${Zmh3k{A51G>}x3TUAzoMl#dN)Cv%NUsRRNvCdh@Q*3y zdh%6^a#DFhHD7mTn2bR--nMl1tIH`>AMAMbJD8F}bXEvRPaba!l&iq|otwy5Ij6s-6yJA}I~? z1<7Et!Bq>(!jjJs%OlCYDS5P8ZkI>W9BdV;Q4nDB#7xO z3nAVf6XmJ_aIH)T*jJb3jBH}AFqS%fE`i-3A5EMX8F!rZH(RK-Z2`?39wu@W^QCD< zpGCc_#XRz)4-~Yw_yBN5*s#bf;Gn40<(-kN*#yi60$PsfzCz5m)?KA+?$BC`z|)v=K)9GrlrP zhMcN_qoyX7ia}~nj!bq85!p>@Y==9AZ^YAbW$VUjK%zgeV}{0mr$H{<{Xy5f+D<4tGP; zLbotgv806?W(|1k-Ty>85#ifO8#F^xf8_dY7#RM+26^gDBoUQeW5263K;f=c$3QZX z%Ei@X=tpxxQ4aaq(<7IaXk&XD^fGY@_QeVx6^H1hg?iT)7cMyIKYMS+YE_UF%I1L{ z+bxv7-?c8DU+mgl$^QS|wf$-Lhr4#5XEzV@?60!zMWe@oQCO8?E3K)H#x2ox1z<2j zdl#1MW^ZKVcsTzE6NCqJh(a!i1_{{}K6dOe&RT?1WY|CGeu6Tp&9q&dhs*G1P(-O< z^L|uEdn4wio1GKoAv3Vs=LYR*e4p#mXXwSahCatDzXFRU`?ILRq| zL9E8WsW-1ZQ75;hrz=WdmX>&BC0_SyiIy}g(W@jafUjK2icO3PkaDt4zFLCCdDclf zB|%RA{KN6jKRo~Opm_SjPd_~Wi7`3JlY*cEoIJS(g$^;W<%*%z({{00iigV~DPx3w z8spB~h;*eGpBERpZ2k-w_w_p{#pQAWaxL(?i_lTGG#J;+APl4)p<5KERkZ6v>OEFi^{LE z!x{$UN4o4?$D%%-yC1y$l|pswW$yjj$-uRz@mjw_!Y>jO1EV78HrMEThgk{AB>5a^ zArestI|^HaLp;_h_53O<43CAyk=fDKc!ISE$yi!G)H5z#<9KJiB0UDzEpVzZlgEWw z9@v+utyV)Gcue{bhy%@dm5?CFuPS?mjIn6u6_Qfc;=l~`+W#or`hG0@+0*CX^4s`MDWC5tX(~uhG3Aoqfk1PD zb)y^SJCym+!V4V%LBO2NfuuvEDRj&C>rnR`BC-qxX4i%v3SXn3hkBL5)mD~mV!}ir z-VUEFSv8mpcqCM_ig_}`P~x-Lk+CvulpiJ;xIgeu+NTw9K*W8dK9RMikU;oR`r~HP!;1sdfL$#x-J!b&I zj8Wo>%~f%Uu!C#^*Cd)VNbzbmiwQm?=)s5%SM-_n|BWn1P20T`KePfsHJ`m1ht;Hngn$Ri zx|}BY`2)g%>o>C_=abA0Tslf$?7~s;pCo{fN8?F3{p7?FLys2neah&ps8X=VrdIHH z{Dyms8wNZQGdCTAcfZ{ZPpSLSuAD@H?2GEW9z}T4Maz?LTmcVpbg{G~)C(BfEP9A) zsHHg-i>|#%Nc@cAT4Fld1#^C_1Xs$lyt&RNLYFV{r-yz8VkHcO&elp0*hrm5jP?R3 zp;>o#WBF)_k)L){4OaRa+EE)_sQO}w25Dw3K=Yf>zl&=Ro3$?_Put|4zUZr}rKOWg zU6biM^6f97urf^`!7gcKJyNqo%aP07v`g6owB4uS?eqJQGMFRPM%uPWz7G+RAz=8} ziqzFr?0`|EJc0H|fBuL$b^u%QZ7tNf5SsI_fQH$9yb^EpUnuNpB?qV) z$(ID%Ea&p1oDqc_L~(yrT(q1m;ceJEK7PL+24h_>n3kcu5a?>v7z`*y?aAMvO-SeI z`6^{IZo>cu8T(HDSxU{O6wt?6IbBMgr-S0;sJ!Z)KOZ}AZ96m|#rIj?(TDjp^GA}l z;e~2IMmxq4U?!hR(8loZRwRB62RrpUf)n2>Oo$B=R68wRD_~ey+bTzj7$;$ww#_H1 zuFW0Oq5Vk4D)PA`Smd^GUtChF=AhU!&r2Ay3`min7N(c&Cp+%Zh=&{L;J$w= zRx8>1Dx*74dzwz3v2QlNilmdhBdmZkhm~6v5lad!#iDHS*}qlQ6@8)jMoFw_$SX2^ z5H$k1fTe4dSi-ysVV@yVXYV^vrtidl*ZPqk!Ee)WTY@VU+;>yS5iy2ttQ?*qRXp^* z;)D25MexqA!z*QrAqMQ1pstqTRak4R7F$`u9#_wi%f%vzR&C#Su)6jW+qt=KckIAB~xasRz*GXMbeP}JfC2QzBwXqAVZXyCK(sPit zW9W46?`RYIlDP=HQfhibZ+5Vz#?wck|Dvtj+T~R-MygBCCv!e(cr;L+XB|fNg|T9$LfN9;UXB&_wll5^?$D}LU)8Ccs(ocVr&9|a7b19-*R+> z{;f*~4(wFVlC`Y(Yv|+6x?PrQwSxq`rj4wjn_*h71m)DfA@qfJ&&;;?AoQ z3>xx@dVY1Ev<7F*^1nZNWTu?nmUw?YbvmEd{j-UkSu2gShqPcVEhAy78|oY$Nz(-7K>|yXy06ySxgES21MKMGU7b29_vD-3Ux7#`8TD znO&bk7@g^c=~!w0gnDGG4YAQMrHAuWqrn8Vdbb|SO3E>QV(4a`y)XSE%t1DvQ=j_1 z3bMVqI1FoI-OO7}cf=|3p%N~#Ac*9|Y@BAz$Zm7*&M%AFNKH551DI!cUTiSf;~h7i)_a4@?QJjf8DV_#c}*X-_iu)sc3TO_;G=|&rpVI3 zRA>aBo4R}>|IbVlj2)Oyr{bQ@G+5a8o%Fi~dQ0X$s&PKL$@5?K@7?m@-hN|A+Hd9& zV_3HI;EL7{UdLOkMx)7O+*h-zUM-mC#6H|3FPFhxeF@Q55)<+I?#@=tHjN`BjF>u8 zcVf707C8dls^VKd5`)2YWZG7EQV9^EhPVr+WHNcL`k{_X9jHr#VV0y42!dvcQG*X8 z7j$d3lxGl8V~EMrWK!RLS}+q(>9GM$DSP9Vd`k-g11sg=WTg-+trU9RR%+JhVo!xC zIIi(8zX|`L$X60)v-Y$?$PuK0D6ZIwc3y8F;Yv=P8ZD-C@kI@-tF_UCn0DHjgwO^U zU{p(TSonKZecG3WMx`F4AXH=GNi~V!vm6bh)GPIA1{BooBi-ll7*F?wek>5Uo+@ zmFIHn#FISNg89%o32T6noXtJh=0Qfyw+&BT|q0?ys_=Vb}{ARM@K1tcm zV)5TI`ITxELh-h~co!Fo6c(0S38V> z0O(q~4fMEr>uwU%vRf1!we45u7pLE^^s?Z1LQJOl9O#0)j*5s^#>u@WPB2FcIY3EbzZlVBkd9?IlfXqznN{8DJr>47?MP9q z4$=UXM@K#G|pv*{Ck9$pfFG)`qy(V^bs87XBuf9g3LD)O4feb2|ehKU% ze&y5ClX*SR9*0}_YDVvX(*D<_lVt)}l`hhtuC0BOn*q9aophssANeklq;>Gzhe^GQ zuZ4;OUaK8#^n_|2WIBTM@WrOIUR41%w}7Od|+yI#>6_p#F0b0>y2g z@!^#q=)QKiA0&d5nh9J=bsKAhcW@kJP*C47g*_HwnP;xZ`il7l%q%FM)COPW+TS?V zdx>SHr8qHm`7OnUn8KwnM=Vl;(9k6Pj8!|hjW$P(u9Q>R!sen(gN#q`yVjAh$p>86 zp~!9`xwf$6+_`NVmi$muSrR2a^COGSc7-F5)X#+=XZm!AVlbZ>n+PUrJA1?!ZWG&( z?=)82$dXoo)8>y4XJX-DT2alV#L{IR&T zCVv0`0RR7tT}_YLFc7`>SL6mO0c!VJaqP91McYHS0t!hLEf9$;r4q`2uiw1+a3Dh5 zHd)6wwlg!HnfHeF%8Mmym}=8p9{!*>CVKsjsqPF-3es{6hd6QOH@I)dBWPcZ-!N#$ zpufZ$AQZf)(T#j}{~(?m${|X_f*i6TQo`G(D*F&I=za5-Uq>={>s@%4@i1Pf{g)p$QT=Gg*u-y2Ye{6hdeMowu-__b}0pjD!XCnw$Z=d_IEi;dF!QadDe++WYGekbZ z`CEiFRoyGUBqfTn@QF^>_iHkrPhj1h&`~S`cwrIMhqw|4zm$Wft3Q@=`g?s`b{$|r zlGkL!k_|Iu1WrM5SsyLOCiq#}(7Mw%ne~l08r{<@ zmz6y`R%!v?=C#CPpA^tX(qmJF=UT%zp5eJwPV_z-PsT%(I~PO4^!Q{+ zixWj2@5BhwlDhzuD8{5pa;g}wcU)R0iaVDI#INdqI^hB=J5^P^sRb6+9N&rd+a~Rb z-8N18zua*?#I>w?gYP@ZGpta-CT#%NnQHJ|eM3WDGf3=VS(M?zFF(IGIy11XR;y&| zjDDF!H)rRoEznBb6ovue#+g_eUs}4^HM!mJ0CMEE9)%#XJyDLgz==<(xJv&SrMs0h z^Hc#Nuvgp?EEHNBi$*Z8g7yRD0J4OPKV%iZFd1bVyO9&(R+oTX%XDY1yB45X^&N?t z4nFo|fAN+Xv2(V;hUvn&Cig&x@|cQ=&O+_pTjb}#MK0t#!k`CMY2q(P4L<8G;p?@ym@ay4*~+fvXVGn!fd{*LID&hB8Pqh>3!za;{F2w0RR8Q zU0rY6#u9z^uOMm|sR2j0aezL!Frc8xZ3`6jMQWfeAfTZo%4RExDoG{Q74+Y`XU@#* zQd$*lU-}TlT5^~BIbS<-=7a3N7pYJ12b=mAL%5DI?2Ve9rER76gfLwL%dG%ezbP^_ z%BL}!;eq|j5C(Zd(zQC6XTitS$-o>QZZCP@6HQ4Zx5b!LHQi|5pO8{vz~{=V`U>We-e5T|RL9OH+L_ zWSU?}_51}K##P{EbGuaDUWael11^xn<;X}VB^pdqsmxi7bTbNvl5Jw>5fD+GnuhNS z?zEt^UnHgBESd&n`7VNXsi4(;yFK8z@oO>tfPX}GLWG2hM%Jjdip%>da6XvH%u8&c z2H$cz-7Ilkt~pEiQHAZmYhg9Qp4ZD*Y&~`dkC{_z9;e55Brubf+=(TEITN`OoAoTZ zyLZs{LK`2KF&4>IAzD?!H2u~c6Jy^_N|MiC>5Lq>>rH}?wSq=@`n_WEYx96VM(3~z z->ub|Ud~>GR>=pmNPE?D62fv(4D7UHeZzc-736i+cs>FZD|sGu*^A=#wuqZj_M{u2 z^t}W!)85-BCl2j_tSXK_@gMygdbF@dN`cCzBOD|RR2n58^G1dr^x}Q8cwYE#E#N;{ zu%o4kBlgtwVwKsh;sOQ51JyuOx_DfRdBrp)mKEedxTT|uCxYg1y#q_zHk(u}t9!i@ zFzXGECnJ4ASGAn>dIj@kc ze5TT1Mp@CL9<5Et9qFr*J~R@;M}+7F~8Mz#pEEq?G z#G>lk&FoM?P7qFqJthVx(eAJeo+=7a76_meVStfg)N1Jv9cmj2LE44U!7eOP2@-93 zr>@hz9A!z8+St3NYO#i2nMCz(0$rbiA46aO$-DE#fJ?NW`|t)o%Vu+Sjz;*82E5*T)k* z%naz3>0WdFs-AEDjH+B8QWd8sff6$1bxNFV&lAsN*4B{7<$?q{l8XxzY9v0-%p^QB zmg~x+`yqx%G|sRtPKU@ul$SpXPe0=~jf49E6YvH42M}nu(B`6S{pQFq+}w>M;ktjJyZ-t?my_}n-PVi( zulDTyJtVj(Gv6MWcg%rumE54axTw(rc3HuYS~Mh9GH)We#Nc7#b%E@b&b_g&7@KIf z5sRQwiVL)O>Pk9|#PY*E+gL1twGlCp69bzXdb(*Dl(Znn2GaFmGD*S_5GvU%U^J{( zCUQGDmFC8~@%}<1PX&K!OegH{-7aV@&=EqR0KCX&L|%52;6Y=7tHMg@U!~7Qkzi7P zuV{@7gB5@E2@(@hDXivm1jLArv?CLk7=~ucI~O{&!Z|I8Y+XDA5x$x(XNpDZKRu}w z)*k&Oq$DE`A@)>SGH@MpO-HSH_k4a$49wSdO{W^PfnIh zhJ}q0A{3{5zG|M08g`g&Pz|MSJ=4MT&uk>(p!Ep|WNy??vsBUKNcxBusFiEGB|XL{43 zuUTEJH4u4|5W`CCYlG--n&2EB>PZ~fJ=hbdY-Ek|MftI5kLJO$!Fe_}j$||zeeN|b z#NjX*y1n0xB`ItX{tzaH!m%$SxQMsi+}Jty=eWO8Q>>ySH>t^(A>BeVh;yh^TOAWj zHrYJW*4#`t12V`Gyb4qHK51=I2%QVmGP`C8=0QMPQl#<-W%#zE;Y~(X+q}IfqgU$UOck@jh&C3G+8N~O+$Ali))rOFUij$ zyuxfxS(j}c9R+{{hNP*4j<+~u!!!t`)eRNO>qnx~XlP!IhD}DP- zuJpTH;a#>c+vlmZBZvT^NzR(=7I?@GS5^R@q|dmo!k?d z?EHiERzj|G58LXo?vSNx)@_#$O?L3Jrq52G_!^#g1Sgj4gFgTO0RR7#UHx<0$dUay z`YRASEK7GJW7_LnZe!WjWqoT`?Zv5GZ*A3<>due|N{C2;MS#-Ei1N2*`n~R%1_(NP zsft$w!NFiYdiwJ{C2iXOVz(V!;#a#MJ&Ukbq)PdVHynINxdSeQFExQ14mJ_b;Gr+U z{XMwhuBvr$GxW_yye0MUH|2V;3osytw{H~|(8W?JD!=sop|`j1557EZ_~Ng>{8J3= zq25tVAKY2RFU`ET+7`*0b_Ee)1OnLvweAS6I{sA_r@^LBa}>q&FafZy@Dt&8vE9pr zDk(3i7K=_w+bDa-Tq!z#@)|Xyn(`uMCX;+iXZUGqkt7q7w`3iTJe>ZMWc;2ue6$0Z zAB_DD9kgE?c)BDKbZ*cXGrVHFcUW)LFI%gG>1bhSgbKi(9MS{*w|$|f`og0F*Pk3v z4F2uF{o@1oPY+!G{ekOWA87yd!2Pce-2cA^u75gk{U3ve!fxo|prm|vKoqn2|DU)K zJ@4@EnzA_jYiEHqH`ej=zhDH3arj;X>wSPSbA|k5|EY!h8c;ErM?Vvhyn-8uTsp1&A zem8UxuS)6cC2cg#;n1bWJrZQn+)@YQwn>Jc;NsrXU5ejHMOm}mT{h;J6v1rB9f*w8 zWPE~WdW{U3a10)e_HL#eN3aY>U!836$cB0L!=K;3XOGy!qfv4SkOhfM2$sfs9Lf45 zGf211NjE~#JzUNpA^PTkcq5Q>oY!RvBJ2rLn5scGi+wA1K15YOYK8-^oKTYgt<3Y^trMYQrx1Ns$u{q7mg+{^v<_!VZeII>VlQcbE&7EBBC5yR_% zm_NWqG+LM>$%sMJI_BfD066->BF_vH+{MPI8Qgn0&R&hPzegm$QTAQ9j9R6Lt;BJS zS#bN}dxQ~ano~@WcU)v`_Au%Mo9J?uLbl3s&>4w&ZMXejyO-Vm@T;5$=Vxc_*;#tt z+1vK)ZTk4lyY`!(e@>sjYrjh$KD=!|xO+deAJT`9@7kaJ5A(dubN8`m^TPRDuG{(N z&*^ir_1oX3tIKwoK2$|pxfaBJZ}ZOQRa?2w{)0E(+t=xOUAJ|eJ~r3wXYExQ05MQo z{OeveT(S$l%0vy?Ei&>V<45~IkC#?f=xTHV#sbLT*sN~IjwjEiaoZ}ZZ0r)2T08a^ z)S_+UUvB(^N!m`QQ#S*&Q+pT1LTyh^-4!uSTm0)T2D7x4fBb~1Ef{|NDqZdvs_n~{ z1K+UEuX;a*&#akOqrWV0nJaU7YP z;Xd~X3pL76v@Vwp*zALpTnNguCdk!FMUroUZw-fej7@3W=0a&F<*b-jEbTVnT(Rr%RKtglf^H^?BJ=EF^I9C)2HD^!GaA-W-cWqJAmAA z+i3C)e)hxLkAz6XMXlzOu+6S<)1c|93cYwNh~Y$9Dds1y!3iN{Mcwf7eh5eOb>uzH1VNbS!%$alE(vr90{8kXU z!_Jf=?T?#=2s_U=O7td-H)(7i9uhwSyZOC>^NfwCAOfx{{8iQqJ_|`|jp!qe9_}P% zDZW@hW4FTtPEYK;{HloBlu5SB-Ijy|U4i#t#;Z#c!&zYo%;C_A$dD{-vG~5`k_nQ2 z{U=M{R93H&&?d3bbcFns={9?l#RV_9mfo-c)Q?2D7mKl_s$3~jIrYeBNnZdBv+bCk zM{xzC&fU$-hzbJW$h}`bW5%q{YHIQ0E=spxDuTX8F>+9j**$;pLWnv?&G$xJ(lN9g zMldKwfZ_$>Tb4wLAXaw`EI>ut7Ls2FmB;BU;s92u#BDQu{hDPo$BUr3=vH8)+ypSF zP{&C}VA3|)5;``f0IG7KO)`s2Edi=y%pi|LtO5W%jbbAr_h{;aqLukUen`p4=g7x- zX#4w!n+eI!`wtypmT)^Lk5RoKUbnIXmS8Rh{T3(#oIRS~(5zOr&Ro zb-T?Yr3cX&dKo6GU@QQ>SJ$9&6PhhWD(GFwEG$)(7WxM5pxQ~rcv4$B-NNzpr)Bnd^UGzXfTAKOAY0J7feuwieAKuqc!n;uM8kr&~&K3`^I9iZt@_MvFsiT6{nfJq1+EOzI{3k$L)iaiRt=AdGDvqlPBo^ zr%z4z%hmT`7!?>o6T!w<6|-4(Oji-SQ5B-)FJN=QltDLu6e#8yXWxE^%8pZ|P_HI{i7Q4G9?ztoR98lBDIoSIpR{>H ziNj%p>c=&gN-1!v`MN+JIt01vEz<9_$tdIPf)0obf?c9`?!K6{Vec6eq8Htjt34Vk zke>oKs7xj?jnaUPZ1D+-8TFtf#^+@n&I3eEdrfH`^`!HHR}#9VT!`{n_3_I>qs6)A z(XA)0@r=Br*r5O)r`ZoAzHCzoL2;?@O%Mfe&iMP+mBgAU7MVpCb<)lVcNbt6N&%v& z^Fke6Qx=CBz5lw|y*ZKL=8PDm#lUoAI;~?>YLK?5w~Hzm?s;`Odm8>{Xn}crZHZm1 zt^C5E^l~Ml8!`KLqL@uA#9bBkyzCeu^3XaOPucn+*`zSvpyk722|_Jj)+c{T^k57Y z*x8aFm|F(zk-Zot64uMH73SoT^yegnN^&>h;T8ALGM zzy2lxwHllZyFhrjyvG+Eb?w-aDH-}>1G;$R8-C)?E98^>O~iUa{vs!qmA^R`Os!>?B> zz{MwJ*4p2D(XRd2H*Yl8vrKi{T9OvdPk|n!J|?Abs>rvZ8B<|?Xhp5Cf-*3V|C$>+ zm1iHXT?x!)TZMUDDFO%kRI^u%7HXgn7mgx9m#Vhm&KscbC_(@fNHHTz5qnvC`Jg`v|2Eopc@a^-tt|#2*?@68Mr;KsjIfuj(O57+S9xmAHL{QI zd8pN1ljKN7qj6vdyJ^JSxMk`pDvf1kBEi7AE(w@KoQi1b9mT4Ov5A53$Bq4Q*(m|k z@{9I-vDP|wT)wf(H~0SXrCq+<_{+C;`F86sH+H${+`X~On=7m5ca4YF&N^^p5nwUh z@Nm?2KxqjVmVW=}@$6Cd_*nJSl*>~K0t{e_WU z#yGm5!0y%r$SCF~dq8xlQ$1wnFf5ez=hC*eD6oH@K*DE+!ufX9;kyfZni1R~ z!n@c86Y<*7+o9THgX+TeVbnur%g%3#?fQI@D6b(~`8Rca;g;XZlIMXninJ8vqUYrc z=Ve(pwZ*c7G>1=c~+>yqIj) zHA0>m>3K(n03@0SxCQ;xM0i~#xK8|)ar>Mr20KTfR{?F;AuBt3CX$VzfUmdV*j8_sxwwe_i%J05utyFo^T_Is z4Cl%05_Mp8jvOpfW1EVS&A=c{a9|gr%oSp~hlQX62a)!8*0xrrxDs5;b+uI=GMcUv zrqOVb0kU_5Ec{e7ouaz{yJ36_Ky#6>!ap{w=(vP87STmYfwinAF(} zX~R`%A#{G?24&qQeW}$#>j>!zQ& zBrJ0ex&u&;q99f;@}<0pBlgtsolXDnADw~aXis14O^zg!$Y;SnzPu1-hKE?{DeDM1 z7NTE8inxT=Z4)!NAg0fs5A|Ty?SZ1MX|080fdWK*TeDSXD8VrJp7v3Dkxy}1dNzgGfHAD?va}8FmM3~DqPl5Cdz|a59QQR zMNV6*J3X@f8GA@Ah|A%z;R$y_iH6eMRaD<7`02OzVT0djYE>8@q!KVZK)P?KklYr< zXIs{k+Iz_@OjMDhl50qng_@Nlf*Nkkh|gLqcqaYRp{6NNfG*i+@FFk@26h~U=)c7Qd4$MUW<2( z@k8P)08YbHMB;EH%onGa<=ZaX2TEh*L|XzFJ-P~!i33YIOkh)VvKc}n@&olWKLuf4 zYVt2tC$vO>04kF`pOg`P?YE)b3U9CgF-I&?Mz;#mgle9}_5J3WmAH%IF5C?n5OGk$ z5y2bgVNYzuU@*nQo^>u~tQtR|lZc9J3qj*uH<5JO=Zzqwlmvk`L%WKl%0$N!ST7|W z>H14As*9jSUtNK68aq=LT5PI;C%XxU+af4MP(ov16Ak_tw83q&liYFSIg>QcDfhPh z>7TljjQqiup&A1?r7ajPp#Rj4H>HlS1+vF;va)rafdSby5r!M6p(;M7`(sT(UxLDt z#C$U&2`FnvJ)myolgJq=Bc%-)KX6=9<^se~2!6*Z>FSyZo!c&OGk%&qGasX&mk*4R zv}zGDj?-BAHvGm(rl>h~kw*Z|2fu$3+3so7SZ1N6F4arW#NqLpue&1zQ z(v|7Ak|1*j9AxTR0G>bx?-_7lN$Mu};(?oPAxz!av zwiLpS-jq0dCG$|&aqpB)+cuM<9WQHl68W8!F>C$&I{XM?JIKf&-LjfDs=>GFeexZJ3oz^}<#WpTFf%(|MDumMTP|aCq0^{Tp57Mm$<7+uTStBbiF}FH^t`haXOA(;!!wf9?zzua3Q79o%NWyHMH5mD7XJoHHkJk zV=+?9!pfDY;y3HqjxBcp7E6#GkqBXy6|1QSTjLK}@PWuY$WyS^e}^JDV;(<60^myg zp|k0W)o$wk{@ug*H4UJkuEO9DdA&6MxkW5ckR(RW;~Cb9SRpZ+AjTl{p@%u1#4UC2lJ!Kbqsr&$`viDPTF}eT;yW411-i?VJ-^) zi{Xs(#QNUb2clnqSv;L`Kd$9M%Fow9lDp#(v%@{-e?9y5tz8nCJP9Ia19{BwRnPgP z`KC%>@;9-CF?gKN?qm=GtLaQbbd&v9`$cCvtJi>N;q~rh^Ghe=3diR2Z0jJrlDF*H9)yE6t5r`QM*VS}xv*_K+#omurm&VWwzFAIoTsvwxqw3^w0Mik=Gd zUBrvM&bRZ49A|S4Y(TjI+RgMErr%d5X*C6M!lsm}HFdWrF@Z=T1 z9KSM`guKUb%*b2bpXdNcC3_Gvh_xq>wf^A>g9fK;kFc_TpO98gpMEua@s+=SUfzb? zHGDg?miUnUV?EV^%QuX&-{N*%w_?0Rjx;zd2F8>1B21h7CjbBd|NpFAZEqVl68?Pp z6@&|+F;4c`G71#BQ(-$znzV_VCQjQF23pyYZ6UT-)yi)X^xuy&&&+VRyV~SKfdH|V zT<+|0NY3js9RC(IjAHz#?_SE7NWQ%jYWnyq#W8($=Nj=c@|}2EM7kE?h%ACG`zqVZ zAe@#nT1eQGhiP}_%h#g^&a@ex=wFaq#0@jL8%?j+8V-Y@E=4>?mmcBtWanxZIeFA) zyotRNnLU9MY*`{Q8HmjpY(`Vj(103Q-2oquB}yS#OBxoA8^ z;t956r?nbawl3Lr&M!w6!H0fwAfVngpP@U$NCqqt^LN06rE*Xd@7rEGY)FX&w-Ws<0f zd_J`JGclTTBv2GMqa9o(;z0c)w=c(&`*Hk^=o0_#4{fDGuZ>@h#^NlnC7C;Rpy?AK zC~!%-1uqmeMdZx6-AQ@sUXD*Nxydx7UQ1G@=aVvR-$*~WonDP$9VMLfvuQk6c#uC~ zJouCIa+AzZlPncrG*xeK`9q0{a=N(X^Lvn?`LgMsoWw53U%`LbT_*N%4!x7iUooID zuD2RExOUbV$~^P8T@(w%3tl0CY$W^tMM3&ONj9<+a~+B^GF*9kNk$kloa4*Bh`e=2 zM~`+9IA?is?&7lmA{Bmw{u6PQYQz`5lohzZyyWE%#Z(^k1!qKA_-V%WB2!(PUET~h ztbdZGS&Gj?U`>ZTgf(72#3*rvi)&uXhafG2Sz_#XqLXP;a8FhoyOc{)@|P+LtHr#v zD7NfV)=vi8$OL;^&25#TMJH2SZ1z74Al1+wpak$>lr>!>J-`xtC^i$hcqWJ8!*5YJ zXk~_}mRb~u8uFr^-U2~5gae9AB8y|0GWRNnAS}KmqQ@k8o+?_SD!jS?b+ZW?0$+U< z<*Eh}y;I1Jo;Y5fZRH0eb2aDJM`f88Tohu@bwL^_w0IQLnTek;)H*9Xe9l2ygmx_0 zz2d0Q64ka=SSGtGK8l5$e2`T|3H1!Vj@(8HlNJ^1*0_qF`d@zrVV)%j>s(4TyZ7z* zKz1h1O|O=trk$FWF^wrFJy``n0$n8WXtT$@XaQBA6Q9#Wp>ytkY};bwyKEVs@@$$y2-?TP%(<8&uTM``_+t^}pRkFrn-ZJ9>!Kj5FaK zosMY(w7?R-DlGsugjW<67pk>+;$Ave&6EY^CC&II}n;hn$ErLoGGVMzPlFL)Mp7)uQ4} z^+EDN5w_hNw%1MTl(sDn=@9R4V(GCdN@TO_rNkf79QgrBBX`WjYB^Fw?>W5}PB*T` zoEb%NH|)j>1~MuOonfO)D3beypeGic)X`vGygIN$rPoEVP$hRPOI$}ajRMl7K-P=s zhwRw8*5iWP1rfkAl4xGg6U@MtMEsT1|2e@=<{f5+iRP2`IBR#dz1!cZXg`;Won|dZ zb-Tvaty&mZU3sDzKov8xykUQ1*>5~Ky}hs+pg0BkHET9@{vrDvB9T2A3>WYiK~nN6 zDZNr6yc=E>#Z2U_`w2(?kK#IJ3Bo0Txw5`@r=#%=iLS%Iq50z3j>D*3GBbVd(E|zF zYNxSz7wkX;?s3$xDQ@O>yT{xw{1e#e4D2BPqWZ0a`&2z;G{FQSDToverNG}& z$X`mth$kKD)f5kpk?%>$DHIJVZW)J&q2{Dsr1#jJ9TSYoYT0!}Bw>%Zj<<}iPp22R zs0O8#V#bu{9`{is$w2j;&clYvGuZkekLN>5bP!!bT3osiUpICPiXTD0hW-XNnrj#PRqJBC{IA$cE5UJ3sLbb)#K#1=$StKoGEvYp z;utCUO>mMAdf~9g*a+#V6t#Ubo<8tH-46;*-{3jO6E}oIE4EPYZ_b%66e_h zBj;hN^^(7qq#;xGXnL>VUkBm9>cclQABMxW=BMFlTl4qf`?lt1;aOYr^YFZ_`G@dB zTl0(XqOJL5c-hwcWB9SH`KRzxTl1^%s;&8Tc-_`~6pq@Oe-1ylHNOdO+M0g}zqB>K z4R70;--UN=&Bx)mt@(X;-`4zV__eM1xA0qA^Y7vJw&oAvLtFD7;g4iJJ7IHK>Em_d zZZo6s*^~(4s`ylvnpTW6#QV6YuO>N;kCvGtm=NA?-1an0=BorjFC~hAa-f;aS5yuU z?q_Z#^+yMqlpH80aai5tpkjZLP)e0<_BVA`A)@Xrl*nQ{nl?lPe0<5jFYn3Dj%VcZ z+}B(W{flW~`;+NDTJ(^aaq=`PFo4VNnS>s8$E54lrn0}yf7 zf?c8>dWMjW*_=w3TCyv5%nx^x_4WVZ4wZ_VkK$XZ}IzNqF6$XX8U}jQfHtSFY?*1*UfUpk{>`u{aDMYyeyQmt7dlvD9GE{Fu#lZ){5+P z_`CoZBNLjvj1j5~=Lz!ECz?H>*;s9aDxCxlJj`!fOX>YYO@<^wu*gKAO61-p^x4sa zP5UtHNe+n$c4l@{Y`YsL6`Kc}atG5@03wCsA_^UsQ;GE_!wKN>08SBwWD0lRz>VAV zoNdL?6IGrC=s}|N_U2m2^i(66gCmm_Ny*y-bV4Bc>&6op!j<5|QmQq{JzTW-XoH$J z4mNs~mz|-K1_{iJuQZnF^CK*eP=fBVC^$M^*9+iTG;~<6(j9cM?=Q-03CJeLCX<*a z&3NR+fcc+}UL#^9-Px^swS-Qbz5WXi6hYA@NurwLlY(7@ zP_d3~V?Rq>ZD31xizmxLraWaVEq1gkE7~5i_US$~w#IKp|EeB@oxk4!|IFC^h{AIx z^SLV4`$|<*fD)c1!LS&)vJO@*Znqk`>tEB>kBpX9)SzXuYhOE?z4uM8+AtqYym3_A zy9iFxl{xOFsjpM+)YoiG zd9=0(N49pU6V}k9v6C`O&ZmvU3a>RiX3f)EzHUR0R{DI7xME&#x{F0GOV$Z*_zb}v zX+4hz(ExjNd=kyeQa9^xv@(r4Z#a;KIQNxX-t*x5N$Anf+w%}39He?Sp9sSE%<4(7 zB}AMSL?op>kkB9`mN;o7@z&BA2-t@tRUlS7fge%^L{qw7W5XY^w z32aqypeFzgJD*-qki%v#{JnigHn&F$Iea4CeTS^F*)t#?0S;l|r$S1q+uQAs|6(%F zz*bbU*6G+`s2K)=BZGdFGPHr6E+$|`wn(QteoF?B83XZM6>3hzHY{7CUHQ9w>hhyo{2eKjs`GjW-&(xQ7-xjcd z7(wj5{LX|vLpRKzC^Gx+}Tkz4yM)d zkMgdwW(fbTVbk1l@};bLU_#A5#;ZEyXPGspIQc;;EUDdA%e8kj^OQTxTX`x!(Lcvi zwbOkKPo=YIX{TD9t^N-H0RR8IT}yAvT( zn4tw84jK6FQS*1gT!-kVF!~6aOd$^@!Zh!U9fF?M917??f9kql|1J}^!PAo84V3U( z%9rk#Gy?1OY<)}=n**$&5zIRYgt7sEqS{sktvsyfBkyGWX=08uTe!1XTEGV6NZYQzBpi4t{e0(>g{&7e$sk5M(p@b0fGcyix{_I=DFfI zWw(_e8*ouGlFDhx?Ci|5lw3bFi}%;UBSqcu8A$7Tzd&Sle1ZVkW~zTvyaiV2;LqUP zmX!S2=67e!Cxi>Wao8mJ4a_J~!+)HyYRCoDJln)FQ&?8|YYJ^pi^amDkjD?Ih&z-s zH?Qz-yaQs*hb%UU`itQy!TP`fAfqxTo;YR` zTOO}GDzdX@Z)i9z&`GYK2-r?_VUm$VFMOhrjPP(m7DF8u$i`6LvCRQW!GH2C%PPVh zXAPN@G$ibJ@9+sbUR%#0`VDBwf%1sgORp6olDtxcGD(~`<#1qaND5^@K~iENb$Nlt zgi13_MUHy0#JP(W6k6`r=51e*1cKd~qB_a}F0t!j$yd zG>x?>9nVjx(h0`NQIsbmnTR1(%PLF$ni$_&|7+QefFq*YEV+16M~#8u9FdqDIAjYI zsw`q#1kU)lxAQ+ka&1Eyz6QxiM44#j;|*LkC^ONwa?tJ2Set*Z`MUnuZTK6FF6QD$ zKm-v$46?E7uK4ox`)2_CGqoq7W}zPu*SLqenj=``XLtWNQ%=Hh#r`MXX;bt5c+K#? zdb4V=^bjY7JvpZV>tg8-Qf839O`$H3veT`Wp80T6UHl+UJxOqD70XXmJ;a%(R<-15 z)%HQgz3LXfyT6b-dZVuDqJ`oHhHi0MX<_S;e>Y&aBPvm#N$ilt!BhD`I7R3?_2(Lb z``$jZoImm(00960#9d2k+dvS$`&S5pNDWRxLwgA|)J;p0OB?7ZkV76aLR7U%WReu& z|K6SV>{^OV8gNd|YIil-UCpd!XTDF^UzUJTw#37gb3Dzsez+~mdBG{U^alH>#kaPL z{O%6I9p71m6oLzs)UpyFAJi?r1*ix` zii3po|HBxEUk7z?FW!W=0W#;7P55uMNs?9Ez1_Eaaf|c6H`(Gouf0{O|W5AZ03Z%9ZQ7W48J!OsN60OcVTU08>db|HY)pTd%j zA+BYi?i~}1VyHl&hq)?#;u{dvO{t_4g9~jIN0=4*R4wlbe;zP_LHk~ct3<3Sq9c(O zp;OY-9w5^-(NB#X##o|*oI=5;?FI=avhLsmFitpS0y00)*gV3^3ri=MJV^e6u=X$F zuq_%0taL6Z78yHfih|M(8D_thEI&ws8yO*}K9>ZzBgUbwIR)*)L}E+cKu0eG$iw^} z9H?)$s9HpnfCZ&pH;YsX7th6lcIw~6$EP@va1GN{z`$4>MuOr?OdI$n!fKy(gaC(y z5Gm>lEkL0t)*6Je!TJnW09cHjL)CZUdIUY?>SbS7ig&g5J`-Bt?DTwgc{w`^tJ-nl zQA55I)-G_^`GXGjK;PDY@`H}ash7sr{R74AocxzlTat05(9AlUT34wki?@}er_zul zS_{NE|2F%2@%`*4xa8zFB^<6&iHl-uk$EX@61ulqkJxFwA;Bs05Czv^9$B_kM${W6 z1&SCVD)HYMTe<90F+AzrmHE}>>jc#Om2L06jT$47Y=9bi-<3~dubJKBe|MLr*-s;Q_jKF6(2=pUKr^e0p+4*bTAfTElCMu zig=Ka2_9IJj+N2@AXRuE!adt5S|?ZF>+!H#Jy)Q|=t+4;rE6j0>%|aLo{xqA&)4dA zD?9iRdSQygJYFfSp%kW*HnJ|0=XLV>uy{bMEc>G9hb8thYrs&_FK<>k@x#lzzKV7w z^RSG`5_XLCQ-|^U+$XWx74nY>wR8Fio{@WVi|}lH0Syc;}cat@DPzp~pUXZBtl+xuF@loyU%+F$t9#m_jid zyPd&P&9mA41iH*7G8aD#U<(vKCKCt6m>4Lr)2c#prFg|O9OLdKSVCP} zO8ENdd;&+J*trvlmV()(P#lZEcfmt9H}rFVUvX(S>V!xyOA*xC_YU z^9HuF;r{>t0RR7lom+0gFc3wzVhJG?2|lW>qdVwNXc0+EAyS&6?4FrBo<|%5p9uU+ z9LK|*d#WwC)COvWQY^x>zAUJjYMtSx9`vNPQ&+mN+>_{CnGS2XEcIESnroR8WzEm3 zq0z?443Dt@%`nxiO@+hiJ&E$259dfP^_OBrgH)E$l|w-ym5w=H{5#3g^aND3eikn` zVAQQb(QV6v^^%N9nKC|@N(+ucM+`ct=LqN+SqW$P_6`|D9mW7b--5#IrTJ;L@aPE^ zJygpV?SPxSqG6wC)<<$vg+oKuF(WaoZPe-qMyQ&*pOm7=)pj}JuAvlaP2DJv78jgs z&>Ft^V*wzXG<+fl6-Oaa1LI&zFJ+uYTwiA3$ohV;Oq~d70(Uh`8@AFK#7$&ALA z+OwYq-9tkk?n}Uh^TwDanED#2q0EFLofNzi)0Bmt3ct3Rx8$erHp6j$gbX|ui;=~V zr0^UyzmT#L;+#t^I5WQ3l&)oySC}aDWW?3g15fg5P)qdrLy!L;EDdbB#BGg z9)hpKXkvbQ92Z{ZV9AVWqU(4rT%WartI5S_MC)C>EoL$ZFjwVYfk&GVq@H z`8HvFuvufqT+Vc6Cgu7Z3*DrgH20)%RFGSS1o$#s5*kzbK-gPu%oZ9+P)GJhD17F_ z#4;l6(aJI=oFl{GwWsul!ll+4MA@f&pKPg%>o4}Txr+1_(l?*LNo7jyB%qblaDu{p zbCy-Xg$r#mQT!Q76o)Q`jApAUyG00030 z|GZsYi_<_9efL)cM6{SjR(2JHl@%1<_Q}V6iEXOIZX%}DUBv(HJ@<1aO>1jKDD>~QW#L}F!kmA>t?055O{L9`^2*9xLzi(tUkkZt-th|-IGw;hv$bvw0|Dzzr69t5yNin7i4!CgN_jcXD5!pUYC4FUSHBn!47M|wl&~1vRcbV=HhX&chP!|G5eyw+>D<@LTocgJ* zFoo#aQD1?q#niQpf|}K939S0DP9;QIWws1+Td%(A&3G4X+I1UU4C=7*D8qGV3zP9{?c{5sA zO)LaYfw`b(aGBy!RoYFrP4YNZVZ2mz20n#_u3}MLY&%>=S5kj#VrQI1zf!24FXwmM z72J~dyj1x)EqZQ5(m?1&>poMBGQ>W4uvTR)K^7N1&uA9X9A7C%Hg0P{5@(V!C@gQX zSXj&5cs_=XDeC60Q45gHNjr?9dD!Q(Pb6}dJ;guFwMu_!ZcUJlhG}X7y*bMReZFqK zH88ddZ4X=<3WEJw)L6f?-H+ClLWsYt+mQ_nX%CP0Qpa!YW={Oc~wj6XBL& zNeRxQu?$F&g+Ct+PDYk1jg3M>Dq%jQ@2S0j_8Zx^XmL80{^FfOx6T;*clrUiemRdI1&&k0WA|pQMc--6eTj!+|qIwnGSamJiS#YGVnSX{9DY~325z| zP+$}r*!61Y%sAWLc30QfRO~A87D8}|9(EjRBDK42?%19Et_Q7gj8^o9TUK(#4A=0-D z8ugSh`HZ@ljWtqZQ8*9sb0L3)@N^?%(FrT>y{1SkmUo~gS>84iXXd~1DYG|O8Z4z*kY#^+@4Gu5k1~_^VSOmt(iBNipdPwGVql?Jx#3|P;hQVojzGBX

YU0*t>=JBLUCW*5k6z#vj+Mgk0)il-x@8KMO|co>`j z3f<|8lL^0IN^({l^(jC*ceU`Gsyx=5!q(Dh*sv{eW_PU)-=^jUez{wLmMAqS;;!|( z)G;-YrOYRXiatzzxVf00ar}>f%-d0-eFEU`Shg+mxtK z5eNtnJyZj!>Fs8iiQQNEh$?@8;|+15AN z*7I!ZEZh29w)OXH>%ZC7|EyKM)(7D*o)KF@kH>0H_Ak`*Mx|4|^8sOoefkUL`G`G8 zwvJB{?>|Tdo({a^;L#^a>4jr)eM5|t^}*f7>15sbs^@gPB@@UsGU3tevXCZ}X`2?O z6Y=OFrjA30nDyR8T)j}ApFw)$rK8Ub0$y05Ri=D@lLfMGcUPl`A0i~y=$E1K!D?R%1K2SfeZZnqLR0|oK6PgDg<9G7Ru zDVBD`&(2<_u;YP6F%YA}Mjt0S`UlWt@Ff6Kh(PN()i^00E&FsHEAhlF%w0xd8?Vf2 zXmT95(CH^2V6o1HdVLDYRNpP`y8xxvf?0U6hXrUcnh0;Ok?pz;h|hz6oEP(x;L9B$ z+5Q-m(H;$(sr1g@dy4|S`uUv|k!E?5nEY@~sXQ4rt|GoONezjPwkCp_T(=n>GcS<%6;0Q9t$*pGF=7y4*CbK1{02198jmbyj30uu{5 zqGNf>;^0z|wkQ!>Hr;kJ)ukXEc_WR>8`rqJiM_kp{m|9Y*!Qln5BPK&`8%y1kwEGN z;^Kh>72^(;JZO_^CVmT`*z|SqEol*+u2NNrbR|-jMz2SsZ`8pUHam3DG9KZ-$!5RU z2aOyx^L#fdh)|cu=r-YAXl0vbUjMQ{EiuP% z6@e8gRZNcc3(L<(Zm|J@#AgI}Q@9{HBhG(O!a^JEoc1Zccb&l4X)cC8NvN(E%Gr!- zmgZ72KOnM0!a0=+GWUZt<<8afL}i)|mUZOeL?A8u^oluUOhIo%K1cAh z|2@DLCexS~YRk4eR#aJpn=r(*m*Ycz(>ADPcdND*1+5k6VKzM%EBdo>CHf6UeJj=s z^#qorF|+ppK#HzT0Ud`21QmB(wuY3I7eV~Vr*#R}jMk-n+C-waLt^f%=CQ^(x?5(h z6-ZtB5L?=Z&p4LouHLQr2}1-xFp8uf{ba|9jXg+EO7&GXQf=G}*vhi(;90=qtZc3E zVRSa*v&)BEy`zdDJe)wth=`KA?pQY{eRgqF;yxp|zh~$thBh!6D7h3#Fy<^eaZ?%t zW1L$pd{=lG?j)3Swq$w?mo@(*91G2AVtBm#c9FzfReDxo$-FQkh?iK1W%yK75}>^g z3f5DbQ9!Mcbr~J3tTHX>sNKs1p0te*_RGe)6!U91`f&DTleXkKJSGc#^6UHc4|dni z0&UI5UEHd%OFnr1fQ515XU{)mUwx0y`Zy@rI~32{Nz*h$H-rd`S zq~0O;9kT!5fWZ^++CATdHtJkT7ChpGg0OSsM9~5RPD0dq!vA2mb;rg%5dO^RF5W*b zEsg(5hxis;(w5?6zL0J9jhR`RNaqW{r^#1Cor2FZ4xnevVlnj8S-ev0^)%}a%cjrS z9kWV3GjHoDQs2K9TzWJ@K)+F;<7{01(OPj6#U zlT8ss+V}|!$jHxZNkEE39qB!n@1t2~ng8$Ddx+pBbufB76Sf5Kw>M=NJgyM;%W=0T z!$%OsR#GbuI|@9`N#Xs{80gkY4k*OC-*Aey!IWpaK`kz|v`}tVBL)u48}1zFF8@Ue zYnrlK(JG5cP|jTXqJMSrY-9}}JqtF<+Fq(((W2WP^T)r-m7Sa5Tw`q+EMW^M5x!i9 z*+=)a_*bJKHlnPrtG21xz~dl^{Gw@Kd?tA*)oD`!+NU>fToCkAb`yG*PQsYm;s&ml z1g_DhB^^8EfQauk_E(dVD-e80a*i}vV3&^g3huyr;QHPhufvetbJeNKeU!r_&vS`C z0P0)e;PTKk_Z!$756k{Rqk z4YJF<)8Z=7NMvszCa5jP6|WWyoD74@P)Y?fAu0%@V`$MLgZ75Inx3*Q$xJ<90Z(V} z07Le=pgT93J3;GkhodEqc^7%j^$b#4GkQ!!W{2rqUY6kSfRZpT!pqzCTYpA48BEwpS6J76{ff<&W+j(= zlhNQ8r0kx5<%=nrOk>(vUL@d9Swz~aNo9>}t|t1Me-kvky97TIiT$BEloG$?gHwi z$P+&pkh-p`g&=q3xoGJb`aW}PZHJn6u$iWH+GXV6t3zb)`86BZ(0X^{JP+(^AgWo_pB;FsX(&b>H}G-!;x77*AhPLM==i)0CDQ`g8ZtLYoGnj=WfOih=p$O4<^kLhO0A9=@gL z*}v?0_F~V$V?|qRdS|}1jZX2?yfgjV&qR{o++(q%+y(laYA&P*!gAgZ3UwW>pSX%a zKmD?V$p{|^B74feaQ`{le|^}y4jsRE4zaO`v!BT2s@}@F0dIJ#dP?cw*QU^u0~(|p zfz!vnzAt1aAf7kI+8bA49wqu8PJY=8Zzg7h0#xa}j24z7v;u0D#9-dY9|9oG4X;5t zToD1+L&J+=MW~3YP=n;87U$M;zgI#xt09S9>$+q)<=b65c98FPeI3|ilj@TIU78m_ zRoL(^*a~QL%8U;x&^^fnNCusCHSoMZ5Mzv%^kT$usV5&D55HrEdjQv)8Qp}ZCg1qE z)*Zy}FIW|t_{fTDN?C)ggnYXlvYmB+ly43VH?Obfmw9cGmu8k%-?Nl8n2l&sx=FRn zBb!iB?Nk+w)xgIE3jl~Y;z{T!ndnn6gh=F&Ixuo5^33HJLfyjo=_Xjv zR01J$>s4SMbZhh=7-3zVofEF8g5M0feSN=GR?UX^Y+nW3yaAy>sok;plSIVV7@Wo= z_~4uO*$JqiC3Tg^3^$nnRD zebe0v!M`;FKCS5sWfo9s3I=HeH8AC(o0jzADZ(QUzLMc}@Yx1Ty`WSLUw`7#5T~v8 z3IzOrANb{9FAL|~XmfxC4AStF!o5V!Hg{T2)lpV>lX>=!X3eN4?niaaIhf&)o~@sP z!Q=uy83jL0@q$)#C~pgWTyR$_H7Bx`X46!l(~c+;LGnFnXc+zYrc4<>dTG?qWGPiqe1rg2V>DKiieb&j*UC-EBhc#usI00&|tO zZPyQ`;|N1G1$(`Ql^^L7cd&8pNy(gg_k+G6<1S6wF3>U*4`9B^puKb z{m6j_YP8esh<36lU71O9Y31I5aSu}wqugA53tg#?EPVO8<#hWtf$m>de}}O~pN%pN zJ+GF(b33t79dFvbsm=o&1m@KPrV9vd6B8gQp@Lhvw8p1~TEk^LH(~R&eXtC*K$lcGC)FQ9b1qjJ zPZo+EOS!gcCjY0rBkko=)0tM*c)~lh`nHfk5JX5=qlX%dKOYDbPK6eODA(B#?c2=?6=Gjh4`arb5Uz z8@KMpD17$m0G2>$zd-J+ffweiW3jE(C*m|+Li`B*T0^PpLwvt+?>lY8`hJNxeSJ*r zL;o2lVi-w!%7A?(ja^`D)d`o^;~QFiNvHhu(zZyO1xump`OD<)mMmd&4o(1VgKIEjH>dZ}G@^N?OIx zH%ZB_^jjzv zn2Gt=RC(~$hKIf>`K&H_5P=fq^|VwY`bACUY{rTj`f)yW%hYU!IRCL44}xAU^g$G^ zEK{Lg<4dcppqpz{!S#lT+H4JxTD5+O-bH!4I@cY|(LEQV!DybUbLOgURG8qi>CL43 z??eS3loYfg#D7Sn;NqW87Al00xq$$*5Ti`NCTe&SY>hJ36VGz$rJ1=Kua}Urovj7v ze93d8`Um08m~$%Lg#)SRwpxXe?L*8B>=K^cwblwnvDH4*ePA9mDzA``BzSmJE#?=~ zSs!ZzeOx02wv5*VV3Gn$nI;0Wd#M;wyNTkW9(V5Fzuzp`qa(FUigc#AtH5(Z+3=XL zli;mUx@j-*eI^|OudCaQFr{O7x4+Sd;2Ggl_o#sPoWZG3>_X_jWcV%n1K`N)h3HNu zynR{yGW<>L1op3ovw?i$vfJ%a@#*)V*1b}i)K!?LsUfWnOve~grrAb&V$1g2e-#?9rJnxR?IHy?I~W8j5VbrPg86h{05 zDI-ux-TvJ;RF4Vf4SY83^U}u!7PI{oE??mCrKi}$<(QY_7x?$P{{9~Sws85&lRm@c zTU`FcWnV5|;m7AGc!Bi+M(&Uhnu-c~HZ4_FHNPFfwvX>+x{jb%*I*yIB{b6vs?)dg z(dk>|2Oys0dZYf6=nWkwA-{KwidVin;lIyLq@T_!h$w3rHmK+MFofWxJcUg?!KI+} zS4Qp5!^aQY(ZEqW@~&q0Z$gsj#*1=e){CozGFtL$00-v73QkzH(sFzVyL#Y$@)}*;Iw(z<-cN2oI2Ipy1avcG|?3q#E1=U$35ddO`F+a8-8CP46*b9EkwdF>9U_qD3Av zTULsxR%ui4k;9B)rx3QTJ+)GugDoX`rh8-yAN0KP>g6U|qihmype%=Q*FijCt9MOj z988Q*!1YK<)pCS;V{iD&OQ<@o#&?a^iXaZ>-&mw2r5HIY!&$^e5di)*eH8TSU{Bv$ zgfy<_`TKO(ONkO=F{V>6*xS(wsb$=B8*>!zKT2L8OU|cFW#T5ZPiWSiP0S~E7&7mj z=_uULMF0D9TcfJa?%4i>l+FzPI89dh%j$e|x)*6kA1?VU_d3cV7n9Mug`yT31C_86 z2rI7&1?3B38tGAV6L*Yqvs}Gz9Xagngx^QK-MC^bZNrRDR*3_^d90Vz;ZRjg(tW_u*jXKJ zs(_ncJK~F@^-YYKlWN5oVZA{0n{eA5&u@?ZVF&7@`%hv|!KrLk7o3bLHdg?u$VML@|6GzpMeRY>xUNL#I~HVC z&5`(OprO$T=d!lENf~!^2fc+RhV|fj#VyM*@i>KqjPuYNDOsgno4XC#?na16dErw3 z#_IShPTm^O0Y|Z=9E|#DF)RQ2V0w1v?XsY(suS6hnqtl)m*l-+dQ-R`PNu2>bwQ?T zgiiMNi|8*Q1R2fTQ3Q=;qfz64K*rI!X{a?#Eun8q`=`^ZJHx{;lV^RPZp{|iLVb*H zD)ST3{`Q=hvaq4|=mzw#A)R!v39~&Trw$W{HD8somSw5{mLEoqhm> zS<>0mKAepPWj7l>*-eu%GH$I_Yl;#>==_dHjH7G1%@}Ef%%Zd^8F*6Wc1nzKb2wGJ zabjdgTWNWS1<{@Iv)dlso6@Axd3BOB-uAwRG&@ZSK1<#^T4(b~Z|AXPP*_e@&delu zLJUm))ocpjZ?mCPRPw##2*;dmozd#*VN1~PEP9J%-=oUqA@&dmR;ZjH18fNB^Qr7< zTy6|H_PrsDwi3G{WR5aBn7Y#0shbJK9h1QDd0=pm=Bst`%Xy`=Fhv$p#yww3x3zJA zRxJy7K-vmeNKF**MrO`I@M7R^grf~<1qPx_-J(d^B$kCE`?zi* z35P|`nE;IMF^KK!DjvIOjh*o~00030|BPKtPXaLzz4I#w#@k}za$Dm;5B>pv0Vd*w zfZ4?aO#JV5-n^O46r!96%hKIWr}NQH-!m$AcFD1YS}=a1+TcYqQs$F{pv5Vc-i|PM zy7XNhrlTmb0hQFf(>q0^#tn%fWqidyE zAp_N|r}ZRy(c^lFkK{kySY4wVd}-N876XWMPPhaV3C)l!VmQBNS(8r0p)CZ{C>_6v zSm^lE)#y?X8#WdQue;f)U&0Nhxet1HgwW` zR#gBKk%tbd5h%;T4H&~85)Mop(~h5t*M_z>y9cg>U}Z>s>G&>~X*?Jj&eI3Q@VM3= zX&awcl|??z*^^nKX{gz>5Ztlhnx^TW!6KW!9-Hs_ii95kQG<#nG|JAnKw{r?Z7KGd znuA+A&&4Zw{T*7bE&Kui0RR6&I>ZTfQZ#6LQD!o*!Ca|_=$Rq~9@32*;LbTTI2Di+ zFub*n)Dwmb27r?d=rCc_oNkP`@(E-k=xiTEIgSuEhV(X7LFd1L5`PN3X;y5-1#O?F zf!1f2q^9QsYjkiFf?C*I7%8qA5)9DQGS!gP_UQVPb3oTY;xZ+_pjO#X0c=oy0r+CM z7zNn*clmj>(5Qq+DpbP_1xjI<3l3$7N^lv5<~oF_F`(UGDXE}ku(c2i;aml{g>a1u z)y1WtgCJ_LgorBKRsaA10RR82T}^M)FcAGKQLB|WKqb2L0`~$3ZioxZAqrg-!ID+d z1feMZoq03kkBRL~D{*T#9(&^V;*aro#uw+NulE(_*V8d{c82rQ0|z1E^K}WwL>15I z$z#_o^TNR*5W1xPrB{RwaKs2jZsg!M5>(yy{3;%0`8IB;N<2F7U{;^bGIT<9UHT6o}zJF4=aXZij?LKWHCXc{2K5xPZRbVYkxaS>SVL z{|E5hY>>hqLtns$l!&pJdR3LQsb=jKRF$G$s4xQiBG4s}6MS>na=i?c}!xQQiK2x6_^7-EHtlqe7-fn>@6^uG<12U3s!clk_fsZE{IuuMn5a7Dz4LL ziGz_HFKQ)DbyF6>!$bo1ld=duO=Ngf8_m4%R0Ro25%a8yMDQ??ptW{c0uQt5`F0G0 zx7xyekna29S1_*pC;px0oJ>oxjGJ|~||OY4~dgYe3Y{+?o@ye=wOp{RQ4LjRJ6yc#H#cM>YF_L2i=y75T1uuW|VKoQN}* z1&a!A4Z@CAd>i0#*z<8BU!8XyqfyOsR+(3cSw@=v(EU*ZtL6dY(-*f=Kx*|-jxN+y zwXd6>2F7Mb{Ot?q5aRfQ`i5AZlXF}#}agf(``5;pqgXDAg2LJ&7|Abx34uUWcy!#bg zJW7xwR};_vLPInmA!<}&^y}@+z6#NJGb(MNOQEx~GborsPlI4wMv@XGlrNN|Jl{0& z{qoC9k3~)hm2ks(O8OFR9kf3>Xg#1J4I(xOUc*z}A*H6f4ji*BOdMz}$P>@eEOr*+ zMvJW{E_Kyb4O1t|kXq(nI0&D`!?cK6%l8XDSV)_cN{Uv--CQ5G6Qjm5a&02psiZVD#{b?qXJ+;iyX2uXQ6%kcc6YRM<{aftu(;(G zX)obLoh29Q%!N$JF6duKRh#uy(gA4%#sbbm`Cq%O<00Dv>K*{h@nIUD^4(hAQU{Fz zn$8L2vsOyMlm!K4w7Ljl!?xGrf}{<#3?uSF+?Fn4v@pzHwo1Q0oco^2jf@uI5tHLJ zdD2l@XU{(zLR94J!@293W&5vB0I(g4->VL5v9tuHn*yrTs8+RM=C~d}i^0i`^_O!d zYGt^vy%nRv+rCX7RQnLP!c1MG730Dvs8*GFAYEIRmzufX$}U(@Xpg4HUc<>}7nXI~ zPn})B@mDow49=1b1ju|}S>Rf(0MuZ$6V!kqqwMzJR|A`r$~@0%3u~c5_Jgs1bc~Vp zvR#_EfdcxDe@KKtkt+?r%W{1;ydc)FO+6O(kPG>`qE+%kE)l`IEl1Klkx z5rvR}Zgd^iwQrjwd1A@?tT^WiDlj=%T5!Gua1_6`4Z-W}$A< zXypR{HTdjBQ5b3I_$sC#9svW=PYO90D<{Yk-Cv{H8C+?h{ytAJwq8c-j=^=z@sw;HQ z2*`a596}**v1;9bctBtC55=e$m}r~-UZRLEVoA@9sUp1uMMI1BCycTfs=L93Vs;9n z)KZEPRVJXvu4@IYL^};r7o3q{Er>ZJx}R7Q$*$_~9$6T_S3eDKv<>J!-$zY*GNhOt zbqrQF~Upha8$Nl)0kHad~PauysX<7xY#8^^DcPs3I%-;TDyEVmf&C``d zvm7pG_spaXG$w5n9G5cMO8P(z9|iI}#x6rB5UFgFzFZAl_pAdZo5NuIC5A!h65uD3 zMK4`@Iami5bPu(~A@?Y&uW-tYkgI!o`$6Ik`9V$QOfW9+5hm@zOB=wc^^qw}=cA?; zYtRX#mt+_@=YcU7U6U)ZQ6&3F6_*j)Ffdcb+y&tbb9&5=ge_$(1^)1Iukps#~Pxc+oKF zn60eOmZzR=>o=<~e3zR!C!3nN(n-%f{prwvuv#N_E<)Cds4Ix>bdc7n){6&Zyg-)WZx`%U}c?NZv`&s3K46OsRvl=gOxP*ia_MJSroGzhyag%s%k{C@Rs z!CA4W=)=R$t%iW{D9)GGL2RnT#z?jDG6I8KZ@Uo zth1O-%@646g`aq`KimUTH&-;XLJ~t&Vr*G{Z?8vwfRpK8L#h+<*U6hkQG9s)^!omz za^=HeS!oH!Zx8C)c}1h>dS222OmQ~T&<+lVFO09@td=kU9|s9;Ut^O0KL7v#|NoR- zTWcFv5Poic#ZqHxQ?yue0u5B@F?#ZY4eEuwEGe64R|1ldZNxEL=LZZfSy>V_NA8}R`V3Tjy zF1)ab<=^my#O>O?3dX44HzE2Cs2J*egbM3C$4)jRg%A%Aq&2 zBNSJLE|7iUO!LPdzOaWP?C9D7mh(N}241~5aVwfY7T0{7J#27%BBiqLA96?xKk~)e#U^*CB2V1@_zR z5eh=Z1*duP4EN>KeZjtx#2ErLFUr=)O&Z%amPCmNJGQ-%s{=QHucWeh<3rMfSUz;6 zb6%oW@P>HQJ=Ap+GzM1-UqF@Ky59AkhCuQp_e%Qsa5xkhSh{nrDk|%lvT|ikXBBEc zg}z))mgn9Yv=l~_a9~OBxNB%mj-*uYcet7K5R`mqz$Ecg&AhmpiJy}j!Kf*38uuUsyZXDN-I~ThI(;Y3%!}V2 zo@oT9m@`hNimvKqPjRt@Dr#nHl4TcTO2fGEl;7b`rZDsr1p3dIq!g(1H>1CMW84cy z!AGuUg*iK{1P&~vN)f2&zMkT$xP>z+<1%61e0pa;X~-y(&RBwJ@Z>~NATHoNS^Bu7cb4a*faOTMr50LIne;g*SF@$)GoG_Q^@uy9T(l;RS0=d$xfT!GAq=J7>($>EsMtsd6NQ) zrs;&LQqoX%lZW3HkB@B0*BoBPBJigP5SZeQa^vhYzV9ad4ZzaZa#if{oatLLL^8f8 zo;28+Rosr+6Ga)C#;$(@zu(S>N4ehi4m5^A3Kb{(jdRG3$HzyWdRZ5XUq_#4I)IdK z4kTMh+bNv^&B#OW20s=UsoP~YoEu8jyxXuOGpTdXBkk)(&{$s|ed_VfRo2KAM65M3 zdaReSWh9vqpLKD~_kAuW+K)Nn&pBc?&zi{*|I88p$`Sv`5&w;dup#Qry0r)l)_qjj zaose|-emZyj!Ar1sMQcn%_cp^f>z|`M?=^Yz)B}9=|+_un&%9@HlBK{*f;7stO`-eehA8SFc`BgNV;_yY1D+=A~ z`o9aWrHADf_cNG7^iu17fcg&r0RR8&U2AU}*Ae|3{)!6|f+b_6gm%&ob`{tO0whIZ z6t#mSunc=8E~Tv~F0o76QV9O{-g9Q=K9(!lPLcLQ>jXB*z0cYEnCBVts=CARRWE!C z0`vkwFq(}*;tU81$6xGay3w4^;v8V8hj$MfeiFgfd}k9QY~9J3NzPM8nQ>xnNNc0` z1cXXVDsJx@5@u*X$%CD_1YR%zTL;zHCW<G+d@OB2x+#5hALy z>25bWb4cpl5*~3k-Hs>LN-j3+_M~qlszh9VlFI9fBHiv=#v(@PQ6$>#LI@?`tuqQs zTo_8(1$(!wj8s|}?NSsTkVe(0mKr9WyQ^(k(CTF0yi4IgScm+3l$F#sq@S+(ws@8t zs5@C`nvJw4&MHx+jTPz(YT={JI7xDyAXV2%=kDn)MlRdHx#j zP`r+>L5{K6$pq2rtP*K4hz$`(5!5Ectb_VA!1fr|3EZ9Zckw!78oJK6Woik%2p|dR zN4X^|i&^^Pm}TrffK5kItjdol7AqyCyd=zW8#_IYH!*>AtcxK~Tj5W9DFEjS>~}#jd_WJ8{k#Po(tt<#^dLG25H%J!iUwG{FEc*qA8V;p(hk}OOKb^m&oKJbrrD4 za%gAY_W3S~599li5W54)O*v1uj`RrpjI#@3NJ+1B5o+dsjd7b2gy*qyJmW4f257Sk zXx=xmUPQE#B1RUMDz^G=$(E^IVw^}l1_cEAk=$eR>?C4U@Fvn-L3P^F@8I=WrLc!D zElGQvL#@Q4>qN7n&sGw4K@?+XCH%{@S*zWczkL;}SBM@vh&+HyYOklYdIrsqWX&bJPoMQ3gPL;wg4o*nVQkWLu$rG>&z!62&ui$7mi}*ud zu-W%*+z=$Yp3N$12E=>PS4nD{t{7^xP;!2Abbwr@UfxXK5%~^#9XT~X zJg72o6c&Y=C~vRL8*KkTi$Q&=(AdesRt&0_0Yjs!ubJbfdz@2ov^PLU8lUKn4A(!| zz~V1y{5wee)0#Ip;*v#Mo9d&9Z~+mHXi&CCBbaahR;S}lw{G9n$}PbHDVtSZqw4nS z#S@sf1mg*dq6?*WbH%BHTEY|BZap54_XNYR)j<6VdRBB|*4aH*yB_mueh{Fktz_jX zz8K=(uH#l4X0ww_enZw4afGzp)gY7H9P;_?; z&L2;SDPr#vhM!j*M{`AzpYX#}m#vgngo^6>F!-GgZ-!{gN zs}@Wlw+|zoM{;|7>>KX+SpDhy6L5k!5UN43`_8SbbNc^|-d)2v={UGRhn5pSLs zdw=0&c?BU3p#CuE`9?NgI{je=Hj0iA;C>>4se$!w=@;)s`y!SiRJLbvz*1=@!(Tij zMq%xJsqD2#t6mHgX(|k=@5c-!LvFm>Cny=%T2U<^*v<5E2kJla~^Ysw43ZwUIqYhSukSL+svf|}1XWK$Vdzg z#P@a>-Pcmp#-y#Z+C$2bwgxg)qnJZx-90AfI4_C+_Lz;?4^6&jjbVikB=`kSd~H_xB_ z^xYQGo4RRu5J8a+Sa8JSoz^QlUemjs!wue)U?aL&Tb(0{unl=S`0GXvZ_MN3O80YG z`dCbgGk@zetuQZQEv~v1HvCWnvBGh$wWI-=7mhF~5{L!f$LPL|{kZIi5spY}kT#na z&tGnXCTn+5kS-2I-F_*X5lL?rGanXoe}P#cGmgEo$t(GJ7uK`13+{MfrhYjPM!|ntB}iN zpewPcGv5z;Bfs)Uds?15_9TXh^C~)Gn5GcXcZr{P+zy4)H(HpN`E1^lu%`U5P~;4r zNWiVe1Bt#?uU5|pPN%injS^=oc_;i zJ=A-JU))((%ihrxe>Tpw7=Kla|MGg%OWd(uWO;G|Vr(^)3HO=TuL5S3m1`Bgs?X)7 zurL#Yg~{5E&{n(nF?r)z$$B=eub8GuAnR4F_`C_hGV!%QwvOnVlI`(mbeBKTi|<~7 zc8BE}lGUm{JJh`^w^rO>nd8Tv`&rH6v2Qhp5GEuKM+;l=!(^PK3bUQgB#IAuilv{% z=XS-({TdE%3?oz>8jcGM!V%8p%_JDimYy?x2^05qcnKO?L$3(j8w+t1wdh07bO$tz zUVEQJi<}x9OprH6DeV0(B4Ngv?aT;I5~1`c)k_Tx$bY!TouUWzHdTFQVXUsF>PaRAf&zpFXLyykBP&f!gYZ+OcX@II)&&(=wDV)#Uxh# z$L^kjd`*rX-jfVbF_FT(SCGE3O$J#$W`{uhJRk}E>s6(hE zYl7OzEiffPOZr~Jka$$pvzs(KmF2DrsU*lP2EXZ$zF4f`o&$Je+6ta2!gB=HYj=kY zY_J>|e%Ng^{r)R-623D|I@jmBU;kkzRi?_fTa?`VKm(Tjg9&jgJBH$22|fc`-}e>U zDP*OCfa&EKK5aq@5|=K#(PrIBzWD6D2iyjKq4X|w=fZ(YK6l_Q?46dQbotsVu9N9d z^>c1VzpYQXp>$redWL9hKd-`xE<@Y7=U?tm&z}GM>_>=C*}!*iLiHs!Uanq%mGfLk z)nkHgF`WwA`nk%q`v}G1`#MOrSf0{DFg^$ZuwGmcDUG6}e3?XOn~Y2GhjJP=88|q&=goiKcICNmwGb;%(pHCsrs`SG=WBeCsnA3%3h<~8tee36lL_;y=Iz_wBENtCNk!WkPUQsJeyv3Du77~lv zO4G7(FeH~JGUdH%*ZwH)R_obJGV{dYgcb~&?#R6$f0-YuVJ19DaEufTS8-9hxzm!B z&`x9R<+(9yn<3svK(YWCCD>(Uk`6*n13ihTlTs^%-`U(|PtaFv=jnP8gm;S2rXIrX zBGYslIY$+q9zyjX;#0;m_72g=K*lxrP}X2xRF1F^{Sb8#0R#?{dHd?>hPU*6_pUB^ z)xv#CY@{X@`#ZI*r&ANYoJh4KIOB@7A_kR$h*4>zX^uGB$6CHPi4X#5 zE9t{j545FSOY|Z7LjJOs`&4VKihYg#s$HoJ**~oNiNCR{%n8FxG~&%K>KUY zxY3%PHd^PpFjT+_b#^Z_loJK%{1gghPX*UFA%umNZ#4YvW%{MWygQ{6OPRw9@t(TP ze)4AdG`a4F9B1SuNm{QAEiSClvLnxq=CU0OuqJx#T=HKTUQMfd-yHLyZM$n1#%Mq!HstF0?5ZGzD$gkD_H$ zE~W`y1t(UB&r+jw@FBec+-QlKF0c(v*8Ht+)C!i0P?hIPIFQ1yxkT%<1C4*fup2+n zMMrNB(%I&%%S&L4F~`U+@wI5i(PB)LUEL?5N|d6c%IOHmQ6BFpw03I!?p| z1^iOG2cMEvpl-a4Lf2I&RMB})hH-sxRlRp zBET#`0BZQ@5!KRxHh^76Bg>!UL@U7YHv=M zuD$+ta8U{`@IdVdfb<(;p5pw(FUQ@O*>J+&wh?ETL84ScLdUOR-d`O4OG%t)!< zA3cq>qgYvKbQ3%CCCmaoI7IeG_Y;ky;|yH5>RN%CulzHsqbSrpa4<=7a|as^m@64-$q^Noog5ObXR1U2m?IRxk-al z>W{mQjVxRbAL2=n)htO|4-aa5AH zi$?~m`6wXLiRw2314B)OP_jdJRoVwg_EdCtiDr1Ci))P$oDdb_q`T?!Jd*QL8gGu^fJlK0${CJUC6^}1 zCG`f|X@yY#J3DV?c4u89A#u$5YdzlG%+9=dFMKD$o@q|IhdlG%6PueGX8rRj)XZ9n9JKrlxFTD-zY>fQd~TivR7+kdh6NkE5?* zTDdr5@x5t2^;Ukq%I9mZ(-f0gXO{#PDNvZ$%`c#`B54d$HW9hglxNN&h6#+wpp?;r zrQ*eHCEN%-9Fm4W-AkBZ9NF%E#C_c*wyl@AjpSgkG=O4acPAT~1X#RAWP}aBEM1j| zH+b<(OxfgR(Mo>of@9NxQ}+`mDbN9UpxYOBVJCMlK~0X$Q#R`%oJ>@&9ns*fZtHgO zy7(K(nE_yA36|b1%eV7#wW2;pZ5=bmOw0us&UrwmPbHg?gEN-1ne{2L(fYF`{i-ju_j@5d+>L zdV$uP1ZI4MU(3A2Go_G@ZtD3m3&*E=7S3?ez8)OkoWlptx%WdDBh=@F0S7-Dnp=OS zEFM{%LSnnsjL!&0A7<^Y+uag92H=hN%}^hBEx;%wDJ51{>^AyBYSEG{P*;E-Q`U;{XW%VNM!@} ze?uh?ro@4x;_3GzY=daBMHdN;SJMU){Q&>~|Nm@V%Wi`}47~FdJ+@NLk*Z$!fvAUG zxsU*1)f8y5q^Mut9gppWDz|6}i2*-Yd+ce!>=rQyX!!i6=k)8*#@IX(k4Vx&lau@g zq#{MDol$VS2lHe{hH$|e2r9r@5&@`lQoU%rao=;G%>k@$5*WU|&Tw*Q*1Xa*4U9Ho zNT&WMYWl(+g7==;6zP3y#<$FfvU@5+hmiIxwa`HUOj0Kie=y%#n7lVm;obZN$cf9% zfT~##qrdV|KtywOVNoxn@NB=jzz)`RXxtCu{dF%Hg)=*Uwx&V{EXtccYU^mBs7(E z|D_z7`v63dgmMt`f6nbsXkyQcN{4Z4)uVC2gjpSs(1i)*ah#x!RUa#4L{P@Z{w#&z zV=`XZK|$K%RVFg|Bl7dV>ZNI?*jLTuKOk8ZWRsE#m>}ihK;tCyVf9;@892Y;YK_2w z?b`BaG2Ih-u}Z0UeBloO0RR7NozG5#KoG|7eF`o;m{blP^jb}Pf+n84U?qm62r1Y$ zY5MN&{AOl%p`5JZ(gB9~w=>`8xy2Bk)PY*D(D1|;`ps0#T9zbDBB*3-HO7sEpRW5Z@KF!t+*?R#)9b573tP?YoAoJKqmmjs zZR-A{ow3(J9`^^+S0t>hWq&~QtkrNqFzkLal2wF?XOhyc+%KmexQr_4H8ZK1BT^%} zKLU;G?LKHW*lPDz5<9@GS!*5Jjagm=gM6Xj(P~?DTl9FiiI0>%R8EiH+Xu8P$ji zccK#Ki9}>|9QsDOe6(*zLaG+<$wT6qrXzeHxz_bVLdbN_sPUtGOdK|LNWM89%1ZA* zl*$~moiw4=O;9rZM&yvrnt9`Dg!g3Tp0DBO%_hN@J$C_8H6LTgpVuSV3x$ALmp;94 zzA_)B)gu$;6NN8G=pf<0#!fT~+=AWf$Gf%^sTtyJ2)bYzst^X`{pZxX{SN>D|Nnel z%Wm5+5WM>Tu+gA~%K_VBbMmA?9LS)c((+>5uRW7Tlj5y*Fw$=}?3> zn*jH`A9=aSQ<416bTxBdrX^+vN~T6JycO?yHJ^<2UuUpH?5MTbJ&|w=gk{%+{j4%A z;t9YY2^q6kJs#_L+KF~ZtkM>5R#v?ujJqMAyQ|FtnklnJY*TTf{ z7V(McK=W8wq`M$M@9F8f{QN5%#LgI9NV@$Z%-*P~mRF#M;VpiQN zD%u+v0k;ID3PrrTt@Z@u3cvB^*#&Qe1)EF_nr|8!y_i#j&hK@1%qNFRg8ulaaH zXPOo~8Z#+7zrU@ZoP6X1i>${*Ql)S9;r)wlf;B(>qh>C`C)DDmZOAK-87n>+zIV|J zW01$hV1BCWWJvKi2@^wjBi1!A zU4wQPEoKs6y9uCf6?xWM)btp}`NiHNEurVg4)s`yS4=NqN#CR!AmE*uw#Dd0tEnyztjBMt(hP1GBG3}(Bz4( zc#UHjDp|HA16RsYp3{8UzH%u;8%i-x>Kz=e0rIrL&(7BFTca^7UKJd-2snj{PTy zeB(i&p}aUjL!om8mY?!XxW&K7q?r(!BTgS_ZgQfzy)-xJH>dYR_s#QGkHDI}@P&QgKEG*RroAf}DFqH($*zidOVcQRB&sh!}}2`bGfYe;xtn?@r) zN^YSs(Z_~L7~aET!0dHOV7Jru+>7{ z3BGt{rf=z#e5wal%N(S2EK>^f-f(Uo1z7dkK^Y3%?Dn@jJ%H(=RMlZw48L%v@E=o| ztB2-ye>q2nOEEHXMG~i~9!QBKPQp}1m-~$6RdMu&uLCVcVq;lZvl{}O2zLNk5>9$* zaD_6?CXf#W$_XPhZ5z-aX?b$cvKb~stBVUo2<=L>O4ZdAq1r$NV>nSxv8}R(_nG@b zD=U~(H|&avGae1>-N1Q+rt6xUr(+98f7kVGWILICeKLaxU7GBbC1bDi(_m!c7|+CH zT+z^49>i}sKh0OOX+6Uf1s(bzG=-;$z)c_qd`n_W~5O&u33<{NorF&mC?89a3;kWHUdE%cjUbV zz_)Bk(M|KJLin9Bn(YDBstoNcw(d4gJuEZ}cda}D);|u|KPB#w0r&lZ`vXb)krR;W zPdXo=romb}xa>_684{c2T9c@%xF#&~fPZ&vIk%-QW;tTqYJ~YLpk>oErP{1hbZl@bxs;_$eN&Jq!Lsexwr$(CZQHhIk8SU?uqaNn5zF2vB@8ANL>0SuE@`uw~jRM_5>>G?3D~T>?MP%&_T2_Ah=f~;agcO!Khduv-9hdlT(Td!n!OIx8?kgm7u~+j;5>`NRk5M0#geRTO4#P`7{8H zCV*8VU<+6^wg72Sp-f6fm=QLZO0+C+<1*TipoF@f8?gW-AFA?F0AQE~#n=EAT3rHI z3zg9p*m7v_#2fJ$s>@_LNJk8&Lr4t#9fW#`*CK;-j+AfDV|h@sw7+F;fO--Ok`!3 ze+f{L1eh`X1N{_698YyF;d(m8~ ziF9Im`6iR;{}{3PGhT?{HSKt&q6e!Ryiju<`nXf?Nw-vO0|cJp5OYt0SBzpSX<39O zPu?MZ1j=Sy>^K!(F2Pu$gkV>$i@xHWn1IPn9$m)`>QE&M+bmoQdA$g|8GHfc{GkIfQmv?p(j{!) z1CyJ9>ih4~z5@sLE;L4m_Vlzj({OGj4Fx#11d+T@{#;QSNgZigv+_HmLTEIgpmQO7 zJU9}M>83HlT|dZOBWj+X&=mUxR?<)Ww%e)Ica4)kBIF7CBT33Z{US+ zc|hm5rVR-L%A=H}7Gc{^HWFgx2lna%287|wL4Dj#OD_!frZlPxEv5JA&25;%=T{uLq}0i|0oZ{kgWz-~=J3Ni|y>i3*asD{0KSAeq}DAKjx ztJq-WGOoKU$2x;dZSo;<6|+l}(ic`cWd|Excw)?YU!ezX{h>-qWQaqEL5->IyFrM3 za+bKPwz+lAm94i*rvj|li+m94R|3}KAS(<zJ4~Tv;vOdp626YvAvg1y~tx&GvZMJV| zf$TSIt)NLsjnK#YO~*QmDZqx%!HZHb1$zOi!Q|~S5Mls_n7-PpBM)g{^GUo>7uPk< zX7L-8KhbQK64B7!haBqYhqI!1g~oXu?r}fu?)2?e>Dr9{=m+9Z!6ekt*(T zW6Ozw@omV(|$!yFwfoZiZL$32=FKtvNzhq0_@_42N%R6k&HSd2cb{0Jw%L zjGDfT_bLeUW0?g4$fBXnyBLxhEjpu(>hV!-CXx!gawUQXz;T00D$UbuzTg!q-*9SP zB}3nvpgAbo@g8k>(~WQ#;TpZ*d!65h*lDbNUF4JQLTnbcvHxow@V>z)UWt}C8jThU?c&w&v@JdjBM^08^{`&!9KdhTa>3a`wG zIY~4WvdoURu7Wha!R16u6)+^Fh!>>fqs9{t42=U!`gE2MLX*Mfx@uH{Y8bc_+9B;RGsZY!nbiu?`);J^aL0Q z4wZDy0#VcJe=8BJXSE1m3hsh!%QZMT+uawB+%fe>-@P+bLkI~|hKm@Nf%G+uoP?Vk zpyZ`Ot3er-6c-202fhH*``D{Qd%GP~55vxD)*(Pj7U8RQ*6|bx>eGZSP1q^{6dv{7 z{P~jQCx_h#>b^hB0oh{|62u-Ch%l3(Ey6$qp4(qYyNx7Kj4s)O1|rl_ z^k$pqolo== zr+A6gZf0Dya%(kaY=Ar-5$rZ7e5P;I+sH+U03H>ggbZgCi&-(*4mt%D@`hwV^J-~F z=3~GBhYu8Ft8oVi{u}=md@NRg7$!&b{8MsXo|%QEQ?t1jr-b@gc;YS5&lB;nB40IE z+t(?wr2|6)_Iecqjrl8SERgJ_BXMK=H^JzRWzOz3D-xr?! zQ`YD6fE_}gM?%uEXkJRed8oklSK8ojQVP${`rZlYCx*7cLw+QQq~>}Bq`@ky)uR)w z@uXXjY#YY=NWGDcRzT9k0~BkI?8H*HDaB|0iA+|;wQ_!@6rWYSH8?NVpx>W31>Q)+ zM7ol1KyyGeA3D@FA}~|=lTaKETsPMyvP4Zq7H?S{@wk%1dE$){#u7h(#V?D~`$O}$ z*}6_v>li#;bad`(afb<|scsnBd0mg(!1Xk7jP2-ew)1@s{tEOM(3V{K)>^G_8<%lO zD+d0u?GO~mV*ulKXr3VrdB16u`awlk6-kmcn729>Ll0YF!efgVKAyup2bE2rJ~htt za>2PTZg0#jE7vc^Y-p1uvxz=ooOYijo@*xWC>c4DAEJg~C0=eS4^+8%e zUZ_Dn)Hc^;XU$^S0YhR#1G(FhHXUh}Z*`VJm&45o=>{#zb$-+{XrjoGkxVDU4B!tZ z`QCSaK?s=$1L9q#^>R{GA7vb&X~(A4TQ{$c$@S3{%lnxA;9yGO_(1!JHrC&;^PY(c zgkc{++sLbB;y;8{gpgzth@h>k^#W0@^bjn5OYpttyAP3tt-3A%7(Jv|EDOQ*X2 zz8X2#v$hvax?298JYBCen#q?PC>N~z{t~7#H z9Y0;TNHLuR?ahao&KbtV3)j_NPv82mgM=#dY5MhcN~XPx9fZn1a{~0;n)KbBn>hzq?*{d-{a=G{!+1#g6q( zuCEyp@d$3}_XYY0P0-szBWd*yxBb&eLX^F4>&)#fF>)cs1{^}Q3ql%>S{#EgxK4MZ zRix`8z-r~#!bO3V?7lOzc{WjUKF)qFFQq2Fig7lb2~$c?ZtJ?~wzX_xjmyLhncy2- z!Fy5`=(G`Z{#EcL>Weg8T2Ejm;sFdOk1V_=@kzzkmhF)kxjMR@T)8;UsDZd zc0YYrfU}m{soFD2Z*F#e;3%5To?XCB1-1BPgpKFP+63RVR*si-%P~Qx;D!rYQn;_- za1R28C8tYlaEE^$#S@bMw+7WgdBr$K^TXMq{aTBOJ?uO_pfD-<7rk%p8V8#5`v~lU zV%^_Nk$0`y5*Fv1{_Lp@Po-@7aImkX%Qc^Xk5*m2Ta znAVveQ2iC2cHh##z|G*iZ%w|2P{MK$@lXC~EI^fxb1+-<{Rol(7IrMafyWI*UrjSR zWD-|jk$SCcB^<-~Wj!fC5?^;Sh=J0-HIo0<$b4Kt^!;TO2e6!+2V`hL-T)kFQ|n8U zzoh|uTW|o`n`|cr&|kp;e1F(M`a^Gi6NM=3kabrquy2{61_~8NoOj0o^gkDfj`xb} zP-eR7Zx~!^drrYqL->E=22BV9p9AL>tx-Vl&1dW=<)Xd$F2%i=p>6^B*}v&Z&ctOu!RHGmw;!|qSd zH~wkoJ;}8ZX|@>;uy;LLN+yYqGK_fLM$unB32dxVW5Cj>roxARG~%L48uUmlF1@0` zCJ&pT`HauPZM=%wy?<;C^Q)bm9JqaW-|(Ky!yU}aF7}GA4@^B1G==B5Yv1UVUCOge zq2PI+*PnASTUQ(y9XX$vkRJF@+d`2;-Zo9m_KYF5_t7Y*e&ZAd1x>BBk;7M0P)W|O z)~>Cl;O%_olIGJWsqd?VMG7h2CxJ_6f6PX+rY>*7BIDv>WSm!e7)cW`)BhYra}K;& zdn*>Bw9KliN|tFX){;D=m>0zY-z|@t;whHHOo-s=(k)4vY8XsONz{C~@NP;Jt4Nt@ zI80eiTwRC1AZ@%NnU|T8>`@W-%&x8}I&;bPjjLI}sIIE~mu*7IIKGS`=Ec2&f?2+N zQBkBMa?`Y8f`(cNl=QaLDxx%A#kEHq)Ut?bjHXjZ6WlZVJ06K?QY-??$i%8#=z&XH zmw5jCFG-~2TAhP)A#l1*ZdB}+YxiLhHf+$&NcSCG9qWljb>WKUy}5BTU%k03hDcKG zgkiq}R9d)7h#%(gK2hrvDZgYu=l?Wpi?a2VH^oqfcONNnm@!+GCo~dc@+0u;NCmNg zvV&zZWk!)7OZN>v1UTOWF&@5^m4CU?3*FUz-eVeDI6GBmGuMtaYWf3+QL z^c=7DGw7a5{deQU3X^V=4x93CO1#W{6q$q}g_JJ}vraYrJX;<&LrZtlDOgL1CbMpd z$EGIj4WPiW`{O#sexPt>4#uxC&#eoef4fcnn`L@iv~4HX^7I?6c%=FM{cIpa%bT~N z%>8;6Rn*&GEVk5MVnv%D9o9cv(ew=b7=6PEck^(#-<$0*tQ%~Q(dC-BaV0RruZdW#XqVAiw zTF-izbi{qT*kBx-v;T=A%4!k4s1v|kCs-;m@E0s|N3_%VY06F?%++BmeYHl z+}e906)#fH(64V*&>&7h7^*4wDVokhOx3mLx9T%AzUKno8;BfE^^0L8tUe|Du2(pj z$Nr-J_^D}scV%_c#3USma*tfjFx4!jyt5ZpYrMpdG<@hS?tmHC#6|7MiGQ$$OSg=k z!$X{yiZZp*rQBPIT94?HTW$Mpq56GVolaBDWb@ye-FYOvIV|1S@$%7Yo9#8xt4v`{$e4LaSOeV9$SF5uNnCxxmd%ih z+NAyL@*MVLZ@k|=bK|MyYjkS)Zni1(lAG!2Dn9Xf4|MljU_Uf>OpxBlPph3vtpah_ zx5Qu@R_1`8K+mq_z@r|ie3Lv{J{s9Fxyh_sw3jZ46pyBUhJy|C98daN90Zrx#V0wI zEuv)0MSZ;ImgMw22RJGB(N%P|=Ow9{J?|)#Zj!+bjzTIO85iq(AVQV60Ap82zOBlW z@eq31j5L1kD90tlpI9SsiPmG7wLDPyq${sAP(#uoe1z0S?=_)12iH}J-!I_^;JCT4>haH7b5IUq0j37!GOd&-mq6kG8`EM%Wzp274 z(cx1Ft|LM!|Dv`;{|iAVCJTj6Kwrfb2Jb+Mw60)6=vrq7FsN}2`byCZELnPhhs2Mp z_%I4>1S>*VCJRXvq6lFXBP>vmDitCKZAAZ{!MqyILJ>vxrpEjNPDQy72pVX$2D|&e z1z9)oiUnDkEuekQ3lTxSVv^`^beO35F)!t_7+a**7QL3NaI9DV zl1h3`se(r**5KN{-x!lF|FhFd}%QjyxZ=r8A0jf2JMGt5hPhmBZ#thmtlMuyX20w2i z7RI}LOq9V5Od?uGuE4d`CL^=D#bJ_aUCCh-56m$>mk-PZU$oPD@$G?a; zYe zSw*;NWmkfZ&xWd0V_;Cn*PQvv!+rr9&A%@7^%j8na$gS;#ocaN<`N!HBl(M*>jw4Y zxtQoqG9DX8omS%#1jiTu!6)#U!d#ZDGL+OQ{IK})nGp3xY*-)8e%_)@cnBEIRl*w| zam8u6Ms5S2|5qJ{t2)a!&h6t}(>#uUc&WI`dhq>BZ4a8`3-AuV(mug6`V4laBALZg zVtm|N7rwy10LYlX;bV;Qv3N~XY`K768~$jysHM+Cz(y0bSkGa@T&8Tt00>4pZXAF)8>Y6h`D z!j(wO(NzGUCdZy4q}5a3G-**2cKZQ{{}G09LNS? z>YD+~B&zy=($+pqo?$ks<<;;ZO}7V`7h3GM2gQd*!G59dBl_tP`I`<0L5QjQU~WpM z{ykkofVgX(-f}R&-1h3>?vJUETV1ALm)_rEUC-T8L)^PjkXg6GFm~w~{jkmvgH^`e zY0wtxVV?BXLd7qibQ0T1%G7mYuEwAkdP1F!b;FzFLZHxJ;kM^^2%AcO2wPB7dx>o( z>HO1{qUv>jauD!0^~?i@pcsO(J=MconeBr-K%;aKsW7hRLlxW}8Aa_n-`5Jp$@)#~ zYx37g(yykO^S25-WjDy|=6%EfPYIcW9^*6mZ95!$6D`PVRr7emijX*s}o&(D+ zeC(Q$Ia+|+B^aHYnMorPGBYuuEc)dki$VE`T}NjY-^H$sPtT7i_WT<775lzT@atxk zTMvJPQOY+R)g=_eVC3_4Ltu98Adi=_nL2L@6Leqa5#TpJk$^z?@%=DcfJFg=%QWco z@FrmNi>~`5flo$Nxu5C;E16^@V1$qk#SZ+~ZVP5td40%J7I*{Tpw9Cw)j~v4gMC~v z)cz6I^>3f9#;rmk1~O`EfmpRW<^ zDa&K_f+AHtHUqFSPWrBXc=mgbZ#~aS={?yh1@t4g&KjTnz7OmP#DT%7btoqcqwTw>4fm@lD2TQBLdv?f`m%!=x?RR*be zL$Ru(**MU51-klm$)2_g`mdfXlzs_hd4<--P3?u@Vw3JGfKFZ!td$fIkg3c@=d2r& zm|$nh9>*TXb@}e-o_V5NZ2i(y(>pjb4CH5BC>Z(aje#dUp}f@m3FwJ55ADXBlubZp z?3F<~BdZ)ya|sG%(y@HVJ$ql-$N(0<1GqqR{hPt3q6rR>df^yZCJ2AX+8Y(x#avRfkZq7+hJreBehE?9nS}s?j7Tcf=QX?ey zrD<7n|CQ2C^FJR;g{mrt1gG8g4y3hr5JRIYz&=V|Sj&f@&PTt{5GotE$ln^(K=l{s|I35s@{e$?UjSwMGjc>k zh$xU^`wbae7CVJPRuPf^mhV(=xMG3%)ez6TgDcD&SA7eX%su-@qCzmXn!*_XHnW{( zLwK;fZ^YrFfJ0SckjqABq>^6w09I=(rWO$k(%ReG_D?G8f+7|6>U_(l7ivXWZJ)-^ zlOT6qOv5q--hnX=On`JW2-_I_oRIGA=HNXKL3yd`6JilGS!PXxfd!2R1i!SOnD$){ob7)n?HX_J104 zo3f?l2LupCd!f*gWK9;Yk!55U=7Vy&(>?YTjhc&LZBe)GwzEg=q$yF5La?u|+_)Ck z-)~L*KN{UOVwBB7#9*+}9Mg$yI%dqF_-Q?03A&IjiHzv_F=BMW!+UXwo)cA|vgx;| zl#jIm<+@b;nzmjf4+Nl{eJ_w$8+~3&Wiahi>UeS7hN|u*?NSa0onzOeARo)}_s%iY z0(4!o24C^y5jV8z*BiY!#Zb|!#P`5_fE0zQB}((KJcs~OCOC0kxX!=>(c^n7h{1pj z3qxG}l1;>u#c=FV&(6oHIVKv9L5`N#J8dAtsPiQZ&qrLr=)ll$V_$kG{O``NzH7kr zWVO-sjvRn`Apa4aKFX>R4P=s5PX$-bY`tC1+ZlaySDGJmhLY6VyG>_whEDL%tsZ!h zM|?#iTP6>DDii5OS5k+PD{~So60@PHCAx4kg)6^ppEq_-9?jaG*f&T>cLx)S#XFql zA>bRT{|(6#y478AH{({z&^HtHmXKb{hJAow6F!2`@)b?eOFa?g(-zh27f(IezX0xG zS$&`h1u0~Fiu3yF0@n^<*kPb5(KH~~ND6lO$y_mU2j-Uqk$q0Q5SC{xO>oo464tnP zfbt^>j``CeIv%Y%-C}&^StuVw7iToWSVLg=6?xY0!t{CMkAca9gU3SmkKe@*M6Jru zrQn^);QeoEG%rhcIw6;i-WI~=*wT=7SLXEotjwSoBu4DUXX@2RH1M@LxbaOnY_#&> zPtQ@`+=EQpCWFV4+ax589p^$ApzGrOk*Dk^$;}q(@^zWGH_9LAiPWQr@^Swf9{P3a zF8%+$x=p&a&WmCQKQpy+2C>U^bDt_7K4hM*8GPzAGrX)Jn4R zCHl}4)Udi3Po?`vtWLY0VQqw3N^%$@0wBuo;ukn8ZBNjur3`pezI72J?Z>?3eqQ){K8uZCAiJ)eX3zk?gsRrgj>*-?$V z^gB7(zh5s0addvaZa*gn*SQoC3OiU+7;ddKuz6aAK4hJ=^8sDj=KI?l;Q%V>9G|>% zyTckT>vrukpD?-5yKC4XT2d*XxN!R9y>jTZ1hb*N)3eJ~pbULAp}c8}%=C-P-G1)3 z62!jhT&_69lfpB-=inA^_97JW9`3(-{v?&Vk>!k%aZ(IE4GnhzdymG zI~!IvG$duM#X&`MMIc2W6Pv4gn{o2#3=_^j+%s=^m%cnRy)o>aC++t;TovWN&sIH& z1$EuVpKw;fKqCna@_r#U#NrLI1Y58O8NnWul5$R zV$qpAn*MO7Avf%eNnFyi>Ff0blfZazzxP!SP?9K(4;`jH5=1E{f)x7p?;fvq1EqWI zlW~JPe})M!OEB~zZew-W!0R@L-E0VxU*|8r%pJZcl;Q;fLER(OJ6G0vwXxMIbjg%F zH?pFEX{xBCtzftVKE$&$b~MldaG{4RD8{S0ub}?WJTWflaaQco$d%ohcBtva`L z;iJSbCkNs?gdi5qAxlODO85zi)v@Nf8ET<9#`g4wVE`t%z!9C2*Y9UM#)1$L(`ru_ zh@zqYbt!Phwo;myB>2OG_{B9;^xV9Jc5@X2q=Vt2F2Xt z3f^QG*j~h=8-szbC+_mEns5BI+(9zG)I$EXCQ5jQX!AbavuMJ`BmU(KK@Py;vbUdz zu0T+RAKwAW*`f9*!Nun!eCD8|FoOPI8=+e(Bt?qMg@4mn=ETSA1!7|T#IpR9Wt12Q z%*UfVBZH>ve zK1p3lr86Yo+LVt*x9=cDq_t+a(F1(e>+8{ldzNktrI2%=V9<~OlWP!7Y?7fM1aCfh4Z2}f*HH@GN&l#p-C(+#D(l1o z)BI0Lyi9*27M`A<@Pwim8(ge{api1-#SC2hba^7hMy61nCrj_K+dJ$!!s{JoL^J;> z#5ET+@-{Mef#JDbTen5~$$0EkOIdGYSugWCGsBv21feIa(OkqeR7^8@q+q&5^_PlC z)7_F=`pAHCbNtCY*I*b{BVMKE7wlJm0&Ao3^p#4?&3pmRJ@;kvac_%Pt@8rgX!aJG z5+;xY!r{&!jEn4Xk~=}0Bg&K+innkcupTHgs5AP+>8CjBRU=BDg!bBp(-fTtKSW_( zKgFj2K7SETSVX%K^dEQDp{++P{OQ7F{qr$S0?m60v7s2pRq>MvO17jw#5q+cr~)E^ zzxYYOFd}nH(o{BMbqPqU-iE4;TBEFT+%^lG#~L{F0uu&7(6$qB1>+)J`{=tp7IaXWCy&A7(ldD-RTt zWt{X;fY?sZN6Sq2r-4xfY82Knbt0}u-o#1-*Hn$|R`BoMYSJ1CNR-!%6Q>O_D8NgZ zh2Dgteot~?!5s0l-J7I=JXYX7cj=y;r5EgJ;cqss2y>i9Q(aiPymgvU0@bd=CC*Zb zB@bX>o17$FQ3CAl>cBoB_A^ZZm49_8`;GE@&k@b3>&Com3r`d&CH-Ek>M}M9D|q+p zcaq1ruL_F;XOo8kVtLUJFe?!sENhB7%FYQULcr(DC#9&7pjvYBkhe=%sF)`+@oxf| zqyEx8W$*fy=FB*U&GSOQyAK~Yt)(^-w&~C6aUG|LEELM<+ZZ;WLan>z=q;Z@n5lx= zKH-;PCahJBYZY%1$XR6!9o+x!@9A)!nKCspz;tA;S#{*SdS1s|ZF(h+=@*&J- ziy&f)CxX*{evd&YtkZd8&yZv~R@YKcR!Dh2HSgNn+yD5Cul@(jyyomRvV^20x-`pf zBMm6X6PgUbc8DU7v%!kufRtNkqWZq=V(oNZc5^@JUPpA3_dAlO z;+f+0%HS_3b!kvJWIwzMj&m?8Ak=@!WDvA6 zRrS($m+q}<-bmW?Ha=!U{G_{#D2pO3dSdrP~gSxH;Bc8SF$}5>8cH0pn(_h74^??AYrRefr58~yevjg za)kqfD7Z#44Q-gmwky$z#VN#EO+2J&K}4e)|Fe4_0RVha##fAIc+vw&qUiKf2%&9! zyAag5we_O;7y3j=$#I zBi;$nVU9#Us3A?j6DW@|@B@=Xsm?9&Jt4MjnzaYc8P#`^T}?VYo`kkDn}JT*gbfGl z0MhVAmG!b@h#~4VP`nav5r6W7)UU)EzQh_Y+u`w%XK*cg!}}Qqt@xfA(b z`->K;Luz5i$@$_@|Ai&U@Rfg6(W7KhT_3*~Ain|2&tj<_y8|yt?f*&ph z(#omsc4z0)|9d_JHeQ6;mIoOpW(7cuG?>EzAab5X0nWz=~HBJXSE>>*(3IgLxK)3I2>0|imXCg02r#emR^Uq!0 z%Kj9yIVE7HI{QY*vE`$URB|I)sbA&ta&_!Wu6K`TKHO4ioH;9tOR7JiEN%|3YRM+- z-!A;g@1pUpgqAICC-@_~V_nyrVaAI$hTo2jJA}O~dyzw%J%oVj4mhM$xvDVBQ_y^y>3(GkYO~%`z&^ywwKOoG;emNfnj0-KU z8|w{G=HDl6>F1Dbb4NBm*6iSA&3S=e3HcJ(kCqM&+%YwK6Zzaavxp2@aiE9~LSr5~&(KLM8whyQiv>pxGX zK?WPj<-f-5<>uj3%MO~oP(D2?b9VS@&)yL{AVAViD!iW)C+LeIdLS&hBTrlY+%8cso=Ny{aC+LmJEUXc#M3r1*y==o z3~VJ9qID4}HKuVE3;FBD^0q}*@`6xvLUQ5paYtsz8AfOWC}N+ug%n9BI)b=vBeEAY zNrKtBvRYePTe;WHfK>$#D&Ezj9Kzxf-^q#zdOxK3HUMrxK^!LFEkog?lO7725qCy| z4#{uD=v-wJek zId}M74RVGBt%gE+_aZ?PVZH%JJef zHL-hCWuIco)DX#X8dNwSZ#*b^H}5q&XHg-dyXWSqr`$?_O;S@u1?A5r&oGX2yCa8fg;k&;(_wCW->{ z*TZ{rt;^%3GI`~RRm<1_UpFUvgaJvlwO=Cm1re6;PUr1_%~K)6_O$b7*%XOop-2QF zqqH7V;a^lz3byuGA8G1@f~~8|Ye$SvcGR~4*TR5CU8g#% zBj1;IHLyT-k))TaveufT!r}$V-*+&;Bx!*Z-{zgyniXK3AQ!iW(~lWsa#9Zrch|qB z-lANpp%n}I^-sKQ>$k_!L|IG6s%Nj9*&Q?fim5?JApl^NE|A$N#Ty$YdCEjV;z*Wh z4e(2wC#)n|OPI>71-0}I%qK)0Asx(aIPm;6tAualxP(ReApDDiVQY5 z7bsZQ@7<43?qE7nRg_r?5l6zST=OR6YH>=(OlmMb~-GnmMQ52|Y8 z{(=acE2Hk)4U-uhxJ64ciMKuid8nj_d*>{LBV{^D{DMy7DThd5!8Q&If$*}~^!qHF zv*F0l0zopIY|XVZe$GLtE#@;j9;Z)7q`X3JbX}ng^MK({*OGq{9qAMa&^Wa913=4S zPzX+#r%;=iaL7U0O(xM{qV+c&)^v_K*fi3J>wNE^$* zs<8P#j~Y`BFd~H>pE%z#DBSX8ebqDx>Z!3sw9%@P*EJcNsux^Jsr2(>+mN;BX6@uP z+1p^5gfodOYh$ ziPb#Q@6G`%9Mv{xSnx@H%!F@3_w3!9;^gkD@g3kIEfH;#Mn$0$kE%=sQmu$;bO=`hdf}C zy9*4dg1|6`6;44o-0lk!hUXEjF)0RHYK}ab3j^~#>zsovCgYVuv7+ql|b>aF3FeXSbZ&*2pNP7$7ql-xsG^V^h3plS3y~t?^#~J&= zlOu@{a#Ws7ycRvXLk>eI4k699x5Kl;}juY#p+1W*oRQ+X5#NkkFP4qekhRw zQ+?q={wWY#Tb@1jCTHG9_L^ANmqB2_MLogE%z)mrZvsZm>crzig9!SPxrR;~06c7f zsPZS#XKJ_6XNsvrrI}^9`fzz?Rly-(PDmI&1ZByRebn&eCJoI-R=EB@cF?zc!WK3n)~3l*=x~~=tqBZ z!{ILN_$QG6L4EfP^Y<5#|5AQ=^ZVv!r+>F2mrESn8{A&qR(T_cLyw_u6$RWHTq$cW zMk$v8Ui1dS{AQ2J?^qk)d^!d3A_IKLg4dRRxQdof66sA1{(*|Vn2IF61BmO-*m?9I zN|6oSD&Ta(c^axm!-CLFi+xRfeAuhYw$=;%9aHW)Br=*7sGAa}3h>`iVfFx?3vN0b z>I0h2jcxzJfk*$myj>KoIw!7`)y&TA)=%$RJ@?M92f`k!Lupr|;64PYxVAruaLO^N zRkB1MXk=JXcQ9kILXO?!b{jw-I9X@+!0^=KW*S(o!^Nyea0qBbzT=od9#WAvVzr1Y zZGMM}c69PNM_3_MLP;>=gb?j~ER!l+n_VSxAsZRDxXl~aL`>_~sgSt7!}2Ao+u_-& z6njkK6ijd2V&#?Zb8G%)D1N27`eC!KkablPxPzTZ*2lhGS?m^oxI-F-IL ztt*bt*ir<@ylGs*cr;E)(_^>7T8zH2t*NntOqzVc{< z1TpQn#Qg0DUper%q4=&vT{e01GqMU?#;4|iNrd2VDMdZPukpdwgSZ6UbsQw3ZeAd< z^wviL16pECm3!9JW6H$r`~(X=CJS~fdSDBRxV(?tz}AP^{oFLE9`Nr5jto-lEqLF? zHay}uie13bSdOO14KJB|{P<2=noTK(nI7CtY9KfIH=FuVnap^m?d1dPfX%kEOw*Um z<$;lPVfD#Vp!F1Ij^{TW9i3NZ^GlXp8cPCqhfN#yx2G-{-~%-1&X~K;PuF}Ow`{q- zoW{?tN4bPY>#0<>xZXP!Xgh)R(FncMVb*?dNDNqdW1_zsnS8k{WLCy7v8Hdy?!gq_ zq9dbQ?)j5GW0%YE(J@X5BQ)>tUYoqOzNN*%Z;NY~z|@t)1bU426`9IQNw;AeMaD%&Hw-Wbc&H``!=l%3cjhdYLW z*;}Ai*@fi(yLrNE;WvLdWEC9Q&Z`5!ZS}7k*7JuMv-+>D_*YujK<>|OT=}n>CZGp- zKdDg7?q0PxXBBoZVDGlJQL7I3V6#|jW!t4r@AlsA^g~vM-N$#dKR-P)SQmbLWe4t$ zZg1g(_rGM{(cC+#FxAw3)l1l$dXm<2zyF}CzrRfCqZ&F=GZl7u03PMY-RiD`Re$Jz zrom;~3+Nw9=85d*{;A(m0=JI+EBO8Az=W%-ejxRL=_hI*>Wlyfx!3Bk-X88T+6`4z zc39=b7!09FxKGv}hxq%crs__fofqr;YKp(YTsU`LaZ^)MQ*ooBN^CmLzwbXd?u{-# zK0cbM2P73%I%HGOs2a&Aoi6(XVBy3LSnw)ThR2kR%hCGh*Wkd@FXGx$F#I_V`%hkj zR<+vG1r}X=qh3(lvmFGSNFSLJud>r7fk;cx`Ek%FF zzcTqT`i$Q`u+9slc{(cCu3v@-LS27&Vmdr-ck(0hyp`=_QxcXrV;E;QYret$O-vS1U1fHaX zdqVFh$p!=#$I z&3!wnukN&o<}9pMs(>0hCuMH=@y-)EQtNRyvzD^BOyLRfsyOL^X?`z#!tHB7q)E!e zZPEk7Z-mQH`qRRXqiZ-`0(hupd45p;xH~0CitBNro@&Jaq@3>)a8K=QZMC~5qP zAJ)0ip>E{VsGD@4f=N5VZM_Bif9}RuU1_NYB>ph&#u4YILr$qBOQ%W|%fy*U#0pxrBvK_!SI>buQ1S^tR!;s{<;oJxj<0hJsa?~5a)(Bk4* z0{x9nBd`>-wq#I4;FIKC+lDd@gB%5zf+citm}T?JPz0HR%8*aiL^r`7Ndn<16+CK4 zuF}=Hm`53kJUnporqG^Ib>={b5hdhhDic3YoTGR{71zYv0!(^t<*F1B1eYqzKTW{* zyjuQik-{#K0FiG$qmhGtl#g6l)gc&=I?d;x=YM;3XMtZHZvTth#U)O*0Bx*mQrCjM zQJd=?Qe+E}!tL#?PE0KI(YUJ@i zBUw9yhnitk)Fkk*f<*o$QNkx+yAK#_5v$Y(g>n)7pOm9)Cu;z>gqOdOeqY0#&r(sk z+P)a67~ez)XPs$Pf12EF)2_`4tcz@Z6ut+8(3i-448p64;%+D#7r`M%*?P^DG{hx! zEPP%*Qt_4nSaINwn+Y9Y#8?63Rh_-2uf~I~QsgsFu0HH3x-;HVty8Z1dL+N;2W{ts zAahnxr6a*4-DBw-i+=?lMcytLjnINJ}BQoU9smU%bp9-jcj#M}E*Tc^K= z5UmpJZCx|NY5#NskMtBzm}lwDVX(Q#k?+x97SqD zVm{5fDZNd7UQ0nmo$C56&f~^hKwE~696J2HW`{n9mWY-@0@>cP&W*1C2|Mk1?ZSKz zGthQ0!W!CNNtUm0WeZkh;iuBnz=WKU*qQu0AeU$iJZ`@C{6S_Nw zN28ict=LGIs0jF+uf0v=d&DzpAJ64ym5B&erNI9Ooj_v0Vp24vQX!V1Xt6x*LVsA) z!frN0x|XuZSZoCUt?eCV?d)*1mEpdmIg9D=&s*w|RbZ*OEw(GYNbyJQ9fqA~ky^kC zw+{YANsND`EPm7ygTg4gM+IvFrR(*jScIjD9#uFZC!0Y*Un&&~={_J~=vk2-CZ7rF z$+$>{c1cPKu-*6ogIv38agQEFTg|0`Z?f(a?2JH4cY2RJ`V9?QvB}@-?L$=u)ia&q ztc=Fycjs5vvkZS8j-VLB;mJtTE8F_&dI1&H3SUUKtZcxB1&@p7JiFmrGth0EeyQj1 zcTIv2ACh5;#iX^)+KuB@|G3foa@cO6P@pmB)6|+@ELgJU+`V(X2UozKw2oSho&xW` z1uttR;d|eDr>)}{JV=4Z@SlugMUBq-!Nw)55=!MaO6N4(tON9wgv1*ai?t^2Szv z7=Ye*V1A(I=M>XSxlS;3^~nlp^1w+@c|v$GJYZBgZV_aVxsW^gwX^$YS1bebyhg3Yy2;2&hdjW1(ORb zo<0WaXxU7H&-xA6@c`?W0~8850jID(a{m>V$mMz9zgv$~h3HM;CYyPcv#CYStc2C{ zrxbL=J6Wf%x8&w`UPh{1_f`&6DBV#EwkzJ`ZtKVq!gUOx0?34h}$=#d4*9lrRlkL@Tif zDi{&66PuFf@n^J%#kIa5e-1A`i+WyA=QVKH=!=>v1~~^sXdz@`UJ%Ag3VdnmdoXQu zT8Sn5_P~L${MJ4z3)vtTDv;R;<4eIX=y}37S1#v*@jNK;+p0~Gj2-14Yyc;CcUKfy zO}WX39;q9wjj))o8tg#1@mEeIC<0kr6EL8x923(L_h!P@4Q27%5t|}&RFW(ggijNG z3g)=;M;%Y2((IQ|PZ=JOio-|JWdu>`c?8X;2pc`+M~G!#)oW zqAQLB+Jg~lCcKBk z{IjGO3A4bb`)*K;4Q$Loes4Mx5+R<8@G$anm8`8(f4;dcV~fyC8_rSq@LZF4(u^-j z;`f_;eWDcOp-B=Dwn;AU&d_{{(pF$L%9%40!8fo(Ns2!40^ggD#&j-)#!{8U;DgQY zs^CXs-0FquDCPi~RbbsVj=EnOeYxCK`pHof1xZ4=LP-6=ufC>PXICpm@v6Y0$S9+j zD_>R1vphgWy@^ezWP7nF)mrE4Y-P1t*<3GZF^kB3mPUjo9}aNeE+8z%QHTOWkmO2AQTtM891+0rI&Y4r!= z+Dx@$Y&Z7=T=QMH?KE8DNWks=99;84!0rDO+)hJ)mEqgY`(xZmz!F{7-lt`fDqF^m zfO)r_EzwRSs94uE+}P~FceMNk+AwyqpnB&^^@Ju)S3G^Y;;my(hWt1x33HK#abdF* zf#DrPK3-xIg26p7ahG{-PYASXtnzzuH29>E{VGpNjJFgKSjM^++`eu)sc&M-e_VFY zPcN>)LV)7XXZglnbH8=)+n2+C{C;%Y?sWfo(mOpn|9bK5UwM`{2iDNO9gUrT-%X~j zH~Z5M!ukEfanF&SN5a z6h$vNCODSN-!UI>Y5$pwJAQ=mV9Wb;6GR{?4(aN(v8`k<;j|O^@M!}t-XqJaF{$VD z%6Rfw(3dz%2aCbs-AoRZdAL>%%?Wu~W|n0K=KE$mtEZ4VH-*Ug=zK8rF9Y}H+wm+6@mjD_IiC#Ro*T_t zOldfNKCM;J7O`S=N+WGR!!6g;NTh1#LXgj$r}yX|Jj95IU@J^B;Zi!uKWc|d||LbTm0{B%ib>L@?78pfKeA@ zs-jw}NS?UK!`e*?ao{pGbu{vkYmNopAt3UEkVMeOkre zI~MHOPrWV<+b?hA03|IZP=42uOSvEC8TM?&iy$1+1d2_{xy^ADV7Y!?*@6a|jn}Jer zip$V4B}jOt%*|pVON`xnIKc#B?rGM!$^wAVV0g}K9!gAD6nzQB7)uPKfZc|?W&6*v zo5!pbrih`5a!Cc$MYOpdR?b%Z-D-#2-kw?ZUTn>_ZtKB4Dl&r;ZyzN~tmqI$YO@ey z`#mq^Kt|xd2G=x0Wt+`^^0xaHG18shbow>CmS->Uj=DSXjt#jD_OU8qQ+qPSL_q&8 zpT*Y)y+U}w=w5%&D|pRyEcAP}fv>BC!FOhd#Im?kR_@t}y>#Xw7A`{v2_*_FxTv;^ zDn&6a)C2BzO}n~qACoYQOM%mcJ4fu9>Eeu(YC*9eS}v0BnLRZU@)rOA|NpFAOK-w3 z3_ioJsG^BSMM0?Sx*vehc7WRsqZ*l34GM!W?Xdm##jhlNuyWu=(;BoW%{Oi5U5+XvRD{WCf%TS#X$IQPmwNTlUx^ zA*^TP={Qa1i+%&|=VE_qWjvX@G;y8A^{+JQfv)HO)el<*PBwd#AY|phLT_w^AxuA` zi8im3-QH{}h!1Gm<~X>!A5BN;@V8$+nY$f2zH3Sl9N7@Xve&C%OsStbnYLigfa9T@ z-fet3lo(crYgG~ag=RF}B}MIgdOy^KP2Jg-2mO7GzzOI-<>pLILg-JJKd$IwzReB% znH_d9Cfp%^M8W;hyvMyT0{@jCId3cGCZwFZgWxxX0Hr*s+*D--Hk(mk50MA0B1jdg z!A&)Erq4Y1#LXW-@Ky;K^58InusDSgoFxD%xnvrAD`Tdgr*$B)zQ{0}O{V(8>hZdszX-UT5j0 zxXre24!xR-J-q88rxkmjd=}RU$@5v;8xi!&YI0Z%JT(-rWM!4^C%DS7S_17_ZWB;1 zt`m;iiFU4{7KKiba<_WRwsysq$@;>8urIs;uYUq9lSi`@CWLGyObm~WU?s%+HzP3x zSZ|s82|cX9QNAr8&SJ zD1n}Om}3OY3@v0s$`UJxHp9rk$iT|k2jU7~tQnaYBls`_lXF04M*{!=0RR7-9cype zFz_?{3ae~Yf|L~mTeCnb(Ly_<@lYs;3Rud3hG>+a1gcaM|9y97CnO;}v@bm3dpOql zd@tJ$k0F`Pcr{nxk#}k~tSEw@bsP0|hvtHKfG=;mM_de%1N@c3*j~BJYOM!$>sQ~U z1Iv4Y7a`JRh#7yIPZ=w%?Jx6NI#~;sGBOHYB}!SWZOVsaufPMq@|dx;WD@=wJLZI6 z>&vq6`+YEy+23@Ad*(Y(4u$|S^U+EXv=X7wnNF!p=sYuNZo6v(M?elAUnb$u)b8XM zFs56d+f+i;qudvN2_{{Te9#Avx_ovqh%j7U@NNzABUw1mQceb|A+aw3`JP@pN&ej_ z{wH~`---np>uW?)xaAaIm^5dw72iTrNJ<`Cw{&$xD&}4J<(s=Y(9282q<_FA*zdDv z7Y6At5Xqr5$SL1P*`bVSd(3;i2s%7PZXoW>ON12=_kq~1s5S&I_8gShHmn6g!*P6~ zH9)Q%a96Z8>aRwnZ$wv6U#-0fIE5a(jlBb8(D*KB?VqZ$M*<`rdUSw56L;MhKfo5J zSsv;QM*cpQpgKNI_3>N=M8?2))F~<$>WV2Q6;_h_{#CcHU58b#O6wnCPP~nGoqz>H z1L~_7#R#7PENgkRAg zYfr{qy;;$pje7H`rax5fYg-TTU=;8TXNy;llOG0Y{!_RfatlR1cEdU~6(qVpW5}Ke zMOwqqzb9@o0)rKm)uuM zx0m$+(Z=@K7u)gKzRR}!q&o+v+vzk;&Z0O?Lb6EsNhDDc#khFoFEM<9h1t<@YdpfA zREh-_p$p1TUx2u5&#LoWo@fqh=z+L~g*$bBVAsY?DWG+nrIs*F>{r*Ey?m4X2m4#{75xa{m3q zyJpSI0dOm3n^KRb-Cq9;W*5~4o01N8^%khx9M}-e5$^jbkA7}Wv<5Ja1>U>8Z#q-in8!{Vdz-0m*%`rU zNkLo)n7QMa-S5RG-XK-wxotnrCwZpDI5a%w40ytZhZEn7%|Kt8U{=g*T@oCgfye$l^*dMcLc+NNJ{gf$kw$8kI(*6o1i6_$o83I* zeuCUy4w3iqixQjrMF1 zJq37sGs94;3gYqZ27o9SGeOE!Uua!n z!4T7bpZ`FY9Pfbx;L6S{!1_n$nGCOzX-4TJHp<-+6#2qc8)XT`i~jO>(Da*vJ`MX-i(90JpdS=`OjeX*T@{QWch7U5uedWKvp-F(6 z4vcb;-_zQ$WlBrAKlFa3H#U-Ae*gdg|NpFAYj4^x6#Wdp0!@{=Wg^dRgh(4gtY|MZ zG}>t$pel+|f!dHL0oG{Sf1e-MiJdr)t$aen_PMqRx%TxrHx&=TE{OVAE4%>OM2AO( zC{0|(hytw}6Z1m;6G(H0GtK~vWs>SRP@wh*C;|{5vqWc7NQRRmvmO8>&c%eAyq}X? zB)PP27Y06hl)5;~=l~2uI}_6jcwSExa(c3QZ{C*X!7xUZjzV!2JB!_3Y!LVgUG)BuL}yO4IHrLhZt5zn zTKX$pq5NH^o+em-hS!lfV|>!q?J)m~VDjhXqFj>DZF9+HQY1=At;ypInw7nkVy(EkB2;93@g_re$_K!N7;O>oHahU!`A zyNw{FNCAPkVbHeyVzF<*MbiKgtTyXivA~=D>6_d$SdLKg$Nz|67W!Z|_Ce+?YMVe5 zo_r7o$4z4PQ}VM2z;t_A0?uHd8si{T)XdKt+n*>(gK6aOuhZ(}ucAwm9r7UGT624D zd$b%3*L*>VUN70fLsK45Y^F<_DZ|l7ac1*NZOiBbiiM!~YZ9Cw@{4hvO@xQT6s4HH z62VBaYm#w<$z2h~=3peIOD#x5oNFL#%c-t3O&AkwE#&#B*OeekMsQy`J*ur=j$1~U z7Ue0<=k1;_cO+_wsE=QVSCC&!48@s*yQBX|&z#VVdgN<<6<5g#9!8&*lOI_|znPfL zh-Nm2I4eq;P(A5gFY(+5H@=e*pjh|Nq=wZBN@U5dO@5Mbx1I z5ow@>wnRfy%PLffqH5zsQ%6fFX%*;8)=*$W{qOVn-LXT$DATkr(7L`m=W=!~zPrb4 zW-<2Y!OXdbujH=k!^M7fTprTheug?%izM1xDmLhotdxZ_nBN3<(cBU3=xP??8{)jk z8P}5CEluk?c_r)QpVZINgd5dMlIXK3Rd*&5`;+VMR(*Ws zL$JtADQgS+@GJ;YN+)2@wj@d|31F^9IwKR0M9(D)J4m({2qXk9B*u?NV#5Ajh1W*l z>;xtWvhR_!45&KmfU1M;s=(obA}!99lt(Rtug!TT>gNx+>-8Q1@*=(+o;QwD45j~b z_z-Bd$<4;`;du(>IG79{iUm#V11S(M7WlHTB4w`7H~GlQAs#tWwhmfpF$Kh5VMNikl9s>dA)_>l96;yntc= z7B7ckfCgBk7~Vq6h%~*NrqAEGHhb~vB_=;sC^0Fyk@1Wfn`t=+4ND2lB@w`ZX3Ci# z8Y`4_^4Hdu+TP*uDKFkToDec$ z_{+W>!%6(!RiN+7^zLWyFjTHQ^AIFHeKbFGF3{@q9?_p?$nJ{;GbQ@rS>nO$UM3We zXY@nbcyZ9-)mJ?(7G_IO-ndj*1{bJG%3{K40S!1_Xh31w$Y)@!eDOz0smyw}i|c=m zx?QDAhBd2=hBn&tZUsr*=K_e08|2i?a%u)SHC;|klEbAygI14&H_NdabC=o-Hw9{? z5*v!x+d+(7h;eJFf!Km8;BR4$4<~!eF$L;!^m$%!c+aI^- zr5ZqKC-(Ktjev^y3ub_??LRSu>CCjCLTlOz0!W=2VH~J4nbx$TQfkSIOQ0uEoH9K@ z-eFpFI}kg?h+r-r!;lF-=~Yg_5FW0JKur5rnJX#9eJuB1aJZY<|TAuZnX^7Ub#fp`DIO`a8dWU)I?wRiA*=)~196HKO$QxG6 zR=Q#LT9b$m-@vZIsTTi%Q1TY`<5y>!eu5166#}I1yd)#xIj^c6dK2!vQD39`6<=8p z#`5u(CP0&a5$+{a=Y)6!KCld;NFi@vJ_k?`5Hav)fSRJ=w-6&K^Z=Ef+pO;@w3As7 zga(062*@EoDu)KRA$?^8U99jlp&|TyDUI|)?v-~98ub(5clFSWAT@WlsKwhOd^R06MxD+In2 z+<;B9`IKl_B}vajxB>F)8X*yp9b>^MWlcP%zPHWP zVD9}j7YZQ_+yH-%feG5~K$e$@R&X`(Uyu})P@{vvfDb|C1Ov!WFKa5pA(A!=Q~=y>BMIni%+1#zrzdoXU7SCQ77!Mf6H=i?VnLsU_L>7#Eg_j|nHr;( zFKP>+HGtcaXQaQ9h+s&?Mwjzh$;o@tzQF;Avqa&Zg=qPdH8kGUIg_w&;sm(9=JDJqO~S*v(HH)A#4sa) z1>)mm+6%^i)7teuR`VNMCmz$hmYj+W=ait1T4p=>oj zvN2ic%Pb45Y%7pit=3i&tFLGx>&${z2wlCH`$2p-H?RFt3b4bpUyH6|&%A-q-JlhT zOWn|VHA8vpz!ijUAcW}VZ>OD(qA1Kx`&n(8$cKbYf#{`3d1wfeP{xE6p;&mPBWJ<5 zGw^_D+2MRXM$%m|a(2Y72p&CTh$vKKH0@7%H*2smcx@7R16sg zAancV`G{@owE0nkZZGHv!1emR8*vdSJZ6XWX94FqbdBspB!i)O(!vKJQe#92h^3?^ zoDu?JY3VS{c?u@+2v+~FTEL)*kqm`TV3rq@k^{^jd>E{`NK18vRp`Q`j{}S>cz*7< zqWhOoMvP$os0Cb#N!>h=1YW-8+UMcSFA~c4=L4jh)Q${ zb*x5uXvScGud9cK50)kTR1@wht35HD#fBkH$HzFQ3gU+pgpw~2phG>aaNkNR&Bsg2 zMCV}?99H55-QVlwL`kz-j2HZRnke{CDI6Ft62JbUi&`w3H97*ouz@SvcVR;o{UIN+ z4IO;@iQQR@{z@Q2{1bs0!hKLAN$9;8OkBbv$8{Iee-yA04F)K`+@wE~o=)lA-_)w_ zhHt#?4FpU9uaU}U&8sS#US$q`H1<}?AR8|1tABr#zPzd%mKt>4xRi+JL|@Xmtao*R zG2C`(^?=J4{(po1pAP#!A}!*HwXC27)a0hnGStN>sQpP~F=Lc|Bg&D;#Pl0M#j$}g zj&=JO2WMj$y9o&f8SjbWL>#k(L^ua>A`w=@pobNaVjB2x&j4ri;6oEe?vbNOp?1nK zrs9ckLa=YNlWS}+d~^%rh~|`3tW`7GDbK#ZnhThz67xzx2I*osmM{-%?0_@|dy=FD z00030|Lk4sSKGJ}@7L?U!W*EJ9Bkq=Jenmfue9Z~q$~k$?uR|##HRR?*jd{N zYLvzBNl=U5zX&igvuB^#M{W#?<-uTZ<_1Ii7!RNl`_s4U_v)<=8r>7B0dG%n%yVtf zRhu6#drY_bh%f`6{Ma3O=4b!Whg#g@*8zftjokRbPi@$jytjqlGec0%LMsF;4nyBh z9}##IRm^mfsBv9Cn3nhNk#-G~=PVWs{G(Pe@!jz5AbIo#HmAgD*|ILafFs!jt}~kz z=XvfU~haGcPop|1=N2_CnTrALKaVWLa$`_PC9%vy|1qgHJMDjV ztvS$*G$f;NW?`Nv(V(*~P_@9Ru`1+6_-|h{=J&4t)fHFZE~+xlmV77KV>_GBAE<~# z^RW6@6G$$bmom>+m15CGqxA0Wk$)6DHIMvxL|gnhi`ojSD2_a`{Eu9Zw!ugKrg?sT zObE5MHZ%8q_^ZFQBOf-E3(J6X-0b4lU>Jo93Sh6fs0>&%78OCeTNAj>@i+ASaS7MY zZtyS>Z0VO5^1VkIZB^=7jb``iynSJ*vYb3M*sGt6{dk!$1DEX*F555SvQxrk=S5t0 zOStU5h|69Hm%W#9xhP{3Kc5dNBe3w_yW=GCX5|PIG0(B=_FNIC+u)2N!=u>7Ud zYa$RPUIyFUd-vFw07n6C=r*nta-Ut2=%vq3!j!X6NDRX_JX-d zn=={AWT&hrMuvELOn>BO+%jCLD2!zJtt86@2U1jxxxS!bRcD+Q1?U!9#TdIq?<LmdGLatZ2l#KY zbP75l3;xI9>{&w2 zOSmPOu0v+ ze?d91x4an4Q$TunvD}rxjb&0&0gM%9ynoY)xYYudff1h1XOQvy{w>a>u|J5uhrxe* z&)!%!o%gTnoIdxWo7yzq)VrjqpMX~wKcmELaNwqMFF|vEA3fQG<6F1=%T>E`d1I`Y zO7wr6EXjLNdp=3Y^@>uMUz`Yi_q(A0D&h8WLwzK!;!xZ>^woTH@j$TBPrQnJHMzoe zr4<|0QlFGV%FXc<`vQO7+hnuBsp*kh6pmXP{hC>b#ovNQ z2#l^jM9`oOxz0L-dcN%iAoORw{$s1-$sB|#`;gEqG3vsv8BXIEb@PtOi}vU{xg zCUkbRad-uJu9f%6te&8vMKLoGmkkq%%kkM&IS)KRFXmB3Q7%f0M+YoFN8J+?ABnSA zl%6Y}++S4dC+6p_vlYIj-YhH~QVJVvCIY?YoBk|Th0PYzHWSVyjVFWDa}Efl%UOvv_4-{_ z*J37uu$+!{aGrF5%)3K6lTuebwEC+<6psOT)u#+n}a;WUV&a0Ie!8wNW;=jL>msHGF$)!$FM=V*Gu=dkPNkd=QZ zWwNl1bC-K^{T|1@=cc~UU)_*4`SVDa&_9Nu#1~~j9=D`mnZFveDbKDD-Kv2!5nuxw zb}LXO22M!`Pc>Xb{eKjeQ!V9fqb$;1e9 zK$^Y9oJA9I>f%7@rz!c?dD8$DD3TG#VIZXUFmgQ-%@Jr>cufPClkf;-2~>AXX6}2u zo(#nt$J>3Hj+E5V9>NCW z=ew31KKg%>qHWks@dP$HtFVG$4-I43t<0ou*fhuF zi)$n>#SrZs4#!9AYe;ulB>NCAFR-hRf-U-JKA0oK35Cs#0WS#N54!6C<9${&Ys~Iu z9Pn1X$610!4X5jm(Uf^e`ex|+p6?lQ8F(iI$_A-|(&8+{nIU(mnTe0tl4Qv+GQZQ7 znHelb8>&0X4^s{UeJf~UnI?W7O(N4I&!d^jG}9$CMh-`msB=#>n~dtTjUS?tpK26F zwii)9NGFnt3kgu>e3e2;(#b^K@xy2Bzt(z1&A|pW zWLay@thHKwg#US3CYXL82a&enN8{E1KY!V081w@#v>e;n-Xh}~x?u=pj~H){|Mz9U zUa_{jy-nZn(Y_mvnp1z}ICaS5)SPYSRn2+3yVH1O{;fJvZ`|MH^CtiR0RR7-U2SvH zKoI`UuZTzoWgw+h(2mv_jJDIUN~f**p|zM^4#ZHe8CxYj%KK+6B@8f=D5gnF zw22Wj*wPzgF^!^+2Bz9(uMURf$?Jl^Xq;QqV|t7$EMGuIkg{Ux)E)$pIZ6xLHOO&i zth5-JY6IK4NVp5f7UG#A%ti&oF=`(+RAzS+YoEv1H=L%^7^?!-c+bqVa{t;C`5K`> zAf2_|_da|)=XA>0~JBMy>?N|(Fr=%Cc>@>xluvyvgUf3L*w@*jYVb1T0_A`m!{#mAEQjtxM# zMWrdQXtuom)I$htuj_ZD^@0H5ld4Ve`0?ieq2C)=J>zJF>Wa41!Y_8ay4&ee-E)jQ zK5m|qIAetq>vJK>0H&;k5ga997t)t-Jkw;!q{Lcfo@SFUL)YY1rk+O&Ic%xN@R5taCh6mNs;P&eB(Zy8@yXdX;6kK%GI6%TzAt5G2_oK4wsHEn86rO+rZ+t*D zD(5;o&-ph`>&6=#pAUjy@S5-;pdPWGbr#fsCiEF5+*%M+t1rALt=R32TKQ5$e(6!r z-?_NF-2PJDD;1K^R=$wi$E#fcOj=60*Y0*!Wbtt6p4(ej?6TExX-Y}lAwC_zt^&=_ zxiTi&)|KDb-rBk=o2;9T!O2lTe3~cwl~PlKrWI&uEVZ#Z8lFcP z>aEX7vtF_Lfc9M5HmZv{8paD}yi%5t`xUELoyz5M?XddF^#G=eL^alfCH_uwjjZL_ zFVEP$H%B{RN5V+KaW}51;fvBERsMyG;!`a4#KBgv*lD}e&TXF-XYr!LR`8VQBH^@% zZYye)cYmu1y8{88N#oi?4LGQ|6W_GjfNxZ9%8pt?r+t%h$#Ac;N&eYL2E}Oj?3rBm z+8Y#Cn|;+!00030|IA%&Z__Xk{?4y3+N7ec&BV4!W1{ulp;L5bd=K8teCXqVzg3Hdd}mi&@?VAGmwYgfqG7#drKZ@ zhEri%R_gkgt*P=-&7DEUGVddd>u~Uq5Z!eAVK{g@ChLl$=(y5yN+}5(Os`}AW(qjj zU->Buu`Na5q4bl&6a7@WM`YNFY&yiVXN{KF89ZwPjpZwwydCj=aC!0Wgh32Y#@?O) zTNsv|aSY=MK_HkFNb%vY5H_PfLMA|PTEbVX+ylDts|)tDuieDAj>n-^Xinu-RIyg+CpDvX**4G;M>Yl?uuSV&cl6M zEER$d)1)|vauFQA5-<9?LDb9ToTwBo4{Z9wHm@er1+qtsK*n}U{hYA?SGm$V^=Vge z*JU!XL}Ln)vWquU=(^%rJ_ybC#^{%4>K$%zI6}D~go?QE26q%`P<2Ze=ZR5~^X3AT zC1E+tY~W)ZoE@YD_?hrJ!p9fUjGSdiPD4-;_&~oZOgxV6Lg$a(hrBD*<@FVo*x`J; z>PbhCW&{e}&t$+pS~z1#+VqegqH7;n)<5%ZNf2^hKkiz)zwhHex)A(%SEXrfgf`y} zao)t(g&lZ0XM@ZA(dfKmuLsavMz3S*vlVucFp8vszuzT4WVl zxH}o58^2`AHq^E|ELE?P))*3_(yVfRQiQQM^Tc~UUP>_-h}U;PFaPPknaOy58>JqU ze!h?(fXuu!%uh+bpf*lOZs;PjF!6CY3153LdmyC34vx_~>d`Y)@Prs^r6c*^Kr0h-g;vN_ zc=0e(wkjuW0!a)bs%)> zM69wzdTlTdw#2EZQz9AlGHfKJGX;;*xkpYbY%JEPBd;q2dBICjN$4XYDJGNA(YzE) z)@H?|va*uKR4K!uPwt`_QKC&B;CYe4l%A^4C|B0SV$3d$i8A!oNvIAeM&!9SPjDs z%7_qGg+>o1n}GwA0el26pqo0`U|ru}yy_WZy8a@A$)?^=n8G);b+7<3mAKVj7!c<8 z?6zi8s8I>FG>unvQxFj$;JRl|q}2N>_qo{;Hs@U|fp3K`xRBd|1CetV=P z5O6|Y=6K1EeK}EM+&#&018Dq)!k6GR?pK{MSB($Gm(duD^e-p)aSNa59_rn_qu?8s z6z|ld0~GI~t7S|jYzdTWmLFcu{@p|s-Tq|8Ayuitw-n#PHpu!b6+3GxwMaz8SRO{v zO3AHK-FnI!`>g~DsSt{EWFzgese3yIdtCn)00030{|ZuoS&R~dh`fnbj8Mx%NU=k= zfiTeZC7^AfpoJG`=OiHyYvm!v{!)PA$t8%xSIntuv}ryxIUM~@f|V4^1k5m6Qf;mTmRy2dc`iRet@$*ib`fl>r~&p&OP4Ot_g zN#u~7b`r)c1O7IQ6+w3>V+4m4sCx};jDWKxbmtK?=K%l!0RR8YT}@AeKoGtAD@Zxn z6s%1ZZ%x#z7jLE^tsx{OVw;F2ZQ_r2XLlC%69%Zp9_f}Y!|v?Nyf-s&IL(?sHV_>v zt$j^-5WF^-_aQ^$WXU5{!uCfEbW4jZj1V0~cx~bvA;4iGY!#xpzYV&{Kar;5L_t$W zP5nU)yy@+7`VD4|%X zHy%`n>os3p8nnR4zT%xUeVfa%7*#K1i=D=Ki!RY*T(lNPryjrAHW8XSa2jbQ`UGdY zi0>k-S~lr#vOD1-%TV_OaODSQQsWBs%+~WLNv#X9MTY9Lq@0?;(hb8Oy^Drb@6x`Q z4zLQ(?1rf1ufNm?PL>%V(l%mlnzX~<{=mi|DqZ@awUpN9=M+$U-@daa!1{; zHeTCJec+?)r_lb}Abi4c0rSqmq2+~`PmnqQ2mSkrFW(9-ixwDVkrNR=gURS)F4pHj zQ!dwwO8f0Uaa)B%c~e8c@`7wBmGCO$@%nn6s<3gQBFpid4O%QyFTc_OK@-*`36y=d z09i^%-^Ifm;OBPww<@i3muGJZH;4mcP{8{&1NKG*!5#|x6XJo7FHqb50hyqXp{4WS z*yx#{(@9W`ZAIQp528#Pwv{%RfTG)=d>KPJ(H_D(d@wHru+LRA4_fg-*B&-SOmB)x zo)95YxG=rx2LJ&7{{o#k06y0v6+FNNvgI?|Je;$&a}QIKC;oC&(OucSO5 z>bhL$1TD}s_^fU*Y#tES_%15VNi7ENRzb7F7WpP4@IeS9I0`aY*Psb5wMMHT=DHlGR9f<{PxqA8EGU-2C=E^OI#HNNz*+ut+{m1bbq50N0ug^ zoTujel`X&6s$w?cCoVmzFryo}1+}qOkjUza;5Jw(rVLY;?}98=YRNBKO|<2)Y=p6O zG5uN6no_FHENLz()m?pC_X&l`qqpN?Fc{qz!s#d*i$VmNB&Y{^hCN3nk43|ztqQ~z z0<`F~wdqzZ9wek5ucv-evY_tSDx2V`myyAv2K|%yrM9jhkM*?zVvp^oCV0NXKR1ey zKVS18YVhrtyVZxC99%{2VaJ@%Vc|V*GMeL4?N;Qrld_C0>X=hzH;wWGdif&qK<5c} zA=hKLi!pw+hvcvJ0=BRAdRi&@PG<;7Lxyk@TYY-0G7&p5v7fQ)C7mN4dSc><)!|)# zHW=tbOscnLwzl_GuHrnGKC%dul~h~f$w zof@>2t*Tli7u`oK&}_USrss2|7LEAYeO^JL=2Ld!tPZrQykuKFCsWNL$wJ5xK%k0W z{dY0*p@A)Wo?pZBj<+sy*LmB%w6{yPZC6Ue0wnHt=a6(cRuR9S^UHB0+PC!ObE#Co zzjOH**W9&1Ll?GJ6)?=DiEt=>v8`gUa2@0pY5PIG`qK<0(3r+$qyT?FfWNbjy?aIm z=|*9YPim43*%{5oRlV7)HFN^_c3tyZ-TY74e0_!S>a|k0KfdbUUD=fy@M0u5gAZCl zY%egzFosTAY3PyX-@3EK@HPTxU|~3RE+4jn9P(%@S5p<{h22qXv1=okW4UfF1Ov$B z`46Uy2Z+Tfy%~}QjRu>GM*fa)iZo-4EK`Km05(?C01HbUX*Yzgq!D{zc+g`eYm&hj z$tB)|sK_MRS+HUtY`Hvu`rQmZL2oq0vfM1t`zUnWe8C1Xfl;8_oN(?qs4bu;M_Kf_ zaPCK*Z*2(e3=5gw{;;f{ZXI$kUNYVrBG8aKg<9RDX2QP2LavlxDv4iWZHOSvnDoGyA}P%fIIzBBdc%=bAy@op)c#(1$2-|LN#F)}Jp zcb685w-|2Lm4VxckBEq=9D**BT8UK+YjmSLI51+Ll?JE~;XL&ykbJNhBQO$f?tD7x zd^kDli2Cul_*8GT>c^e)Hwre4XL5pSn#{)-B?OglyHkG!;s6F84_l27KvDnmsCm>m z$MU~B>Kq@o+v43xOVq__z12BtoHgq$aeCG|J!v0e*s$Zs*=K_=2lP2GVA=7zqp`T(A?a`v^MDC#;>=U;3R)Vy%1hHV+R!Q z=$%Xh4`evP)m_(xx4mJ_Fcw~S=+ts&_}{+Bm&L`&Y3JzVxP6HSiCi>JK7OnpA6&wR zZ63Di(fYGX!=Rx6WWmph@$rD+{xEO&SfGc1$`Rnu_4_mThGUV8B(a0eJTGC~05pVY z>DHf&ucn}llXFsF$czebFlI#Af>;0IM(pEi}71j zbHg~9OE@{9A|=;<6o|v^o>KT=uh6$bNLL~Rh6ji3PMnYf1y{6brpbu_Y;BX zpq26bBk(bUB~Ipx_$On#id%@gGBFA+-a=+LCSZtO5l5aSSX<~99u7eS_9El9Oj8Z! zv7bBzNxjvvsRQ97-gc}~gs?KgF<1@ASR0B#oCbEF411-j7>MpcO_KsTq2r9ZePtdb zi(FzWAigauIw%8Eq zd@j|K_rdr$Y;;aq=eQ0PgDFpbIfb!0;r+m$C(@<^IZxLL zBb_HVLS)DIp}d-0*dX@|sV~SN2(sb{v|V8`7D0ia(+zzdeOy|}Agou30_qqX+Yp=p zHpX*|WKW0e&pe3~0;#_`&YYDT1`06v(M6koO3Jj-CYRJOsuqIHkiOaN!KA`oI-m{AlBXrC zTfj`~zB@m-p7Fu$pGjdCq#!5S6w;Jxb3-sTG=wB7d&k_f$E=5VZdiTPlMNQek0vqXHK@DulRr>KFzS&&CgvThdIG0cbe9|`o z74V;Rg%+Vm!6-1KzWx^eFjZpB>S!Y%u{=hD(gh6TXKPrr%-F)i2*(8Q&+zUGSL%E) z3I|ARrb|)SJT`}Z)^ZD_yiaU!GFj&lj_DY$NJlrKVRSEY*Am|L1s!(z2E$x$3c?OE zvT+x}cSXT2SE}&uWkD2#C|pAtJO78BLx$e%XyB8Z+VU22I`zva%pOx!vJ+wKOCo?LDBgOL(^1nyD>aZPdCq>^@^>scx2E`$x{ZwF zd6xkNAIOm45DXS$E)O3Ya?$)hP%z0pl&pk*r*a~zCzlj$;ancBKuE2Q&4H&EoI7ve zq^o^J-71b#1)X&Rp)#Q3w2}F&7PyBfo7}mdBlI&|sm+OfQMmY0yWFX9gmw^=oy;$h zTfuuU36}^jwspB`TnZR}_gc|Ni>_(-n_oiLf+v3vnJ9=; zoP){OyW1p-vXh^}~k4Jj5T=ShbLV~zGxUmm$Ue7na9R)`o z7z;J_*?LkXJjb|(QlWK{D5$b^LON4vim;`>@NmN*W~n)YB&-SwIy)JK^mO~IbbVFk zlrC_?B=Jz*(EVjDjMY~>O#g6Y!bsB}4=^oAE?%zVe_9LmfE5^&XPQI2HC7c{uHsI+ zDG=$+H+$Hn>3LG50RELc#LsCWFEj-2a43kRqiRER`72fnYEjL02bXgcbpt;j`q4IVGu(h){qShSP2U00030 z|Lk4qa}(JS&sWc1F*Qt;Y{eR3nSXAj18ncK*w-LYc|#4EQFo^QX+ zoWo1pfoN4)t0}tsij4EZt^udv&~eF7c@-F3NXs2y1^4TMRa^UIC*-493TcV4K^7G zm)s@{>#Dh( zG^y9%B*$|kfuR4!Fd$t#?}%iusEjmP1M{^~xf9CFCk8X8Th)bNYrL%dj)PvHZZYd_x6Pt@Rkj6DHS zRrcdOhHH;L-7$0!|D?a=`|(|1wGuZfI1DL&PtrWI$Kn^1ys5D>`D-5*<*~Mgp4Taunx{5mDu-+XIi4x1J^Gt*( zs7Ug!!_7bCr&<#WX+r}{mrT&JF8!!;bVK~?X)dy1G4|K19~V7?9@Q>`HvD?D zV-IN-(aol^{p#hb`dPKk4$;MGli>(FYI)UqQuV4Wq$uk9I}jC%Ol)wvj$FK$qC5`3 zExrg`Bu_Jz9Mo4k4{KB;f1kZi{Z)5Rjf;y{1ZEL3uQ^khzq;PiHm+aV@5QXLRa{7j zgQvDU4)ph<&DSfm7V<8~nk3@mz;~{c?u$$Myu?D=Mucc8@5tt>-rjzlC z#hVd};pS|>xL(kZGGhBpX|lbB%s*1i)1n5frgW|it7k2>Qk)iWuyA@&Ata0^Lnn_K z5lD}fT*lKGHO{JydR-|%#VA81J_$5|YLE__wK%5lJ{5SUX$v4Ra7%-EP#ztRZP|fK z4Ab_=1v!rgV$WUzW5GHIZGzwK7!`f?#BWT;;zP9v)6gnFN)O~9Xdb%xD21(nk!4Q> zHf71*KuU0l58JnIFfVn{r**B=)Cs*jDwX7q?`gxA8v+7Bn40i#(53SR7SX1M$)py(3`DpArd_xlQr)6ghic0&xkq(Eg_|}? zZ8O$Gheju!-n7-W*sT~US;ov*coK~9+$ri#bEn4}w?%En56$8gHR0`ldzx?-ZeWfI zqmz>T*8$n{jE#!sOfhofhN~DYa0xl7QVa6+Ww?Ka{L3Ls@JSV+*GCmD&R6D!ruZvj0!CzpDEsKKhNRuFOk({5r(}-edlE5A1U`-}kB@w9_3j>r z*Ul|Rqmgo6IwCISR>TB}pLAdz8suF0$~aWB%gIEB3Uo{1pq+I&iM+PP1c5+G;ZTxI zrm8FkCTf;)&?G^=+n@F=vkV2yoPRNIOI{RCuBohKgkwg##ZjQtMr+8fleWaqJU!28 zC}7ZBxeJeRtSA+*iAUuoaN-$3;(vzwv?`w1?|e2Gl+@38%F(HYL!_-xTL>R+;TYBV zSd;%Yzw|!(E>Lp7ISt&^5xzO{{P@}7@xjyZ<-zgc?@u2bo#59Xctnt<#X4;+d@i)e z&@j(I27+n4FKO0@bP%-1W6dQr&26qDvBYWW_zwC4ilR|%FDc%W=xi76N)Y!M^*G9% zxgg=+jd;6V@bF*9sXtTz`S&_39RS4Q-mgy6+v@l{#WovSLV$Tb4}upqNs?I`I?+tU zT{+FfQBQrorddaj^0cW>5NRzC*FuoVo8TsfhpL(qc>}$Act0y zr9mBrn))TDA}Pvc3G0OEs=~41va6tYrI%RSS(;_xA6(nuUrGiNC_zkF22Y8j zU9}0e8ZugfAW)IhCJnbn&GUx}qkll3E9~Rny&Mb?f`QpVhB$-fCJQSO0&!?PpI(|Y zswb`fo4BJU@Q;I`6QY%TIkF2J7$EumJ8P{I{ zeDykQEcUDajXzhK=jrbbR=V z1yv4yvDqKeZik4Gyp=&_Z)X#gE_EtfMhNKU8VV95;h$95v12MC3<=^?J+|^?!4sGW zy802cV>4wVhI+9n4wvc;-;O)+5P=A^>{JMy9c>XM^|prq4~~zY9XALEsB*=L9lYCE zhuMWbSJAt8m&0VgvxD(MYI_fXSmgn@2Ax~t5}!y61Txwtt(PMnKPe+;ax8Y>vS-a> z$BoSjItEB!unAyacF4tE%&6gEjTM%V@6OBDb_;dctEL&BJbU)UHB&)5_D7*tOJ`RS z$;7oH<>X?P&8-fWz>J0;PH|39-jl3^jiL6(EJzgNu<*{zvV{>yHf@+v+Tn;cT6~5x zpu<^Rr57in7@DvefPs@n=K0%cK!^LI$47?^WpA{eF^QnGyxyUj-*1+9zH&N{pi8LZx4<)p;Xv{Qo(8!!qRlac2hQV1xe5Y@pHsX3;Sewj7baDte zk7wx3LX&&~rV32N>7xg6o!~*Blm}u4V4v0tV39%t=4 z(TcHjVIhG{+`Cr|fshL5K_l?uCJaZ=3=M}paqGL7j#+DNbqo^qrqCZW{J5DfL-Z7? zKF3&#Yg&F_CGl$H@6ZL*NnNpuWIjMZZJ2~Fbh!gW3}2B z7j)D~3V7#l$MOsdX(@I_<^Cduk>k&k6AB_uKgj z{dW9*3EwvCR-`ysxLl)kOv^mDUwjBGuap%kRS+#^L55wk7;{9x=U8aQZg$UOD(J1E zf`>GQn-~pVQV86RbPZ!g*I1V)qltCosgtx)!&@Eh;>eU)5;ip z)t1dy;WvDZX8}8mdixvjoBsd+0RR6g0XhQOoCdRjwyGnhB|!0&4{pZ6Lj+plz;4G< zNCZbbY~VQ&G|^rHo8X5eI`GgCFs=(qi!$>|k*+gL2DQf_ZBFpvEJ>-*1B>&DK@*^P z$>7ZE0tBvEBTC+Z;wg@G4ofEG9C<|}~a{RS!rRH5Yn*dQBd zh7xpdR|)K1AJCFpG^aZhr3D%kC;?$1= z00030|3WrjzZz6LV>JOJQ2-(exj2EPt_sBd1ngb`mS*6UDBu_bFRB0^m;xEw*8rw! z{WNes04B!de9)27pw4m{{9Fn`!49z-X|1^)X!XA}kdBVii`7yAtvd%Bh@9z_QO=%1 zAA^L?x&r_J0RR8&UHenpND}^e^;b+B*V-a}0ts6-Ucx3O;flu<tKY@Fz?oM>t5byuXV@8`1eCJr7DR7&!neALR@#AQ zDcFhF;i@ph(Omb%GV{^qNJVh!$H}l~&IdGPwq$Dqv?f7(N2h&Ul$H`o>9hvjofk*6 z{DO-_lHnHz_iOU*2K&Pq9ApPA7>MjAcrGp9Q6-U<6Ilr4|GT;Bk!DCA*nJjMC)KJ- zLei7CM59UHHllk4#dwlowVc*rcxr4iHLx?DZaPk^yST&nuRS~ad9UG>sUIKBb za!Rj3qE4C@fO4bH@P&it-?V#q9uECL%<*h_m{V}f!M4R8$}}NH_MR`)$e`W-mPW>C zhB{$<2kp(*yKR*K68t_?pP8e=zoCP4ZWke=JkAtHb<% z>Un3T8)h=r5{L?RYupsigGeWqlMC#m`roOGn5s!+(ygH~YuUsU^yni0`0p$D|DOZg zHwenZep$F(86MAH$N#^+T3cC7;lDqBv08uh|Nln#@5s;!JucB--;@E>@R~g>gd&bl zBmrj*a>mpZ*LV7(nX7O@lQZvPsE)i+#5`%4y?^ZN%oR0ebF6as@vIBTKlnO>jEYx> z)I~K^U-(Q^xdy_@%475i4|toB>BJv;`~?*TSu!v`#CWBwS#V+mp7yAF5+rCCV}`>wp6D!`?TMth68_(_ zmUR}KIaGjn+92ti%|qiBOEfqSQjYHlyNa7-#~B80{dICo6S@yxg1Il*j|jp^$f-i) zGV5PeGEw=zFm~c|kq?c(QshHv0fFCsB65+RU!@g_eBoBX#%1_$!%jTh3oHX1wB4U%n(pbfii;5XG=)B0qB8@l7(+%y@{gvtYF zrO|jb>2*ORv|A(nSY_;mRXCwnQK0Iy_g))8?;sN534rr>Vh-QE#u`WN%$!HohyGFD zKw^$xp~H0H*ljn|6^gxwxV!`m&wA<`+A#SiopBD8@*8ydZJBx#vBtsqv0;QtQ_KsV z2o1BChcI}A?$Suj%cG_|&mX=cIeC{JB}$l9i)iVFS<)Uh_^M^JH0~$Thhk zTsukJdD}9(FaCmQzRP{Fq9ZZp)=A*!WjDzPJx#}^F`%ZSJO+%l!p`T)rf_~OtHRM_ z02o#ys~7|3k`qmW-rc)G$Dq;^jP#O|!Qa5NkSYxRx~QyxF+sNvk3>Pm?L~(28?VmqwGQ2%*7>=?=^r*~*(s!Z8aZw@Gk}YAMu9z!?`h8y$qw%H;GYNR{~}O+4l9u$1D>ZE zDgxPD_v=WYbLmZ;-q6|R2lR899m7<&;Psdrvx0=P@Pm{;Y2`hsd!27sFt}(OHpD=QK%>t1r4& z0c$^EeeA{Q6`HfykS{k6-n=*Ks!zb~D<=4oRYNdMu&vWb-I8`SUZrRqCRn0hC$wz~ zH-(a{g=ImEfIG#?%&NtW29~{EU!=)9XUr$eD zsk};Wo@Z6g)9GenoPGx><%!(`(u?c3GZ1S?DE7mLhSCHU|W0A`Nr|kVIoj z3s6b5kQm4(6V9rp6IQFeto87gX{^z_N6SbebmB*2ah=m`aYJ`}i$(9KSHw-Jg1c}8 zt}|q*6m6?#$y>~kG80HJ2e538A^B^d_Pl~1ky))Ji#PbxL?V9j-~8r?f89m`2~^-D z=FDFRjjdL3Qg4#iE2m^ z+$_Oac1c}ARWs1-A-yQl2guRBbj+UXntq|a`+4p4wiIr6CBb#E7meXcn~d3xwf{p z23)s5MnlA7NBiQ&*e0Qv+g*E zZ)LRIKX(0Lui|W52OM0!dRB!AZR11|LqQ9a15?Rq5bWgmBfN8bPGw~-CK4`B2kd9O z6}2OWisNpC^Vx^8hvmcwo=wi4nB=J6V|Gj)ocmqzAF4Q#xZIl7-X~0JPvKKUo1z?c zkApJyOv8+aK3?3{=$2`9OKG%osbbl7Hv_v{gZ|r1mtVBLWtiUzvHk7Q0QY}x|MNrm zh*pBruaEz=wz5*Mt;YCY^%ubZTB$$ce|;PKpQ`dh>t&`(KUxh=Szd{@f`q}-eu0mM zYnCg^l^64R`ZsiSC%V4d4SydF&O9Q_>jQekVf)=-Wi$*c#IzMx>$6y3KP(`E)&CF? zjPpvfVe9j7U^ehKh2a&5*~EI-;jRv&ho-s`IPgH6Lj{*)Z=V{o2Aih%z`>q_nh&wu zIBK!kks1D9gBg3cvF+)ffxU8`D)7}kV6SMdXdBNUpW93nfh2oS_ua%YEW%vHjYpFV z$fiG!cJ&_s00960#9hk{f-n%g`xPW!!BCAKfDecV#7I0CZ$wmLV+|0#-_9=O5en@XQtl<@F(bqtQ9Uf8t6z}Z_`mlz&ktGIyD{FIy#(p`=A3w@*hBZroAdj z8;Wfc3x`n3`&*JYH7roCOC@;3#hEHHzPeZ$2CNa0Fn%eBmhdU{8ONpmT+hwVZhAGo zR4TWvl`2XM2tCW43*kCqfoOP&y&2a@43oi>=nA~c+;j<}&DQab0Wmh!6vY*4B!1>E zN$t0G2#0b2Ouk@xBE5xqm2oKrp#wr)xRJFl>I^Yu+?(|oCtFAK`|3g3bRwN=r>FDFvOafoV=sVlgmP zp?U!8G!o1#P{ZFA6ubztK-nC$k`bZ1Z{STA$eCPoHl?0m)lt1%`?y=&V#nUn-8uL9C+8ZVoPvs!La2D z53emb_bOGQ2?#n*q#dMy!Svlcae0(j)8|^O1598LbF|R3^BYG``DnT|;Je(lS#^9j zB=l_Yv_>%dZw`{@dV|;+*H>=G!_hQh_*B%gqvtJW^2Mft|~=u7}POfkcsbeXB=Lv#bmSx#i7 z21`

N$(Psy=cZmL_4-S!Gr`QL%w5^T@DkD{CTT)xD$^)W${CfHmFuuuB7&shkH{ z#mXV>!I-mF+?foQ=yehyFv`uH3OnO}XGu2E+2+npB|U8?NqO!rP?8Md_*H>88q?yF zBO)-aU7`Ci;> zu`|eb{x@3fpBsF9%-hDoWxgZHN07%48{A?<_@M;@~(*{ppH66e_Sy7!VcaE`CN-U%WNSA|>ez zG+@Q&mWFDBP_X~$sZ#1BI`8mcBykoc3981}y%>`uf{_g>4wso%aTL0oE3c+@8!E1> z^P3TvwnP}5sK3@iHYKb_1`B}3eS=>c#{PSPWJgzNe6ic`Cd&+Z0U5h8%0r}~*kse_ zi-`m;rS9jZXCx*eZhgaHh1Oh)IjO)yp|TP_pY zT6(gz^h8Uy6lzIA3n2_9Q@>tlPA@uZhXKf`$vA6uFDVD{WlYxJl>W7D>}4+u*qmO| zX}d+QqZPf!oggnQ@>^33wh|I?Q}0HcuB*$C7X|uC@B~AsaF?-P?0x^bw-<20xz1#E zy=l_IS9$4G9McR7|B&QK)J?7~X+cY}*G>7ZFZ}YEy|0O{T#&L=A)1!324(@f>`xel z)(e}w>a5!j4-a=Nro+Rnm`JAkIiAmvi%AZVPI*;BOms3)ISVW97i@<1?4G3TE0}Q6 z1`{m8SBV)*b2z(&PEZG2&2&c7ev!2?HlOn*`c3QxlY_ns=^R6#yGh-? z{LG1o7EjZghsA8lyLUeMaNEfK{eJ@h0RR82U29Vt$rb%<{ffz0Wf@ivyxC-{&|Ep@}pg0VmZv+dLlB$im9wlEZSIFw?)%9wX_thT0bC2 zY84UlscKJ1*l$;9?6h26s^Td!czXEls%3t1Fs`hOMk%5<)vJvptdOkEkXX{X1W-4o zGo;9dwMjPV#my4lFi!p)ak+%nEuah&iy--Z`*&@TRos^!zH25-3L*sWMg&P-h&x<$ zZ60>?$>-?}Y;}2(=GUon)JZNDvl&s=x!Gx0#N*z{$DiXA#h$qPbjH6f)SvHF@=^%E zmIjnt!!QVuh<(ort(loMrWP(wg=C z2!%rcLpR|1FD4d~7M9d`WOX~2BQ(*om?aGWA@gpUXz;KvU1y)C7yR8(V@BM*9F4Op zxaYZwc3YDz!qzScu1vDr?x+DcQ{Axp#3@VbZd7T_S6NA8BCtmI5Z(d?(Upnz!FIy}uP#RZ59uxpn#1mcVz#+UF2$MZ{8s zs24#gCi<$Y#l!fj+V`)dsu$?+xo877wWI)YSY208ApL+J9>P?7>&V^e9)Z9t&hz;slDo1TLg{koV!fds>zlgQ+^8Gr)RRwRcrySUCk=ta`fN?-w(dI27; z+4StW9ZVNO1zM=kJAmZvnw1VAX|B>nBq3@x4i@jRt4PUVUY_>Tx-n;Ft0PkWD`ZH< za44(f>V%?zf|l#?{Xm0e!%Lx_6B@gN0cW$gFd6W^q)~6sKos6zZ?UOON>Rny zo=p*);ch&9&mpxOjSx{ouV}3h&5=+qllgLruX!`Mbr>12wTG@T#X1T9B@72BTX5%b z6*!hL(f-Ro(TeM1yLO)MHjHV=|KH<-e*8f{>eqqPDq2~?)OAktT(@&=kAGCV6?w;zkKS@ADda=X zCI;WV%pg7B2~JY|osmBzU57L$MAY~ameU|wL* zFj4?Mp5&jX(ojN}c?44QJxmf2t5N|@ly4PUJQ1mXK}FwnlT}^4q3YYI$}D`@T^4*p zkFky2YrIB5_>%35dmg$I%^Oi}e2={u%HhE5F~xvXF1+ws279YcoG#aqP1Pd%#zqtH z=GZGU*6o-m+mwcAjvA^cgi~-abex-rR@p@T%Un>_+^mUb(WHdgsa&7t=k3m+z+j`rNSPj@!BBN@LZt zt86q`pXtkNp56XG=DX>y2<_P7n*I2qH3_>jlTVWeg;EF3CmdM&*%U(Nq@hxwnA$S)joy3Jh?{Hk^rK{QYGAeux)PE^Pof3>)nMbrxwJn zg2W8+B9vDOsGuw>^yb~+{!hmr4*%YQ2+3R)pM}IgD6t)K_4+=I?|Z(Do)zsZT9f|N zgRB2;Z9Nag+M5(QRZ*@-3@b(4Z`yUru?Hyos1idMB6l8u2Qt0cB9G~}8U;l0wN?Yd zxT+i#0}|zo=L%08u8)Okv6b`kRJFIl#<8<@CfNy#llm z(KypUKWJssJEkg8&@aUOu;!6_#M$MAR<7r4NDIKIPLovJE(<~RVZ_s4Sj=y~8bx+;P6-?`u+uksB>ltA)9A7cLYinMLs0R#rIE~Tb+~u%=EM5{MVWC&#H91FDfyzWwsuySom$}n z)~|hUG0yUv-9G>8`$GJh?CkvbVNsQ$MAT7fe z)LZ}HDi6Ps4F*6Re_pgD4lEriO`j)5g)DB&Cv$3y>BH3k2IOZIFZUJ`oq+XQm{%pa zp=4)F`$?3yrnsRtv_S>Jz8u6Ni)p&~{V=}g!jQuvCJYUV4Dp1>ZyKvffYZ81m)vs9kI7SPk<*l9Xgm^&>b2ApEm-?rWxAZuK@!}K%5jjWyHBZ`C5{R< zB;y3{3GFiz4D}6!7sAGQN?ZQi>nM^V1_-bG1R~4JBe3Xd#*<_#5n5?9?eBt7)Z2zY zjG~-LGyQ=Alw@QNm|~9=rm=8;f}6mwB8imSTeQe~G2r`)2a}0@5=gEll?ggTpOi$s zIpjjO|BI2ATX*u(vU@nD%F58Q_>*I`qYu!;6-g4rd;zymOrcTnxI-sjRBkJLy;bxp`F{56d&ZY?%3|JU*NI zdy0YKs!?^6Du`xpW6kT#YQ^XX+vx~o&1fEG0poo%&SwuUh||ng9x#XwJuh!|^w?ik zQODtIytF=xJJs4JNIH7Q$iV@&KqlXD9%980z85p_+ zoX=6Wg_W1t1ef@7i(W|70k1QCCYUvPSY%{0{3Md0#Qn%THz~GXz8EY+boDwmru zGwpCMfOw4!3fROS-W$;}UlOA+jMSrNJY8rEW#`3U^+Bd32ZaAcMY5tBuQQ?7b@vj9TzV%OIh$w8$vGZB@bbWU!*ZyR&Ua$!5jJa3 zvLwligQHGaUo1{VN7GlF%H_MXgHdOiRNkIi%e(we{l#lTP#8Q1`aiHZ>GaDvw{+;c z>1$Qnq3lu;G!D-7(wGx|2nEodKk(YxkmWYn@!A)!vfT`T!!xMNuE88Aj)NLq)@Ic5 zRn5b|no-M`L#wFp*z0|)>PUPRp#1lUBkw7$v>XL@D6Z3$!AxYc!c)Tq*{AAQx;uX* z#;I#cF3ovNGqB4hpV5q+`7Ib&Z8oHuF~AaZPU+5%M8>aF%S+P^yCVa?Qv#!b8i_kG zlyRdx3Ze~^|`diN5TeOJ;Tlz=LBTYdN4b~J>536&AAH4y{xKumK< z1_85m-`p4dln=h*LVw%M{u)bEnLV>>UxviCV4lYt6;(ZGgMtPr zEKZ_~GHBI7Q2U@QQR!aGKQf=V0gEdrV7GpWr1?tXdKJ>o~d zjC&E^7jJFxO{R7|)Gj}TIF$)HYGs1!g8QutzD&Tb>$U9XY9{j!{F(=i=sK*km*Pp+nJQ43y$|Szw%NOCpZEzc~dT_v?6IW%tsK}JS z!8S|<+)Tyh0OXL%U#tGY+~)$SGVE`apTHMD*!6qX5*`&WjM^)%)abn0)>x)7cf6L$ zk)TV#O~Voz{dIeI?Z`1JW~%f83YDJB6nnnZsE^YEw0zZEm7ern9iA6XvRNWR&RkF* zG)%zg0$uJV-otoSg_q@c*ev@-7*4og>=zFFb}X9Q&+oEjpD1eohL+78f4jZ=>X^Sw zX7kC!&KPZF#@W?j$q0tJqnsmbhXA8MT)()^HDexfcm`Tr_+g=S{4MCP#>R68d7!&8 z3hYR%^2a^hsqgdMN4CF7glagJLB7esqro50_BqrSzKwrDCz8@YogX)f2oKx4RW8Bo zJC3e3`gn05Z?_&K%moKSR=*+9i@<_XU}|q(60bg4l!BHjyqS0hb-4aA(UZKCk1DQN@PyVDnmU`C(tq~n6IB7?l%JlC-+UOe z%D@2SAZ`h9eMBM}8}hSBUR~3~wj9_HUNK&rSce5cb)COE|DeYy2Q-*3pl{LP9r#6f z(6+Q~)hS`Zh6DqeJht+e8I;0m4f6}*Ad&!fblODrW*kIr1ia(r|KBi`Wd-y4XOEVi zs=Yz`-G|KWjkvaj4*a5ZWFI-4Wuf5){IABdxut%o)T&x9A2r&c&@=$+ic0IOHoYG0 zU)*jZh5o%oar~BP@5mE%+`HBpA_4Vb35**iZiUDiP83Ej}(IFLSiH;;?!)$G$6Sae;#WmO*L?WL_lvu!( z+<>j)fQvzkO`#-{e3fLf3NH}8>W1H`s{gpiX^AJU<^|!Y|P=lUc|@oSMkfJ1%F#n zO{dc`3$15K=A%&3@oyv|nHjZ5^18`0vl^ zV}Kg|NA@#lZ>6t6rg5>ky2?Hcce%*)2b9Cp-|c%IS>y05Ut(356%^zgFFMV|?1Zyu zSZoFs%0#2sFh81!2@xHHc8x{UmiT-UQ&)q5^H_?R(Jhg@+f|nOz?p1|0=1NRVOAT` zu*iIn$+)=-=3Zik4g01tASio4_ka#U{|AX?gXi}x-|KecE+(tn2=&=|xUIXO?~Xe3 zUScq}U&1Q&{;yPIajk{=j_S4f{d_8dcjKSF=WZXEZJj=x3LctbpXqW;Dwy9gx(M6q zQxZfn$^);7X`dY$x<`EW{_Wdu-hKD?f!Nux{|0Q z0(j`R_uk#{NXoLEv6F4dq-dH)@{aGlGb9Ii6&LmTafF+mwxM(BA0%G{x0H~CU@j>T(qoA@?LZL z+ZE)9X~1{2fM+=RpPMa+rqgav)k1bs>j8_$AX{kFbhG>wnn??@u)m0{v{vVn?y4sE zZ`0wn3h)%Bib4+az?dA%CiAv&epi=G$T}2S5#FZUo=Ier)PpmzqU9n(>M3T?zO3v1&)#>s@8yl? z;WjEYh=ptCF^Uaq_u85C%&PKOC<|>@)wG&0OY>QPg~RY~hu%|Lb99T#G1~L+&M6U@ zt}OM^=@l1x#>)GiI;lo)oYofIxDRw?>ng=l3z{GCHjGq%s38lc~(e#c@2go-_LzlD-UUVx3Mx5OiJ zDblZsx?)Pw{Wc3an7Rwgbh+TD#2U$&oo_XRImv5JOz_d!~5eb6>+Ha~vD@ zhmA5bn~Z(gCnp~4e`o@sKfhm@rlaYDHT^Ai*! zy_WP4*y8A~=%K2eB1W!0Z?@Ip=k1^&HAMiW<7H;w49e;4x08)PVN75xYlZTH*T@6` zPOD%>E$#MbZ4|jVTOKWg0H`?hqml!+(b|%^NJTY2DERmv00030|Lk2`Q`|-ten!7S zmd7iGFyl>9`>^pkE`mvlgj)@G?Jb6Y7zvOqMw8LtzVK!Xg#Q-|>hP7~@{FX7qCQ)wv}t`VJZ+7;^<4;I+R z1Jv2G0$K_MxUDmvJ$aN0c}yuI#!|*F({d``AstPXB~#Ve$l_f#`c_e%msb@zh@)YV zM0lz1;4^AiRRU*}mQ(;NHCiZ&rS553mBC&$7hXcCfJepTb1%@xIELB;Z3Yv73{(3ju**(DG8M^B16HtH2;;_~Rx+3%G2l2q`(V$}FaQtws9X_-1@ zgcGrv7rJy^Soeie$BEAhTekt>&i*51MQcE$=2r6wTsC5n0$l(w7V3}vp4?R7hb)_c zzuGJf7LnmP6i{r1+i~pW)eNCzAqWUuwzVITN6>KQLGb|%mCi2{(zbXvvd`KGcKSNY zjZiL4vn3 z`n*+;5Zq_pg&B<>q_d68LAR!BG}pBW6l_Loj^E@!NgYsk?DL`yGAL2zJEMmtfW{6Z z|1{+YSHHHo5NB|{HYj5{K!c!j41Y%{WS@YZF~Ar}c?OizW)kK-L8$1NeC};-^i_Q^ z`x=cx%U?sQnl*dlgeB7v=M0%|GsH?V1L?moQ6Zn;3J}$RyC3VAboV|j2SS$E&?DSw z+1}`#s8W4zO_0XSUP0!OT`y2?ItRZ3RwG3mFCQ5`*K_ zY10_e*lYEZ(yO42gR3hpG7rdgHO7&YIRITcgFxY!nzoUm<2y8bw_o|&y}G?<_ASHJ zS0Usj;I1S6oE<9>U|{cBntGL(8jJ=tVvi|DzLn~Y*&t1NX_j$l52uX_<}49U6fB96 z013u9C|{1^PBRLSY3qzy>c=-LCxT!}3lo_#sPdptB6V8sRns<^cztH>0$kew*cN*7 zy3kcOvDlSli{q|Uzt33%#KVOy;c^rj zeVU&kk{(+WbR3s)=CQ@=Mk7yRPAe#Vid&&vWv8~~oKyo2t`((vudD~#^Tor-`j7kh z*=1E8g#wAXGECA0e81-Nls_x_tS;4EldrzQUndj%$aDJ35GdU}na$|)`dYO*Jp1wJ z@UMSAdWF}3I^gqt@{xvw*}-RZ?UBVb`cm!t38cU<89?q9uL@KbwqJb_ic(Hi%Wq0I z$cxZ*4p#(uvrcK9@UiZ2Q%KM!Kk{6TPk6vODc4}}oaflv<(^uJa)?13o7$zyBO?98 z@ZAT6xQ%PJd@X(rkOZ+dEk&*Q+1fW|xA^uUYA9_=B@1bMO658MAE~bFFz7Trz$KyH*4%&?v%Wp1ich2-}&o4SjNTPh4vWhKdi5{`>UT zl~1=X{_*{*D2D%*!oMu{|8vqiJc@M}UV)W}cL9>7qd|1Vb3h^}Y3#A&d}D>-t5GOA z&cJb+(Q`Nnr$o2Y_nb1`%{8wHl)AOTCT@B1c))G9_Pm=r4g#N<`)VuFabw3)B1Ma! zX)#D6hfaYeK9&&4&K8JT;%{x{+n?hiq0;r7UJY-iSJ40IJ@r0Wv%Ky%@mk*5NPH=9 zE*7rSSs^Bt$5`_rnrBH7q1OQo90CR}4zj7t`=xgwG( zQdaokCydw~CskgWywG1!X#i_!=I$a#QzHY-8gpFlWwy8|Q`~GbBbkm9d-x!Fg1Ag3 zr0+DqCgiZ#VrSenW4FTVNim^f?3CW@>cFCRn#;h^TAHV_j&3+{3}j|@R1ozj(+Bl+ zu<0$6q;!nSePx>im0Dp@>(^1#oY#r)TJc=+q^Xr*UUVJN= zjLN(IHpy`=mNdn8BFqCCgqQH0KF8V68(HQ^`% zB_1rqTXkg&Sb)(#g^;FX%J38zet(gGvtnT+XFz}!knLC$SwWn&3YQ65@O|H6EkQ*F z&}jkjB?O}bSZ%27G`P6Qx~tKT!f}iS?|8A4AqI#D<`n`1mP; zszXaAvi$!3qDGk!ue@5+12vPi%qVEfOH>;~9sQw$-%Ic6h)>X}+YU_<($kC5u_v&F#gsk!60EOnIOn!SeG9$z|h4 z-vu(*7fJKylr)yn{0!y`p%ayC-pIQrqd3@J2F_N+dhsBgp;iWgH`|4cMl=)GDC zPmSpqR5v1nDvHSm5~G9XW$)FC@PWbz8^kTkum*{8jP1tBWfBZ3@oWT%q~8Cqu}AgE zkI&ba>Iau`J+wb=pp3VPpIKR90xG~`WYZKJl%6!A`;1|Gp9s3k_U(`i>S-R!;_Ydj zFEKt}(pY7w+wxM=ZD;bWJpO68&u_}H47Ltg-WL%64aKKK9cUqm#(=%r`;Q(dQdGL# zqZF<$a^#B~`4h;IKO`eQS48|@CB#Ewp1MQC+!0n(caQQ3I?1^16W!$;}1xWF6>{OsqWUUX^MnCNzAtPOrY(ZpdunS~z;A`ZEL`WUsKYw7? zF(QlXxsc;W{q?qaD|j0R0_sWW@u7@hQ2B4As-di z;}Ufx-MHe_G5@3NK_gnHRe_vXA{e1eIut*tW>66uv6UIX5~wbpB8#VpV;MRJ46om= zauvuB=$h!5r)TJJXIn?Tui?P+(_`s$3Rg#q=G{fsrae^~0H8AgNjxkQN zdH&I`iSw+Yigp1^7&1i|)-{$SmK-ge@I6=qke!1SJ~Bx9(?O!L`mL)hV5W~-WB5@|+SxL^4vsjI^MlL0%*((;>;MWt6l(?7tpB52ka1HK*4g3L*69 zV59o2M1hF6kE000tlrw(`NgA!E%;SQOP>;~@s1gs5bP$d2B(9-#B zr8%jVBpj`7glh-;hjt3<;WS2Ig$?QU5~--4;T~G@W^)H2nQy*A!)lTF0G6EIn5A}V z3)n=a1vUiFgdnJ@h9J@sTNsh$zhM=Ebl)lmQ5+c}Ly5#1I$FRS&u91uwV^6Ub2#QCD5|7)9d=;l9GW2psclxTc%Q?Tbr8FZc0x*yC9&%O>v z8$WHld(04+%851*_b}LE>0|#@8C1s-p#-eNN@^$7?Z$#G3ao;n{^{l8#va>sLLWY% zHFRS(_f?UpZvF=V0RR8oUEOaQM-YEDf5nzsx{w0uvnw8`Mbb(%O~Gzb87scPp`MDd z#i3YM)&IToxjTEiKpN$#F9vgWvmZA*J2N};8`ZY;UY10#G?h)nP+6BCCshbJttLa- zn!Q5t;{1fa*~=nIVDk480RyzcPhqXMHL23H6sqN>RH)d{N$*A^8zurAGfbG6W+Hd& zuK`mwfZ(#dLlo#Mo#rzQ+!adVAruXfB;;&XT`#zUOB|k|2Ww@CaqvLw*n~Q)CV+*f5I<5vP9T!1IZvNlOjHV_TT!6h9__kdJPD{R;MRA^_ra zSFbAdM{yCgIM~-obkM%qHZn6h^83%2@p*GGem%Lp&98TKy!u&MC32oiG zdb@gfYMkDP*N*mqz%Hp1KK?Uwg>@HVX6pnpbIUIky`Fh})pS0qgNHg3U#5tMQZA>R z*g+FlB=5)s`+vE!5BaWL&UfAU8ouk7z4*AoM&D}@5YU+72rYXoUI=v}Fh^gljC4PeD zHZ2fnSKr@PD`YpU6sE~ba?aq|kkBTNDFiEXDWo&HrQGUt(8BQs*; zI6X(F&t&*a$J_(7InF2?mVaXiB?OKn5w2_6$>o`XH)bRwJF{(;X8>Vv1PUiG^#d_A z#Y`M^_u~b)TQjV`bo!#|GeX9^R(1O$&x_tkQUH(565Wt=8Bxr-hqLjLyx;O;^RPi# zi8@-4c@8gN*YB1qej&twk58++NYD`c9^FaTd9dLK)|}kwsB9ooe;<1XA%=7)Kt}3#tC5KzqUo zFZNjdooke3k@kAWp%rX2l9W8-N@t&gqtL>{dT&FwFgWQw)o05mU~Stg*CZ26*ilM8 zmsq68nio%Mi$Eq|ZU$|k3XC8jtL*7)V<1B}d!$1Ss_~oG^yeC@yi6}YjHgrlxV-w~ zE&YG_>vTH4qOZS9=5x4f?$gq=mpWDyNq-Ye$vL<19mtS>7C1xjrB&F;8-0B1XmM_z z{6U?_^1tHlu|Pb-UqK10lI!a_f+~$fIk3+oxm;k;FU4U;@cc%99-3$XDohANf)C=A zB>6GaVUG_aS5h_PGx>lgaUs?(d}#^#jDXiD*;D)x=XJ#c$;ROYP`y_Co!Tamag!9X zZCN^UN}U)w^7|n>2gU+&qG?$#3j&jO z0#}Fj<(nf-BEwjW^@jH_Is@O%S)Ygc7pc~;0g%)N2XmP(|vaSd- z1j0?fcM3N5if+O3HrFqjtA7Ci0RR8QU0G`zF%W*Xe}&iv90wnDAKJv=LQ4ZJgub{B zrCyT;dz~1Z1MeD|k{@5qC5^O4?9kG_G~Pp+)oP`g`DVU}^XNb#VsKYZ1wEmIr6htiz&+iUWSrJ*{?o_;T+~I7AhgW=SK_<0OS#?Wum=5@Dq!V zV)2mDgx3y+@BP2>&t+cgwlAE<>$#9MR4`83&rGP`TgHVGPew%RC9erZivvg@yyUn? zb2J5^Pf)@OYeAL}wxGxo)S}_=FQ*Ro7{uuLLR1{70FE+NozSHkG$n2Yoa~UaB6@s8 z=7Zi%iM_YB1p|g*@h9XnSnjrzGs!SA@_Pf63+N6ppE>Go2DHaXd%q<*9{PR-dSk7% z;NDKGoQKlc%Pm3eCvO^w(t?`*XRl>Rzr+x(S3&s45{4pmwD0icraz-*J3;rf7U(Z!nh~=Jdt-rj zoqAc`FHq6e&eIZChFzSJh!n(ISJoc4SLJU8v$yX~&*o3=_h|OIe>RW3{7LMw?HO@> zsgt|# zu}J^-luXjNP%_b-=6y_e-$Vtteuno?tGOl^BJsgh8mLAYw3DNee27@dIxo^G{1jZyjf(}ULzCqT_+iX(L4;*Yx(5=r-!=A}?0VW8X zYqwA`VyJZ9(%2tR#R|9VvSh&f<|~x1x=h)dm|%FhhQP@zO;aj*&i3T}3!zdy28>FeN9bhV2Le^i zBy|b)Q<&DMWLcGMO|@+{S9VWw5p}8+wFrhq(@%U;-dWdNTeMKSu1NA1C z(iyx-w@O4?@S5O~a)LkH$talc zuALJN-8OR-?Z9@VbSs%U@;QSCa=E*`eI%^Gj*H)YU4_qAc7?kx%!r}TDvTK9S0J$y zFHq-cRp;@LmEEq-!#ObS%|7&hT=jp?$8@AyrZUw?yvN^LAym>L%2ZnDBWlnIwHaJ+H zEBDq%%$~fE?;3tfhX|2hD(hA;rt4Zmb}9x|k?w10Kf@ZdDJjF}Ej_E4_@Uh&LpaG& zq%O^gMTW6ZHlD=f*+Rqr8-L89K zp8!!787CbiJdaB*wj>;Z`GGe1j#jho$8!Joqw%3>)W9R z*cwpzH>gAI2y@1z!P-Lm_2c|Ws5kZmG4Ba4LXwz9*W+@G;xo$?a88wmawP^xQssPO zLazVmz%Nw!s0_3wEdeTuxN2L#KL3bM-mE*g%ja65Y)l!8dDFlT4_9Kx-Epe24v-2* z5`%~WFilIWw%>xvRWe6e(&aU5ju84v=psJLy4m4yfKALLNfG+^sPHE})!I@-De!LN zf_%9_o-NSsAwOh@Wq)$zyG2}ff0}pf{ukDY zW1q%1L(^rSVYQW>f&XjMQZuauCHRZ$VxTflfx{m-McJ}VncvCT3FZP;>-{9y+%0(xHotH%l0Zg2j=V6jWZBzta4(#VPOg?AQBbw zi~gz35q9OMM8iK(=9{cWnx{Iv0g8BXo|B|$p)fq!JPh)e5-A1@+8yMMUH7DmrkOG*02d5USq*(R;DS>+4 zC}@F%(U-5w1zyr5GqPHVjEL!->=IZv{{jF2|NjDO!J^(;p%#cV(eCDiMk~(we$cJw zXd}^(5CA3`TO};12G@cBB!gh90uadyTC^b-2nEHdr78Kk@Eu;@z1xUY^aZ6wKoh}f z2>rekXjcMnubUI(6sQWY`@wF{#5i~hy>x+TL&`7cc?IMV-^5D9hC9q25vbXbpRWhK z2Lp0S7@`9KDK>F+lpqUlkyK+{atjMdjZD2%Jz&HYRBB>eLZ}CJsvG2bV$if2@{kPt zv=kl0`f5nq5ppab(trae#y~OpLS>*3bfq0U)ZoehFKNt{&Fjy(nalQ<4#oh$f7j#>G^sQo6y&Ohy-lA3%U+C#R#NL_#a{ zFcd7KAi_!FoacEbNi`ej)*b^%w_s8hrWxVUW<~Bfdw$AqW44RkcQnVkjK%!su}#1` zBv#*023Wh~+QWQ`;8mRSZS(ABGnvU^YM$L4?sY@)@XUasKLhs)iq*uX{Xg5VqEz86 zw}Q)mg@#`znxvDV&_Q(umkovPg>Qi`IAQG;i~`b7PJ(fiDcS~1#`lf0pq7*kc=f9R zrWhh21({6I3@w@wTy77TAgx81#9eX-Gx0 z|BWLH8MgU9nwNX?ioN5=3Li5s9DDvE8}Kj|yX?R@VK060Zl@WzFwsGPeExX*D#}A{ z$5s0s%TXd!H|*`U`SQw)2^``ixk_T0cPyKEU@ zUUSKM;2GVjq@E?LsaZWFjf_^pQP6u8+P-Z+S*JE~_xmY6ZJC*;WaA3{ToMS3=Vdmx zeP?BEVL7(1Mh=G|?t)g5#Be04>`3w|wWF$~P_=t$v{>y##u|vMHeC>$DmfT1fHM5P z1_`Zny>;y|+rf`^Tyr)Vk;ofdoz z3e&w_44d({Iv0qsb{7I zK@q2N4aYTtQ*${PH%kRJuzhhY<*PoyS9`C&U!DIr?j3ax)mOE55g}IP`iB~SX!lYL_3UkL0Q(2#BR^BulU+LRF4aeXG8%?D75^v zp|p~kG;T6Va4i?Ne3z6b!^l*eSX*+rD#ErX$Y#)ORQ2G!D$!JT5?fdX=*U=OL>e~4cprnI zgIn{^)=U!)m1I?<4th1)16Ls#A3m|4XrDYhLw^!Vb!wRO5_dSAO=owlFAIj(%H{Vd zc;CvfD%E^BzC(BcR^Ba)0cqcmr--?pPK>u{P z42)0w*^teP#;YOay(KhHgZkMF2{Pos%gi*X?Oy-@0RR7VT}?~FKoGs>R}ASwv|tM! zJxD_dK{UD~!Be2rwh=*%7>Wn+zneF+UrF^4l0!DLy#2`T?3*_(X$DW|6Id4SppKr- zusBu`1L~XaKb3o`g}kG;pMBt0$Cc}?;E zrI4CtIS;|Sumg-`Iyr=kyed1CjzTOF(eI?g+tJXzXuiZ3bL$9zR=U#VLtdr@ogrF5 z>2!UY=9#K*ima;BLZ6d*%t~n1p>#BRY4?YgHk;kY>#@fbiSQ#e@w$nJZN&_HhBkts zY%B?Br0BLHK!qw>jb2XbGJL;@LJE!_Qj?wDxB<)zBQZv7hnvnoB6t|b#7V#?HZaK* ztqce&O1Mq9Us#_DNL?V$bYCvuz$v_0&WpFZ5SDlMETnqB@E(fv{J%Ax4_x@#%88`;a%T`~7%aPUSLUZoY&Rc`T?3%z|{mEO5uBf(O^%RD#|C+~m7`xm&bq-xQ{S>(-nIeItx-D|>6H#d2x} zV(xYM1pom5|Eyh0Yr;SfKI^a8gAlOPgWggp2=-8r^w8c*stE?EwI)G?_P=+(*~e^_ zjfriqNp>>3JI~#D_;jv#CGQ+3=6`0J7D}+R&_W7>f1rXvm;lUtt_0D#^Y*ZY>P{Gw zmGlQ2uttGguRbgcC!)?xurROb?d9N&R@yW&lvHReMhdoCqQ-7Ix{7D&bn5G=xa7KN z-4#R#e&!DSC8U5oW$Lnp^ZfSI()i35&wLx9w^qW5efy%niu{cZ)I)=e(9jzQ*(xRX znu-SXzWA(*{A{YZDGHouj7Js~DWMzO_~jhf1D?3uiJ6%5MtJQ*%?tDu_U{{6xU?N8Tw+|FSyP(vgG{ zFI`OZ5ZR_jF{Y3-`HY%8j?>Ks?X&KN-zWh^|E6w*LoW)`oYP*`zs}0s_i>q)ignBlm(NUIoopPg(9{>OV|NkmTEdni812xih z!Sjq?(J|Pj9ms>=~T60mu6a`zZYS5TvHL&N3I!Y9yq@$n#NynNB1`4%0 zkdhjbY9W_ZW+p+6hbG{>d`$ucLp)>`A|zj+mOupaw*p$c5N8Ph00960oL#|AgFp~H zm#?Tuq9uV;ns_liR7#Dpu?^Pfjf4tnLbNH8aFBm@c6J7Kfhh6R0_m__hGBU#Z=N#B zf1ZyQ6hp5uOy*Rby2_}ojM`fzDTDNBQ57c6zZ zWozb6we2KJ#V)$3`Y)i_Xn2pEW!E2>jwZ~$9g1?WHM4zFEA&4`w-HNzZuD^FvgdEp z-GZjRY@+;Ww8v%?bNQMeJ2{N4_0C_d7dH?5dZ6`r7zrJfcL4@DDSvKn1BJ_{n>HjD_}EWRjKhJKt}e+SywlpOL6Bg_SN&meo6* z8o)g{YgM%RC}~T{$GWVF6(zc2&!|-VOXU0k00960v|U+q+eQ+87JkJ9gbR`)kmlOu zO3}qlBuiN<(N#;UqD`>cP-PxS2P4-{iOmPfXgPd@QJ~M8Im~jso8IHqUd-O9 zXh}=Gl$sM5hmQK`$tN2Wkr@XzV=$Ib4K4dgU$<$)>3@yBf3u#|DyGB4x}d%V_1}p0 z2Iv?KC+^reu8O+?r2HJ|%_vo9r^aEE)q?}m`rDM8N^eWJ;ZPq9oOi~GCG^joZB#5z#qUo%qn7KeNKj z0Svrra`**P+E5>9$XU}Z52a`S047)RfPkRWQv9ABNEKeKAOpvPGM3rmpe1vjO)>Ds ztV99%ZCL{E^OoXF?2aXGvrA7##B{;CZN;wP$Pb~J34uar_7I$;+0eDtSJt3A`g1Ft0HV}d4s{~5vH*<~4n=Yz zqOL6=g8`sk{MC0IOoUb}r>mOdIiZ~-Fn{i*+ z&0ww93Iz-Rf-pD2bP~@P*rtTh`N1!Tm!~K_mK_7t+R-7(sJlOH zS2X#~Px5C!yx4BsVHNI!G1#Un(w+QgK|!RjaXUK0#a^ml1#SFJ*J$R}#XhrOz!Et`DqN)0!_93{AhmzhbjL_R@c5jc*ovWy+%kU=gwwtFVqZx$;&Li#+Rd7o;~4p zsnbA~b-C1LiKZ|ffPvvO?@+6vPX>$ z5xrPDb}oB{?(YCNdCn7LhqGzI?A=W!*@7*$T~*_eQ8h-qPD1u*L%$Z1GfhfTO#Pp* zTjU{wytOv;+@P?dMp3j&AUhbJ2c9nzq3A|a7Y@~Cits4)6-`#s^=jeN#h+m%>S7~X z6YA6$j=WaTNa*DF;#^Ry&{_dskBLmnzQvs^-5h_3YO$J*YRW~YP3IZzQ^VJoTfpY2 zmL1@aroB!l9@VPoHyI>F4Woq4OZRdQ`*rn$)E8dU`1wQV?8yXu505<78hf&NVYgj0AQFwsS{k13GbXAqf z$8uFo@kMwK^19xRvs!^SM61#f#z#|qk+Ti2#v8e9UfZZttG_Ocd~I+sIFGBy!@4(mv1TFm+m;(zH9L2H59dTP+#G~&5`W@AmP zjLpAA=7-#TI8*ut(o2eku%BFQJbRwgO%prHT!z!W_Z+#;tD*8>o@a}yEB*k$?xOrJ zib{@TIy>zHL^tGs-Ii_g1_t2UYEpu+NK5?O5HWR+{d*Co1Iu6}05^PW6Ls4=psJsh z?-lD^ryQB@tqrN*rO`#-R}U;pc&5dhibh?wsNx$k4O-s`@(O|BWO=Yi1bCg66t~?S z9N6Ab-Kr~SeW_74P7#O*RpZJ+*^0l3XmcEbYK1X&iz=T94;Cb7c^H2Hut2y>XgcA* z@U^+!+(%4Rj_3u3fsw6)m*51^E!d);V8ASNU_^yLFo!+Fxd0(2kWQf^v{nP+yawR* zH4)3zcv?eG zk|F&csZ?`-m|Bfz(*#{yCkV_?0D3!!D*Lf9o9r$-e_lzBD3IUT9~KFfdAu(%bmU+v z4$9S{APac8GsY11+AK_rarXP*^^j*;g*cNh@@+Ed2b8s)4F*+0m^|{w+2zT}tJA}N z4?_|EzI-d5wbv-!d@ld8aSN*GWe4Z8yh4Utj&2GsQXu80G1Z3k@RD-JW_!~ST$Q^hZ36`)<{;tQ%a?Q}%bk00d^Q}s?yu*! z&vo24`X+k>d-Kg=_2PMOc)5S_YJYIl@9JFY6X!eqbpQj)d++r{a(N~0AOM*h(TnrJ z@fAy}=){I)U&#{$F#Me8o_J2mO60V^I=t9_^BSeYfZVW6LFedeZIWRT*cpPr^Bqrp z*J=oC!yC3KD39Fe3}?C|Uk4|Mb~~^G?=`|1W9+?@F^yB>6QsdbC>l3d&n(^8NCwFQ z7U#!6D&$7G&#o7x`VGs)N7aaZfQeWwo|gCxr0oC+1N$63deDAA#g+pC_mtNsOe6=& zgX|i0XNmy(O~c_tA5Bqp-!L9RK%Fo@@4(nA4Rz=TjI;WbKiHP0XcUI_9B!FyLEeLnf%7q~)7{!m>+uIFcJ?yqdAJmA%X%)W|5AOa$LgFh- zawzx@xSHe0VqxsbcbwX*tI#08B=8uB=jW)kaZ72epaP=9jHkLrIaGRk-rk;WARpZm!_MW-_-8cB#|UsO~|OVt#V{^R?f@&NGaC!8oSv(B7Y z0(e(Sj#o$Bkau`-JGHxHZ;*AWJipb3TpL<_uSJY=taEG86~rZJ5P7oDQ_r+h*w&%g zIr#rhV_sWtVx0<)7(&9Lp}A?AQ`78YW*1)+@J46>_Ev8bOT763@izbf0RR6o!qI^! zP6ZY!}spsXZ>i|nG@C`yhFF}^x=!2KtKqiYp zo9RZP?x5(BntI zhiF1CJOL}`Ldnkv8({N)(5wsXgehp^D60_~(efHpe{>wQ2!NDZuw0BV7U6z9v^hga z_J(Y^02a&X=oihSUTXnvI440}n4E&8PR978mq)&R#qIKLIh;%M7!(GP4w z*=!3>sS2>ZrEN}$t~yfhRb2&Gp{7=p00000|NnxjKrif|VFI~Y5#ouaQsF3Sv4N^ojG7T425kwP0hhZK8;g)s@%3Nf%FE0Ee#&;k-%S43d741De` zIB-y#ZZRslNUBhG%qxO!zCm&%T1r>(^#T z3n8Y-K`zQmO-?N?2KL*~H}!*zNAESDpJRY34_)sDj3Mw8GP-tfUj-D>&{Lg|H})Vd zp~h+?Fb?e0jDX5;c^h)JrXlu|3P2m4u<62?fKVq;xFCrS({4l}00000|Nop_$!;4* z5Ivh;F`x`kQcO-1wF^cICzu5tY|6?-%W|T~F1B<{4z5UG)~&F^B~e?i6N=-HTunHZ%0a zGJRgZ{kwSgdl49(d;QKdR=?Xl#Z_Kj$|1Wf!y$W+(R~!5TJM^#mf?Jhw3`|pWsa%N zyP>J?q0cUt@vDzdSYEZxS2*4WXoW;}(bIwQ_~j~Z>hk(2AMdUA{+Z)v&2^fj%EN0| zvcbj5dB?KzDSl$0@8?gS6wkf$v4(R8C{>A;hqo2C#+H>#xN)G2p5Quxp89sYTF^T3 z5u8sGMuO}W&E8E_2!2u>nc2G@Dca}r9;vK6UX!KR_A0uLa{kxAiemP+AIIyb=Thqh zWkM9Poo2;HN6fzL%nmA&Y{Wcug88FFy%>Gh}p%6nL%u}W5 zv>u50L5X@jz%pEZi?%}m#F!(jUO1Y#wau?yW%iAf^Zkf>epVE(G30OGy!w|HHWl8K z2Y#(3BOK;wC&7nK!xzPROCU0_JcGwk3cK1!_~5z0*!=nKFVD{CZn2|zZ$^=_coPCkSU=tgS) zd9x!%RSNa>QoW?3JoVtCBLHcO@^0F0z!*Mg2LCSuI5&MyG{T_HGf^?F)i;jiyg4iD zVD7pFiiqUkB*x zYdQ67sL`m$s0%E?m{$DOnUlhk;sf>!1R^u5&pO|{*$5WA$)9U!L*&6*t-=gQYh9Ft+4c!w5$J&gFtm75;|~M z0*JbM5|ZowR4UifXBil|Ua-e-@~CLCO0*>eOjjExTvUYY$ILjvNjn}y9hHhf4X1m~ z(i=>IWxLVxa1RyndC&*s*ug|by8;*UM3$R5!n^BA*4jLYGk?39xE;=5=ko9F{tve+ z{V(z#9_;QXc@C;gL1-*%5LbAO%itMzb)FejR1Y5?s!q-Yi`A{c?aJtVsune6kY$^u zWvu4}9-Vs*;kg#M8oTm+@qs48I4iY3pqtgFi>sScHe8kq4Onq7ch^10qnIc4SmWd3 zte?`Tb%tw2hq_{Odt+S~?(2{AYkxX>Z3nk~h9C7E00960(j+RVfU3bsRJR-)OoP=^ zXueTa2n97#OG-igTTmi|6~8F$=n_czoCq#5t5S>d(aeA>+fN41wL&lFDguuXCqoXZ zOorcZ0BnQ~1!?(gid;}`sK#Q4i z1_#JKP z#F$4x?F%Ctg|&qaJ`fRGD?JB%+yqH2bx_A1!vfI!BBY@N>3+f6UZ5SH;M0hJF$r=R zy!8#K^7SFD43xH)1}LP_+ic(#D)t5%sIja$uq}2j&>_0Opn?u^bf7(C z*vZ@}kZ?q9hoV@d$pyNJ0Dim~Qu8(uo-(M?zy$yR0RR8YUBL>%Fbw^bp@V^FL5~g( zUIfqHMR8RGQQ7pikGDzJE$x=t35u72+nT1$+PoLj7DV*Nw@^KgakX*`&Lu_v4C_LU z5B__5k^9VSIAa#gLmv?YP7sE~^?_qz92vL;i^FjQQYpB3 zMk3M#wMbHt=nSLUF`iG?TP}4uj8DUXs1R^qr!nk#<*jD+L^f1-MN0-KH|0HTt-s@Ko8>>{c0MZ0 zY7fwIK8n?kT|X|fw786L0L?Ol%!qHWnZ|f+M#FdJ@2L(Q-n}jPL&`(?lhB^Y-QS)6 z-uM6CHw_#m)KWUZQQGXrdho@gmsXZ&*~tL(_R`lH0K2X0RR8Y zT}^M=KoGtAS6I+Pf}-ROs1l-Xiq3z9e>c&x83;5PF#e*%C|Fd% z0z&%fKDYC7muq?TMR`OA)Kx^R%5}*J2Ucl-gP`zaPI_S7%1BUsK01eHOWbJ>%77#p z2uOazDmXVkkPfi)0Y;ur)n}!^-@jFz%ZRWJ#Ar<7yc_gsysqd&k1|qlLUu#~^$^M_ zim+@v$^$O%7Kb3IE9d&es4_?6t!)m$B!@H6_Dn&z1LZof`? zHwo;8f!u079r@o$x-u~bV|_YA;KS;$dUi0t5=NNDxk08}(lcvFTc7f2$kt zi9rfmupV7rU~^w_H~N0L9o5@e0jUU6cNYU2BoYbk+-B3=$+q{sMf?K*0RR7tT}yA< zFbqD=ze32xQW0Qju+xkjoZ3k}q_JVUSPBFn+AXDq=*2Ba>a+MT z#l#VHEOb7ZesMcP|0ZWPP;AQf(hkrBF|o$AlFPdCC6Qny2V&k4y>4m&_)oscFPw-* z8(}!(m1C3d1jV|o+8SEO@CD0-i}-VF zS!{QQ_ceAwjUR*r?z^w(+YL)YeX$4y2+7&EWmRc1l|~M$Y^KPt_vZ(VK;|h{O+d{e zp}A?={L0EK$|_&O_qiB7-;J!bJgs2r*ec+Nc)N|Q&CGaTbq^q9i8zTrW^{(pC`AJv z51)P|BwuGUf0*jRSJ2T1!Q`oz`hO9((I&zi&-Ckix&`xs@IEn=ZZ9(5dn|B- z>Nso-C7$*M7*|VN;aFtM2&#vmbFZZ)y&o?$Cspme?oL`)ynN6D8lU<)BvI7)ruRAd z8go5)KGAi?3og??9}m6-x}}?B93ppSVt5&z@6w}D`xG@eSBNBf|J#y|73%?*A~&; z!gA<%$6M2O;sfg&JCJJHax6bMy$6vtGdC~p>KKEn>QPfKS}`{qy~bVP*0+!q>}%h`P$pPyVX4@?VFzC+|2Im?tJXbl<9Zr2Hm_r_%s5o7j`+x%Rzb2 z#m!1x3_kLK|E+g@+561U#dNaNnXvzrqE^EpU;LkKO6VO8hs}$x=K$9Y`Lt6z&9<^y z(IgMP!9^lH#ws1LJ?UQcm@lSpg$4iwp)$|-y(|w7+&>y9A0>6DI5?Pr9P9%FbJM%- zpM$l^KD3dcXufGV{u!7VP;h@`tI2drG52Mr-ok29uD7PjechKG`zB<+>LJQ?QmYeP zeYqK2UBdgopuNo{O1E0To({o}z^?CuNv_UHJEN#ae7IptsL_04?>Th?_)_0CYt_w+ zicy&EV0)4IPn)0H#Y%Q;EP@pvNNI#`@gH>R=TZ~{I?4^3Ar@6bz4x-|AXDK1QySn~ z08i=CAQmQ1k}hbGPfJ2jdYWb3AF!`BCFcq|He{Jp!=io*chnbbFN>ngm7W4KFBI7VRl06u-e|ss>N1sIvM_NIb}A@q@q)5f%&g7 zs*!+m+_W0wkN|{M{C%9}5F0pDja^}%a_&SP=OBpvznX5Af{|*s zl^)Kq$mady2=8nQG3;V{z)}cZygQzr2$3`TRI=TSJ6GklnPYkp2)0T%Vcc(Ia^m<^k%xH*zLr=6TcJ2&1y z;X^#;wcFj>X zQK=Ji^@NL*GX4U6x`y$sSQkke271Rp((DFScEmL$o^g6)bzn_6_7NE|BY7C(UO@8T zE)oE)81zPXQt<{A;o0%Pb7pO3zA1qsK;>09T(VA%;#_~((t-Ay-`EFGZDM+mP)^0`$=@X#(Bh3pTpa`%T900030 z|H5fH(trmxMLJk*f#+@5Tq4+(64;e<#gN>K$7o2eS_#zDQ^J=1>``4^a8Up~>H&IcCv2V>TmvZNW~OJ9Kn^|uwnG)5O+9c3 zAscFowP456gvN+BBvVKTQ!KjBf)Ysu#5@$&5*2WSvI%TcGBn^oMx$j}00000|NlaA zgC=s<9MR=~mtvqg%@$n9pcH00;K~8i_Q9SF6trQNC_z;zL8q*hG(qJb5aZGgb``jc zghfemL8XEQ!Z|wFvo%aH&h|*wfmYoaDCrtvH_%E%wm{2su(AQe zb9hS{7k`}Afohyg=&2mVaJ!LHE7(fp78sW700000|Nq2Y!485j3_Z(N5E3)dCF?4yqdLiUH9x>M+s(cQ?WU=BQX5tHl*0Y6{0sKuJdq>~W;Zz(zR6@bIEh<*#;4Sn64qxTZZVUR zlM=gtm?@0B+Wu5@o~WES<2z*zG&R%UV05R1V?~QPmm}LmUUU9z_IYD~ldU|!qc6wj z5i`X5zrQP zh!vR<7)taP!J#>t?*fF&RFi{ba0fH?z*HUaT+` z_|usIEv=$1e#_U;mH_5jPFXZSxw5Xz8vkpkiVo<1Xi7Dw7b!{uw%rK;^m*DsA%O`J zWVJ%W1J(42bHjZqalZk2^yQ2`0%gx}Y5^zw5`8vLl*W3GI~jnJjGN$MO7^%^4r}#8 zuCrG5A0~0ewJRir8^OqIO!RpNW{)~EVqEYX&3pXCN+0Rz}a4WmNo~kTiV*H}5IayM*c)Q5ps%aZoY{3kcT_9o$zd z%YweR)+6I(P3Uk;+i#}VPDCAPclu~4n&?wgbFtoA#+#&J91m96zX_u2PU5WVhxE?V&Gd^UzX z7ko}T)p`a@`iXJA)J8+tdaT(+s=WsYm%jUn9yfBf{%$ZEF$$P}kg?UZ9U1qoL>sP+uev)qHF zrYjJ)LzKV~T#n6ljBFj;rGm29tHOy=e?{ZPYYP^jQ)R!kX3^g$aK!&d55tle^;D+F z@qJq#)d20&jJQc^M~@8X=!gh+VCD1UnjqG~z?>Kq$CWg@Nq&1)Y-C zghvT_riTv2WK4Z_U~3+EkAr9d)2|yawVN5$5kG0?x9P|rWkxDg7PpKQg8?Q!H>H=6 z9Tp>rqD_l98{Nb(*>TP#3}^@uHANf>{Ve)?z^>P!xQ^8I&XIZBwQNW+UO0HTqm0OI z^B?@J_6si?5}wT#OG2F#rw{cniz5PWiZU|Cj`xOp zj1}b`7+}hqfp40M@NDxJo;Bwo@~=T+w4Q5q;i<-X7g0P(mKZe^v%KG3Rkp!3BJ*!$ zJ4dwoE|94WZa}_zsv~eK+nT)L9z+f1dP+%p=ZWlus~NY*!{G^vYpgXVjrl^&sT2X& zY)l7314MawRV#kFue53!ily>}u;~Y_{zj27jf;UNiFsyH+q&f73K!4eT1Zq-h4RJ3 zb}dCJw#ot5>Qku()eujQY6tpx@>F&eQYR+F&+*lj)NqDZ=wLErdqoY(yU`CP2MCNq zPYDMI4}*EGhyZXMkeRRp=IUiI!@6E-^z9D-00960lwC;6 ztsOdm7`&l@$k1(|2&$Szff%3M13mB(!L)itAWMk)@olF`%L7ofR*7*_FLC*n?gvyUnS&o(5; z1O}M|K(eYp$N+&{f25{po4~3($-9}jZK7W=UR^X(Frt=34BBEIcPd`Wa#!o z!-Bt1Eijj#)cMggH&gV>sFD|d;ghL!Wt_k%~Rm zX5|ntrIte90JQdIdK|UwUi$3*lN(2222C``B?iV^(7p(BNTP>rIi)CKlU3X?xL`SC z4G6bk0~7t&^}Zf-rE0)2SD`HlOo4c0&}an3x)OdCtO=$UUF=Hr@S0XujSSn>yuG|d z^lWHiZ6%SmdCE`DL83+ zm4fnwKns4jC3t&W-dtWi@ZeG&xgX?h;Y|6+t3|RU1RKdO`|b{0SWxj$W~dIG-618T zwf6AgWD19fAVc_BmUXw<*6+J(gEABXqS`h7q6=IRJ!H#@^MW<1uBg$f^O-Jum)sJr z^)QWg%(0s(n*#apEr}-x8@in){YkqVjhRufS76NoN9o{)prMmnY#9L}I4EMa4Ad8j zM@OdIy=uzAu_UlIG+8B6G!H0XwWVkm3cqYY?T}^AZXe45SaQEo2WuP`&=eKXBjF<{ zjo9ZNp_UJ0tto%m`4koe`tU;*bxcq3`#$6ueq>ui2D4GN8i!qRX4^Q%dTkvwqT2$8 z9_j=9gg5dm4a`>Z6SCnc)sIfadcK+wnDZOV4sV}fOm|Dzuq=3(j-z#aqgD`OUTH7I z&B(HK@5jOM`Towq;mOgS>+Sx|@y_8|IxY=3ufnda60MBgtUtz3YF+S!e*nb;w{37M z0YA}Fm9_sm2vfF8jx^A#poMiPeq@{DNRkVrC&|-bGw-mXp4>c6=J#}WIl(LU0qO}& z6Fi+$cDc5xEHG48zJ(1EFU-LJ$W~${E~QNaR0vCi%U7LDjkP0^-pRqX8{tcVhOTWd z!n7*3Q1?++Y$s7qa1J5RDxh^xoW>`+yL;oY-^&Zb*)E6*3Jwb3SFa}jLPWcX?)i23 zNHxSNcp6}z4avw!&QbHvBG_&!jm-P58_|odMBmV!q%$BD`*D+k?S3r+XE}t1rH~Wma0s>UNY)_zsebVXx3S2`LpMl+skh= zMGc_84onnlbL^daI3!Wz8?RFW0h?!P*IUuujM#}rNhR!xwTVbdYeuYJ1MW<66N%m3 zpssJQ7HlWrkJXVmq}8%e3JprUn0SXM28QAl5_->40t_eHjQBt!mt_p5!l*FzFcvP&2wQUFt@TKIW8#voyVG#GpiklV?nK z4(dhZ<5&T)*0G&Xu0MRo%}C^1=A(6eEuip~_sqe!@2gP9wyij;CE$TTd)plyBh;@# zR*IW81U`sgzmcdoJbU)zZ_mH~Cg(8ZP;~4TZ2K@o*FN&gau_(#fbDx+OQ9}}g_dz7 zA>UNK2rc6)$t%|)yt6Vl(-cQC!WoChR2q%KXw-KE19E8E{i-OQfy^Dkxu0wZ!DeXw zyHLrpbIaJO>r#+wo@+ugAR$hcXp|9C-1azaQ67xTK@e!^HVue}e)(-<;jkWKpP>$n zH_f}PQ;<)PSK`NKg;Lgrcz3nXcpEg*wsS+jIvfax0BZ7e6awl-&pwFN)$%Eugo1ZlE2 zxF#eGCwZ7MK-SVsSBBGQe^|f1In}S_{ge;4IO?Y7>}U&{4(7ap-P;UXpbQkeYhXPh z=L0S?ZWoP0=mb@o{6>~)&1!Ek1kBWTV3eCpmMTiP9!WF3-Pv1yvQrTGAfmhaO9y2i z2Mw(60Te{q=$xW#X-X{B;az}cV<5$D_L2x8#NRtT!}{|0rC4I zu+q~3$msnOrVJ_3CK7u9!SsV=qsrB?mD35=?zjb-V-9heP6Cs}67)%=g`N29zom2y z|M~^;DkL&ZlEMr5K=~25GHgO5x4{LfYKW_}Op)VAaE+=jmB23A?~cAc5B&tXXoU21 z=|~ZN&9+H9JXPW{}#%;Fhzwu04&?NY|w89}woEcZZ$0Xz~^V9Ib%iLIg}m)+pZ4sS@{u z50tXBW@WM5?eYFourz3x6UIhlfm3gd7SY>-gEJO1VJwDkm$-m6^II%DAISzT4kgrP zz`#y9s>gN- zlgKc!m0kq%DgDhnE9mm&PcL8m{PM+RnP<%%tvqi~(zCY3nfNFA5t(h2Jr)gO=hC$^ zE1nAd5jzb9Z|BVP$?h@RJn0kY<|Lnz5fOiR^&Ep|FU#}XV^U_>)gzF_$%}Wm4S;jJ zYAZa*ty;H$p^+^WiOpL&czH`jypmIMVC%*%axhVLw$6tpx?!LuFr+?&GY818l zJ(x*)eK>^&!8*@6L7D|!h%-3amCzPZcbt`_g28f@sWH?&{-J6ktm)^G{sRC20RR82 zU2TinKoI^Mf5kQmMZxqp6glWo=t(~pY7P~oX>uedoNzzB^UTY>nOF<`aCpYeWM+2W zvpc)GLHa1&5*C9Np-v3R2(~_i##s9j55E&b@dK)EZ!e@5qD@)AU3$o3AC79{tjY8H zdmKjTnRTjUTo3rM!}yPOY_+!V(Z+X*VT@mdj|A2uSZTx^aGQj5>?xGQmd|BSE-R@N zR#Vy6J!&e;(CL zO3GGxSs$GB3M_o;8_m`vp;68zMls9b?%gN>1K1=#%uSM3;UOR-l_2|pv9G*8v9NL-F)O4bo3pc zh$bXdvoLIfwUk^XIUJ;>!TiU{v*sdadRuA4ZVv08S+biNnew?sKK1h@<3$m2L#*;n zvqegb(Ngj|Wn=7Q$cD2{&{c-4XQt`Y$R2?-Mie+DX_<&f_%(e}HX^+l7QaO~H5riu zkWrp4H=@>hq#Ac}|=di_qkFAR%waOSmV;HWQ znDP_-0oVFL7ENfm04nigX0~18 zwwceI!QYd(;MHVnT-N`4+Hb_T*)Uc4B5n4e7j)Y~6hx*9A(cOpe?bJbzgI0CT4t}2 zOqD(`xF@|1&s1oqbDoaPmxs+)hZ3xNgkHA4=<}JkRkNB_ltn)cL;bs+QIXt=i( zjAUM$y>=k>8eZJ=rPnMB3=GJBcH75I0x}EWQA9%Qo`aK|BE4z~^Q~*wDcC@CuCf13 zz%#3*LY_S?kWFb^OD+@3ZDVAwSdf*@z=|AZF_stylXkDLiI}T3tCI8{5_*@xxsE>BXc#zvm-62&^q)1t@ z8U14MWVeaON<&)3R&%k$F)5a-lJC>nY{PDQ72FM2NU6T=a4>3CWw%6weA1VT)!dZb zsE$!{VY?x3`sC#Ei;JyGGEr~mB4v}Yy!4bRfR!T11;7rv)ba^V z#nWiYo}`9LmVyNL&V(OFNdjBm(yhbxNp-(U&I`?nbmB}AS@xn~;R{vzqN;eUK=cn& zdOKCVvHVEtxh4|>Eew>;m>ODZ`Z=gCU=fCFbD~ll^Aqb$)hi2KEiS_`jkVU?4^~QD zZMDM3WT;W~*lo!7L$;ywpKamu(|JBxz9V*?y1v+H^WEWvFSWB&`93J0-=HTc{k9PE&IUtJblv3Ye!XNrZtQtsgrtkn7nXn)Txmt1oK^ zT&T1Or9GK&&oH!m^JdlRZ!$MX1n9IzTudXp5t~JE>IY)SC_ghxB0uWn@)O1=+~*UxYg1o$2Q)*9_zB`H@)xYkn5Thvwnz z7UMVqpDr5^4TQmwnEPRfQ_^QF&Ln-Rp79B_2T!?9ShW*9rM7T&MIDazS8i~{EVVU+ zlu>^u$$%1qV9lBUK2&A16mI^EFDU5Zn0?oePL9sx?n(%uDG60+AddGxyz6y0;Nj@> z&t8`Tyo=)xAA4P0Oqx){Oax*@$_Bt2Ey8$!Z5iJ4)$wTCm_~gLs{^%th2c0>-8e=@ z>5~3*dtGgSMx@i#O&D$&HR(9nLM>@LjTgvZnU@AuptYu3xJqYClwRT=W2LM-n@!^h z$s}!Y+z#4pEnc8NvgW4IB7!4qVibNemkd8=?0`9wxiimYh*b(zg7GDR`m=cyje#}C z24TN|Nq^OD)v@-()zCUUR+dhq@u?rucYELc0k~2BJ*1B7e zwA=oog`8gQT0~_SZ1u2=p5gO*y-p72g$b1Sllv)u*&;6nN5HA8-E^zE5hh*JwwN3( zkFlzJcNld$B`3%zwDd{N4|moUP_PdzG4R(>k`_i@?)s_0#dDNr9gURZ4F?Ap1@{go zqr!at&`*Q(KD_Nz*cjz>Te7B-8vHbaWnWq~?B%d@RsZoyaO-t2?cXHh;pm%b-eE$g zQalbv_X9$thQZ)I;)urBK2%}hS6m0-)pYZb4V&KfCuuVHrkg_My;qy(FJEn6>eigd zR6r5jsx9Kj5exs46+LC7vc(qIpiHypa5~4@S3P!VnEbf8{qS0~6W(7x>>7FP;iNYcREc-Yz8zMt!9i(hmLF#PQtx~|?o!VrJ@aCBz1NlJF8Cyl1Flt)og zDom!h-D7Y+I1V}3AVLvS9AZPdrCQCa-NFI5`L3)JJimIEpQPS7dNq~D7-GXwrVtbE z7BO8sNu8Ec!@1pfZhOqa%%^y_FveFxb0qq*l-GYDFFL{T3235V-e?q@L+O`v{f|D6 z3E|TJhQNL}f)Cc$bs6CZBTuC4Ar6aRd^1vr{~%g~5hI8QZUWy8s{WAH6xWNT3kvZ< zqMTE+1a%UuYX&qVq0V$Q8fBC-6ERH0X_BCFsaBo97liUL&68t34bezeT^t<#>@>As??m7)((5XUzSC(v4jTJ}t9kA!|m7e`x z2(q1~Z2gQAf!8Jr3Ft;?!Ma76K#pbkOqOS0|1_#3&l0d0NWlzm`{7q~UqOEm8IY52 z6d-(vzQO?(;Adcll6lJcabV^8)1ERavMU-rmFLZPKym$%w?aJ#!2pe7NW*_Y;4qyh z`$c>+POxGulyA-~=AsB~_{7<5nzxk^jkD#+uheoj>>e%OH50^kYC%m+(XGdy&q1}& zLN{N^vUFI5AU7}T7iAX_q`uMG6iV%yQA&z71`^66U&|6pV+be3my(1hD$$}cl~;B? zX)HTGvjF;dOH4sbbc`UleYrAX(fC2aSIvae4h6hoqv4RugK&Tf4RMZiP}Laywlwl~ zlq8eQ(sHE{g+`3u%97Uj40u|mAl5Z4qp>7Ssk$c+oxAWRkkoNpD1>Uptb=%4W8^1d4~nhbbhM4>Gna-(No!Y*5d)v_P>SPp(pG z+0-AEP=EA4qJDi5m6pTrHh5>2^|cYxf2NJ0oSa|F5+5Aok}IQinFuHD(wi&3hB8Tq zK^SUw7{9A&=65n#;UTT0rBm1L&IS}5Ptx<3;-||X8dI#--5qfa+#%gDAiZNw-yP{G zV6sms8~y1@pW|3ce=r z{&$ys$(5^+N)Zs)Sn_Tnt4h~EO zZ?}jqxgm!sdPJqzShB~+iYuKGi0U9pU{6`TFl9`jX%jewg$VI37773;hA=e9tBPD} z`7=4(D_45EK|d452)=+6l1`E_TA0XSDW~V|PG)9O=1h%D4RdBjIm2PgaMUsw2gusZ zf(v~}6J0Y+RuG`!-%V!vky+iy#M^H6bJv`fPg@~QDK(I}Rmkn$Oea=BNlGHaz5Z;Zu{MwHCgSs$YjqHy8m3AP({#19)?V1zM~Tc?iP?V~ zTE7ua-$5L%79oYJELwY@`jU)!tbQeKRRa8~(fTGyDO}%9QjOQIG|bfl_9d=)DQIXl zGPDjD>fqQ5nb@K5%4Gk}mh1ur@8KC{7M5phREhdaY#;_T(PqIy6_IX$tmU+!KuUqF7 zZhvG{*MR#8+0G&Nb3V&_Wh{Yjw!-!ehZDI){yue!I$<{0EhPPh{5?#0upujmBJgleFx}R> zCI|(r>Uq!b#ic%YcZ-bxD=kJ2>HKbTc*J?wf)nx9<l?N!YbPNW=!ct#waQeOTZpmfDGEh-;oYT#!9NT z_bQA9TPw$uydSo#kox1qNZfX)4Z08k2i=Qf@Sdxl-ThD8^w(9TyOvJje1F_sZEq7t z5dQ4^isNDw5+#?y$5i11g;tSL3DHXJhe+lUAHi_3gU<#m#DDM3+s^FE*-lCkYDEdL zclY*oXJ=<;o_*$GuRA_DE{?A+_AZE3%`mU0jqex%r{}M_QPKnVuIa~CI)bX>wx@FN zg;d|kSPeXFVmRpRjcC`;8xU*~lq^NR00g3(`_*how+5I!5f-{(AS)w^Lci0aV;h`}r?gnKL_0&C7V(sr zf|u`1soH#F>zj`ufeCQEfK9Q2W7jnb5A$x~79vSbD&ee#^%2M)c`d5Sn zw7|>Y29&s&FascOnwKli*Cb?|9uv1?c_HUSnd4;L!u_wB;!#swSH)3VyZFR z;u~gse3C3+Q!R%VoB z#|@}Fr_Co>kXNfw@OgH>0JGBRToA_7=?tlL8?r%n3aqb77dmnyl?Xdn*o530()? zOw*6tu*oj~asnX{QdRmzNmav<>Y&He-E`D++bL`%{YLi`T%Hg-!exntjpC+rowP3H zKrQ1$&Vix1YdWLzaf4o9KEMK~md(W`5}c!RFl>?2?9B`X`I1Eny_u5*vqXby>#6}t z?bu5za&(COMYOPMOYKjr2lM+UG#HT$k`MvmAKsgkEtTb-6trHe)URbFPziX5e#yH2;qwe_zOVB^5~zNm1yJ>01~@H9>lNC}xQy^-ZCSFR8$#ExXb3q+#Bc8fE_ zW}-9Kg2C7W67C%XRjZd)=SA#O-Yk+uPux7*|Fon07KaQF$Ngntd`eUwxX;JURZB>@ z4ln)}($!S*ZO@H%;V=Le#dD&)LB$rGxkObCT=BQ1|1 zH<*8@>@>C%WLJS=Kt(%rhp`cXmW#?6Y*no_h^+!|0);6j{I`jAC-Hk#k(uUyQ{{Cdp4;Qx8I`=ow~>zZMB*7%ZSR>ssr?d z`5_J+;~XWL@ZomgbW8vVKQG%fpr9(_CwpGlX5WZq$!idU_9eQSL{PU|6GR$ z89D)g!$hJs!QB46ZExsy;|lHAaK_n~Nqi&5sEIccS|QtZRMrs79ovp2w4Pfn-g~UxdoACT+;iOm z{ts5L<@}6TNAXkqOG%H7@ogE9t*L@O@uPNUaA2=l|M-UGCe8W3H6_mv_U$QDoqGfE z?QJtW(P0UlTgi3td+soOR5F37pK-wEZL_TH88`#k^Orvc!kb0J@EiBsa1><6Oxp&R z&E49zd;j;aH9P?Ed(TPW{I%zm^KH*7>OFA^O5{9U5um-!-LiNUpRi<-plWi0%H7rs zhGN~NO|oBphs<={lHHno3zGfw9qp>i>Ey#Qh?7^Fi6-qm%RZt>f7dc4np`h|36mcO zPcMD>l0R1%);6nZlia6=&kg!(w>bCdLwxQw&N0>za3)9~1!72i?_2e zZ8$geg4UWdc`=CsCjVFzEvTd!i@bOO{fYXZ7SQNt-zrA|#(lwpwP+2@J zd=r5kXNPRXMCabF!EnroCz6X33~cfLq|# z2qIHoaa9!0oY6GL7IW6>2i!1~rsnxs)2B_f}E2Pl&|N`6HJ&IHl{orFHX zDY7af!2i0L7R7@Y@*qi_$HLUtpyV+m6%S*WX4D*jp+BNz9zd1t27Xt0?~X8VhGn)B^dtFmZY* z0q_H(7D$$aq`6&SJ`3>*B$l924z-Q!RTiJGI{*s@zei5{@9#A;@p|rBu3zg;Q9fiz zyp0M6;G|SJ;$lQ^>b@O7!`X2e&SvCYElw0!z5ZUA(Yyepb^qLhDP2w}N7-0aCQv_O zZ}te4ea8!b3a-yz_rpyRIV!U`sibc`K!0u>EH9jLI=*RAxMh6!Ub7tCI(HpyYKXS5w34sND~SSucVB=ci10djJ?wnAZ?c zF7y(!be^i$yFC8=&+6b0r-z?Ayj-uoez&Q8D8X~@spo{V?@(_s3u#_^kJpH$JrrH{4PkBsuR{l?tLl-K1)GS zj4wW`mFO2O$p}nO$fViuRog^>Ce*5sA`@<7LAy<{;1o5qvvARBLskI~v;vZ7A5mf; z$+|kHb>MaF-;ec$ZfVS1$DZUMCo}WWqP4SqU=xatk#uCvV%Rj*c!C)Lkjucnoq<>I zd_8u61cc^3B)}z+fn4eYdCZWP~{ACh0b=aED(HOi6w9d)&o zi=k-t#J6=Zeln&HJhR`y3X%?#F_g1`DhN%Fmrj0}D}c&Va0Jfs2%f|Z_=c{Qca!DO zMz%9IovsDB;60Pg?Nx=DULQTnqz5yuZrmOn^x8}6$^K75Fu_zR8cMSFtaTLaJetm4 zCze7Kxm$P&UCWUu`}ltybLaC#qR;0W6oG!U(){gp86CAFhdy?9ROfnv34tFL@VQ-Y zXi2Fu*N9YJLgwE525!1t%x~QOANy*n>CklqRyY%FiXVNY<+wGm4@)9NizZFi12H*Z5s7(iZ5es_}ni=^iPzQzC7ek^Ad&I0f=rFIRc&+Yh8y;1iA97$7VP%~#k zf^T&3+lOy{`r+G(iw7}<@_HKhl{rlEHsWwWbE{;eZ1Xtgje-5@ z$LVy1rpV?l&H>1pTkv9Nkx6qQQze3ct0_zYa=0?_{_@cu(4fGOrWD4#KsL!x4Ql3J_Y+u}QP%;@E4>Hn=`#m!P!qB&d7BXDTPL+0leXKzj# zn$nxm2K20pPr=o@LX|^6+F=uh-Ks%~$<6)PV5u>cv=8X+ud8R>N69(*9J>@07TqsB z?Omb@09#m6f-;W=YGfQ()VYO^?Svi+E6sI3!lvi(TH^w6=Sg59v>58<{{GT>lZpDi zG&`Os?&p6NtB4uK(=4zaMYXh~b|{u40EE7G&IG%_K(Vq^E4Ic8j-!CZ;#re3*@Ewi zJ>bkmt%kN2U2)H1k22Ve9Y#c|QTvFzs*oR2rVAWW+-#Wi6I;vegNlVoUo<{1D@d;B z!y`F3w4e~bVHT`5tONw6xB62TI#DF)romr*@MOc9dYld3co}u z@e7kmP!U}`6)=W;L79uBXLM%UXMqN$Ysj_; z_@|Z^usT{%8mHv~Rh6JnA}Fc{NPKJ6s#zeXT1E67V98y)f4}iyv{3j2yn^necMEmm z)dNG-5nK=cNY=_&OcRm=K8NoSO}0hyyyCf!vgSk|h&fi+e?h5Nks8I>=m2;F($0Iq zr6DM>53s?byI85>5^6_qGGVF~^&n*tkBK+^?VzeIutMV15=!J!-(;jBzYc+S$xZr( z2npeuRHUlCLJf8z{T1ghpST|-IhiJ$@nl_S_K8U|xeYTH_3YYQMGkj_&a@vV!f~Wr z#wBDrgA%*ZI?#J=!!J%hO|S0}a+t#|V$cCE`T}59Cx1OavhWaDwCVxkJjkIXZMZ3y zPZisF-ggUN@lnA*`J&N$(P)YqO)u-bWK`P-Sb|4V5&imhvZ>>RHCxO3g950bgMrLgDQ|*AV*=x!U<03Ul5K z+&?GVSJU;3T%Pl$nLtGKUB>9icoZuh-LTeE1${suZiap z{1_jb2eTMwme}%?-|56jVuiW2U*bOi00960)Lq+d8#fSrR=5Tx-Z2F=qGnjs@SEm1Bkk$gA$72`X z_Q#`k{?VSdJQlM8V$gcd(;DTTba|fk?Jo0R{9N~^_&KA%o%5RGrL0>xg6X7W9deiB<4Js3l!<1)GutE!wmJQ{vD zdh!(WHTZ$5gOh+blvS_4hoaZp+x_5cUdsa6P;Ahul+$NWMEsB8hsQ^lHR8}?vUc{f zEjMvxVfXmjhd4tddSn1S0*IfpMD|z{^#wg3L}C?Ae|2R0)T@0od0-QA$W^aikFRDm zkVBGc+ywT5!*z3YcwR3K5&m>=V$Yt*#5@t0H}lQ5?wLM8TL1Oac@lELQ7OM7`r(>V<7GsqjB&JtPGYy05dHcoxN%wt8sVPuBGsoSc zFkGH_qDne??}D)CDuEL2w%rY8*}xmR;;}Nqt4B+)%0*b2C&3}Yw#KKUm87}~NUgxl z5NQds%xblo%epx|QOi{?Ok67K#j;`X4;xM;mH^$Xr`LyD{s*(ZIHwEaQI2fAi6nO} zcaC!}cD#UjO~Gumt#;ehBL85{%A=;IF2$?MPT1`QNq}f(lA&h&4G`s{NqkXXH6o?& z^BDJa%0i^%f{?4SS`G!_5@RkP*9H6>Ur%K~T(STyj-B=MsKbX$8QJ?5eMn2o;F&E zj|(@*r>`=x!jZSReX~(y>5k$)MnxN5PIB^@?xZ!S*wynCKc>rnNpm8c92TK~QAg!Y zN*zcQI6tP$ShkNr-CJMKvR6GwVhy={rL|S-nqtZEo(&~BJ&+n&;a*&N(lsJQCH>G} zsyS(*VrHp(q=O>8s~(MMt~gv*F9mHGEExj{h1SlQO-FXw8A*`b~_2qXoLqG#}>amdFee-2KZGiB1U{&7>Ft6)S(XT~Z zcGONf%&pR1V+AEvPwt_d6gQ!)+$6{F{SL8AdY(Ty3h4CQ5t8qw6TtnyI>-V7;8hTgkub?$tUO@)I*tv5MGXtwedNF~nG)@&X%~EHRyHY~vSqe!VGAbHp*$wFAokKw@WmJA+GmK$$Fs#8 z2~hxT0wo<6RzV`BH-|^J15h1$KyI_PViSse8S`$*8Uc>( zm)F0Ub9=hk_fJ)!#^wUNwp8C_g0LJYdo#?iI_d3|j~bPb-b?r1V;ZXe&RrM+3|<$_ zT%7t~36Iv=;!1z%xpJa*OvL_Nc zB8tkMV?qg?L}a)*s!Gwea_vB&Pt%e`$sO^p&)LXXj}w2`r@8&I6Io`wGl)VYz%U#s zoZoR}mb|1amPL+diS$G?ViAJy&E z78V(baWOjmx9bZi0D>42M z3*-vqwL+WT!HJTQDp{(&{sJy2CVt2+Blx0a{S*=0MS>^hTHH!_*b7PlZ*7>JQM`{J zNcZ;uH*mvg63B`HnM>(BRcX}+=`Zy>)_kVw<2cgcygn9=Wab-p2W6WQ=5>B~w$jlm z3`00960LObaKY5P9b>-GSG-9idEk{ziHg_a7CFXe+Z zp78A`#&%OMmXnYHlwCV-+b|HGtzV%!0h$1|yL;=fkqn%xkG8@b8hfl^NBckOE8?2+)L~U^!x3v*{ine%yz6?_R1_PCeh*X9&DI-={uK!ArIElTLJc`cQ3e;T%kj#jZjMXrxskcXWzSLEjkY$_!n* zrC2m0QF6eVV!#7&xjSJ;>W<;Z77u!Z16!Zn^pf9TTx_@Noix6|BMV3nydqf3h%bJR zjICa$`c+>EW<7i<26$^2(iT6Lxy_E?kJYEflk5&$vT&eUBapzcN!emwF+x^Jg!ZOq zG$jwy8$-Z<%$u#xLZ3)yhjY9_caKxyFk$M`hxo{@pRQgakqorvVy**g9*2ne zUBD8d5%HqyO|1u??dZ!g7Of}MS=U^s{e*qEymr-1TntJP{2bN$@chnK+uYj_jj zWI3R{{@JY7F}#m51It|5^#hOKVrrE^CUldoF2+7P+Qr66c525U}yT~zR z&1qWg`@A7LwogsPzqI`sFf8$u&52)yAr656F^{Q$807laRwW`C^s= z*0X%@Rn*MI2qvD?4m%{p@W_gfzLA~jdg&R(o)Hkt#kPz)+4s;K8Tz7ySI~^Vcs3Y`O6@MFzu#zN#s3vsI5VY)mJ2 z10Qq2)vuJ?MUH5yfF%lRs;>+!oVEf)1GK#;JDe^5g`? zU|5$eCUr-lH|f-GD>Y|5J+)R8Gk=juujPrwlkcW&toKdPNRRWB${ht?E+)AYQe1iH z2v~TBpSDSC16)Rk*$OYwY(>PZAS<@|2aJoN^EkPr%7X6O&=z!NvKQ%BP+7}N-6GVG z>V>2AY@`CBQ_Gowto3;;EM);t04Jq?19_klVj083_c?5u{o77Sn@yUZ6stR988-=Z zO~Fu|H+D!3?xL}dGgcdI?krw>Q6F%X*J3S=cbuZp5cO9|*ep3Bq(Nc7?kVyx=DU>a zSvtV9sS?ae^DuGGC-)~s*_GNpQtf~_DT=Ki)zlSzX0&O%;6}W+N-Z(=8qTc{Ft?~n zjF1R)0+0sj>s=v8Q$MllZxV_$dh~)3=i)`l6lbsB`!S*JYV{#YJ`Peauk2f-btI^d z2Uhyq>yCyVeLr{Gj*jG)2-*pc{9%qK;CFDlxYE<>yL*bh>!YU>hW^A5HJsKzBSrBO zCOYl}7XB;IKiOKj-i>Jf0ssL2|HNHOYui8&KDWPOu?xkdHcoSDiw}L65-2I8k4q@3 zV#|)Gk&L9IF6hU1o~v2OGA$UVhtzuQ&g{<4%)BMH+LV}ti^yQcgta6(6sani=^L*nC*xOErbJQ1^L2fxJZk1 z$FFn1>zyuPLfN2rW-(jsT46;D4iX^!$m*W^TTdfyh z)M`2&Jqn2!1O)e1WXT}86U1xG2pQMS^;$g+QmvM0l0u zoGjiq4UZvH0goRhdY(3r@l(G(Nl~<4-Lp<4S|a0uj44biP*c<(86^ zhw{M(h*C)`TfB#mz#Log*<`LaO^gVru7FL@D(^}kv1U5eg$PpfS6nzdb7o+sj{!Ou%d1q zhl(dLv1WeMbkAVoM^vj@`~y?kn@(}yDEwb(4Mk{ZUF||Yz##B+Y%v3mW_dU5QLhX( z$1eKcQ~BVi=UxE2gKnQQY&6{|i(oVV%x+8Rzs}p`I&FCyRwUc6>*#5Eyjf;T`J^Wf zUa#;~j;P7=?aY^lcfdQwV@0wt0*^r%XD|wzy+7N!-a#M~ z4wd)1Yxa8z#u#&-C^bEw{Y%48#jl&kVdVPIz2k5xnwt@D+6%{@vbB@#VVtwMpOfbk ztJ&!P9&Oegfix!=okDL?bujrjVr51fbnCO-(D&MLr1CES00960#9hG(!Y~Z|l_5eA zBow@eXYU@w4;UyS$YdKuLHzeMY0}irG2KPjaV+h4ZPM4|g-87xAd^}D1CN{elZ?H< z=GdcK3Dpsnyes5ZZ?4ImHVp0s-UPoZMhF6R^_aRj>)~&TpNOB~(=SIShZakyOwp9A z(C(u$17=yY7vzlOX68;!_9_;_R-Vp3+ugoc!z!>OK_MHy1^Fn(Rh5)Sp9I4L0!E>T zKB_RXHzvn`@nYgA%!l*em1=4;CXCf%S@9Tqn+NU#GXr9ev{E{zL)Ps{*}^`fr*2cC z&QT&`A*pCV$vm zcM_*GjZLsFiKEz|jY|Lf?Y!;I+Uw9lxi78l*t_1h@y^UM&$MY}^oCpS6ZFiMI$W{= zmu4>*FmjPF@h|@Zn`bsVgT4d_OTe9_R2sOXUoYe_-}Lf+^uk7{-cc$D85tnGLN3&e zV(7-`YP5>4=61dnbH~qG1zGp3xGpb;?w*!`zw=H?uWmXyB0|%0>m?XxW{V_LAcX@3 zE+fwqwjmfd9>_~H3>AwRBG<>tqP<~EtZkT6pxIvP`=)OR+bT|HAn{($D&t&?NpQIK zcJqk;%03D5&z>ZK%jhq;g*M8D$u{Wu2QA2U2L-E}k z-yoylc?`>jS#^;+p5ctpq~z9t(LO%hSBcB1P=F`yfwg|NP!|NU-*CO`0`)fHg9tVp zJR}M^)e+#L;nAEHFgj0Hf;qIpuMRl%SYS2XCG{N1`SdJm%A>Y^k_; zeW(Tjz9MpBJ2Ywan#1goASN80{szg@4F`-Bl9xjwS?^t+yt`SN5BlcTGWvF?$tFgC zQ254tnjEM3!RyY?GxZ)SNodKuE zgZD>4w92y&={C+hTi4BY?^(7@6J%NrN_^z~(ctv>JkqZR(_&W4!B~ac^BkzH5mBro zF8F4`alq|NzPq)5}xAA@vz&*^Zlc) z5(3a+P*MP*yk&{BnU7#Lu0n^o<7Efrv);(f*PNgXBahfa#l$$Xl!T#>3Xr^0tOj&l zgq^-M35W#xCz`Nea~_Cj4v0JCe~5^I2!B+JMPlRf^xK9GIszd@Xvfz_fF2qUCW+gl z;YPePQ8}gbJ3-i$2Tlw<>@>ifdOWJa?FxumJr{y@gWRwDejc2wLDCRW*sPiI8hK?y zVQ-`DcXf4lLC{czer-Zu18{6-i^Ft7JRjA2Y-nnI{3bxO_2?jV3mf$ zF=*ATvVh}19RSI{ChnILVds}~$MWwhV}KOkx$pkl`^HSfhNH`DffTGH^U^Mnc|Ojo%G0ZLEieLvB56xPNkliLu&qqr-rJpejg?xz zeUit}OGON5d;Mue3{Rbzm9)!=j_ts z%WNUGU;phH&OVg5wy)s42F*x-kX*9Qjh-5Fh**Gs;d%L)Z3?h!HmikvU{JO!7mGZD zz!KEAbrettO+|qz(9|8Rb$gpqz-VP(@BqRiDXbHwZI!C*dozsrL~r!8sOu@jbrzqY zS%2pIBRAfsr3a*sPY)?FFTX-YG+VzNBIeYS=u!b7mDR@=<_Y}!2@P^GpbUC~aRoLZ z;5uX`PB3hN+X`PEHxK|Xn!-B75Ig(oAaqI+G^$gj_rzcb>uSh=$Q{)Il*QT3qN<{3 zM#NMz<`MJ25D%OEzyYEyD<;T&Thxq^g8jbLzU@|EZF@1dx((&#!+iJHi(ILuiIWJt zf}5$4y0Y}3o$$of+T~gDgoS4+F-Uw|bRekD)d|Cst?i=ZQ~GdZ^kE?Gq~&_JT+Lx8 z**kd$o0*T$b?KNs+_ib5u9?@b5B_+I)+;+lX0{Pecg!`Q^H$3_coJ?N@b8<-X6sk) z=xl!<|Gqu??e|mDFWnuw%AO0iSLx6*yVXUFaqrw7yW7t_=~1DWWgyw$jSrw5jmP<-#!zF8 z<}cEuUD$nbq~1SC>Nl~Z9s(A(u+mfWr9zRB0wrDU$Y_~vvLZwN1RzWhmRspz!2bcE za|N{IAPyqMB7Gf?Ou(Opa(Ps{4}qEFwGfsvrD;f4D)d1O)*D=-nMw$om+(~pN(;bo32DyG`$^Lz^ z{g%=_F5mA*!r!K2m6Y$2^P!}_XIcN_r2UVO_xH$)9WC7tn5zRvfIgT1Ma$G1FnB0c-Sk(wfr`N5*K-|M8Xfy>) znkr|^EEmQeHqu@h3P5UBUf20DP44|mOEwd@1MH$!kW30TF194sf9zdfi`y^^f6hLI zNdw(V{_O5?<2LrPF}SBa4SKz{q!}&bQr2V~gZuEaB+Hf)x4mwKjnSvlw3Z!3kz`5! z$={s6b0t$$z(kJ>@(2R?TgCMYj^AEmevs4Xzx*dQM0&EmH~n_D0gUgt>`(YZnc1T$_o z?q6I7!PEdcaoa(xV`)k+7Bz^g&3;bvY&KEXE+0(>71M|~aL%&g)A7(#N9yAi>oeNz zH&O`@4{~g&A$oWVh`5esEGPBbf~xGDk|}c6ky2*H`yios;0?nP7~IjC3#uVHhC{=$ z9#uhIBXzkD11o4h+O~u?h6ngkxMdV9ZE4D%Wo^u@xUZ3mW>Fsmq>aba1UW9DTjFpr z80Ruk(6ZjPScn1k=Mmz<$W5Fu6=Og(LkLkT$@dOublXwS7QtKlqo~Ks*2Mol@6D5p z=qH#HWhB#D(fl0}t^_nXZi{>ZkEbXAQjx)c-B5br4j?DX)tWJckRG`oUGA5c>!CiT z(|b)SNz?HnK*l<$Jq%wIL;?>IdbE64DL}v@GIv3t)OQXOU%md$SE#%rPWlQt4gw}e z&r&s!uW2F-_^Io@q?fG^<>_%<~)%%))#qw>ZtKSo)QFX+vSBtS=vb;d4R>Q zEEEsmI9F{q@XZMOZ7G(J6EYWGKxS2|H>^_F58K}mRe&X~U;){!JgI(UV>a+vLZD-s z^e6b});mPZGg$aQA!nZs_l00~wFPKSb?dyr7tikE+5Iz~UC6Zn?8ge5DuF)BNWGD- zrD-{fs7w$|THe?)=Bps7`Qn>hXYA4DTGVjdV;j>Ocxl4c_xUP-TP*hEf&gZvF}|4M zizz;rDMravMvniQHTG8VKNw`>%#-4CKu>02a^jeQF$cw~0&$Ub(VfjXV4npjhDr1u z$bOyPewj`0)ofA}2sVEv3+N|BhGtOaM@Hrx5Xd{O*=%I_9Y{82x5|em$HmxoPz|#| zT<%rfrpYEv<3%XO<%;1CP|!@9MrsD!QrvuucK>-`Y`85Qfk2E4C(5KNQHl5{Ign-g*d9FDs#>kO--PYJmg)zV^)6Gh>ezmLxp_w()w$ zv$l8Mc`l2UoHReT94y(bF|IE7!|&p-m{KiRag)L$XaYsWYQxNL?u^jN<__n*nI=OF zc8^A@%IZ8rNL2(#G+FOh_D?5rjh2;^eqL8R;@p}5F z(H7%C&#^yq2K~A&lOiVBacSiQbpA%%TT?1?ZhHkpuO;eX{?U^cE9n5?J9w+xE_9`%1;82tABrEwN%18fm1WBPMaZrXQN9n`XH>5R?W%j)?UX9P52RmQ zG>;D`h<1YBH^0apW};* zGQo)06XK=usE&-YD<+_<0Egk<0t+yI}6Uh00Hu>@a0LxmEKewZia8*DeY z1B>97AwV8*JxLeuACe&*1ekKzi^00aKSP2T6zEDb!J@z=Le_X*>bzL62*(| z1RPf_=JRoo4BcXk1QMK&)h3_^2@!M07tRAnx=N}!<9PXc4~xFki*k5>z%%l7Pc}$gD@%*i_8Wmc3VQ#ua4_VD(o6rRUzD7^Ge z!I`-2zw7QL(@4jV*Fq;vnGm?jT-DDs(iU}ll@cG_A0PLJ&EZH^69-@w4Tm!`c0`uG z*xvnYr2ns$)=IsUEWRi;WO6S3c2W;<npJn_AF+IUBftFz00960lwC0n z!Y~Y+`9+10*!Tbs;29mtQVCJ18^0&^U2I>}0k$?y)8wowPMzFc?-P_yP zRLzlNne(nfwLFFC3Bz$3h{AJ~9T_Kr`e>gFqU=)J5ci}ZeLyI}L@?sM0V1{niIgW{ z(xdy)QeO7|!FvrcZw(`F|0uOo+418|=E7?)6@uB``s6VN$fi*`qO?USc*F@N@8ou< zYr+af*Mb*OA5;~+Usc5W6mbt5C6LJI4r|TQtf9()imVp4Zw;S8+MvS)@cpt2(VC}> zPOe37@3uU9h7<@Wu0A;bxGtT8#?xx+LPDy-i}WL}$`=3t|Np`~K!ua2LzjRx6YTg0 z)M!Gzj|r`~f$mWUCaD6@F;PfijlP#8xd4k=X-|~IzwMmQcjxb0$&^fV z{Vdf-Nz+!oYtrb1~I_`L)dPx9vUx|liromoCF6! zHhnS(%L>L`wh*C1o`q_CNg;W?pMF0tNt&&X&rS!QhhNJ|z}Ur}Gx~1uEi!t@7C|8TG-B$#;zJ7SJOc3Rq?qt!t^xZV?95M9V4) zPAjjs(nV1ssDmS2>l@#6;0i3OsJR4{R^Tr`6?8$IrG6>KhGi=T4pQSOcX?w^Jt^rm zEDV+xXpKgr(r`F|^&eQ`6eaa5TU>!5BT^`Hgh5DIxX}=^qf7H`7ip~ZsV${}76#!v z(OxT6JeXW&{Z3%*@#`?h%b&PbmJm7%WeIs~HOVJ=vDHDD7Mq;>Gm4z3vqFAS5tU`0 z%SS56O#W&MFYCy6k=QLrpGnu~z?dG@pheE(-69jaJ#$=a0G*)$BF@(G%-?w@JNu&g zk;81S)CO94_ar-Fnu(Y2ek!2(d~Vr4oZ zKavIH#}_79J;I7f5(@0`8n;i4c~7xQz-h_S1^9>wA>=;Cp6sM2v&R+pfOO+Sg${CyX>32sc)KJ@yHZ(gmC#uX2O5YO*g*ezk{<{P}IqiV_54<=A2GM+< z>fL6!O$P3CCXNn=hq`9PnDF7_*~#&KD+-}1-o#?U&!j=WiV`3wQ!Xd2Vl8YcrI{!+ zR{0fA_*UUO#TAr!+I!0b)6D)=t>@gAXs5k?PD zcQN9|S9q*_f2sCAU&eqI*YSmR>X#%W`BQ%Zv&;>I1;YRp@4jYn#w zC7n{AH2uR3M}b(#&IV_j+zt9@OpJ7uj*pbWYj8B!SK&NhQMt(v!Nr%l}^BL<0_qI zJ`gU=ob^69Z;p{Zn0ORvn~w2ivsp*~YwYxY0RRC1|ALOdfsdw41kcl#7Qp($rFrNR zy_Jw7r6I$L;Irn@&$dQC+8S2_0{{R3|NpFA!485j4E>ee)P(o}oc#rF-UcQl8VSae z@!wth+S1_&J9wq=pe$Sa%6Q$!Zn5ssJ77-p){@od%*Rr0W>u`rde|`@QhIac^vGJf zsqnf6*5l%t=Y4tkAi%`D$?w{&&-4TUi4$=A)Z^Cxc>>~Vm(m3~rNHQZ?fE=fMO=ka z3@^)G@1U*#^&S?k$e*il!j_M|6G9oxds&~6GLmPoc2~2Oc&ys~L1IH_y#^9usMcz8DY%Lh1G+b*NwE2{^1Q5?S4P%OF^36g}A%A`gC1Ro$Gf5@Gjb)1d=IwL0hmW#khM0-7Cw*r-_|o0>Nc-G=`U{o*nE& z2}L07gbKG{u@Ol~mtwe8b(H~C#6b1I2t)B2#j_`0&XqvJ^*k52{Lj=lpts^TUR|bOOK3mAXgvtelU?z7F_OM4PsSjqUX6-_{jFjh^5QBXI;sse0jCpVMB=xpqdRC5Q^_n!y%>VKkNYWQ_roN! zilCaD-eu@32c5aZGzV6QrU`hXKl;1=c!Ry}OKhlhR&hqqZL%tDn`xDD;~Ckc3&=Ot zmRaW=&ivnTx>rrA8EYYE(DtT>n-AKqB#>SV5o=;NJ8^4lN#J6JrtbN0mq)eN-^C$}m-7u1oTl>ovy_nC!>O58F5XC1|i%nKA7>w&xQHxd{i_}K4(u|xHx(xp)2CHmolmh zC4UJgf3Ya-SBwx-*GRbbndB~^OvX)(z8p@20BMv0G0VkS2{G|l?mfEPDfHdIyI9Ue zNEF2gajGR$LEfNa{r+pF;pCSbkX)0`O!EvgR#*#<>f4EvM--kH%+T$=a({ ziRmI-E~#Z=mB$i!Qx*rxoA%;yR*vgW^p@DIbzxa&Lqvj6%}lvRM4ea0maU&EU3u7r zVRXC>^>M4uwa%?8!|b5*ZdrA%HFZDV#R1*G1#N6Igjv8>u4VL3Td&W5}dx8|h7I z8MQ6rXWzX`{%d0zZD&?MVYWrb3anQ&mh!iF!;tp$H*xjXXI_677k^9F4X??Z*AWdM zuC=<+S8I+6NN$QXMF#jsUS0RU5wPzY0uVCP`-K58TIO0p0jRI_gae33fB%pG>S+yO z0UU;y3Jr)#8vonyfTT3nJVYQOYpn!2Kr)4$ohNm7^d`i-Lf`;YOPix=H!aVH5Qn*};&_pc#ACAB zLz%=5spX?wqnEPU_vq>~QP*OKv#>q~;|i}~j5^;ZSRKhH``(E^iz_f(qS;8|y1;Bl zhkZ++ENclyJ&^Ydj6)tFw(=XT;3H1QC5iWwaojoNQ*Y`-8v5%8Ths`(SP^Jp2(TGU zlPHT?dzezAlIln*qB){}L?f9)g+z-ENsYv0j5Se7mdS7lM-@T!+SW$6uw-q8Bvz9= zjN5>JRceXI#A(fBwN~PYfq`zalpwKCA8GQr-!w#}Um2oe?%F{ux~Ut$Qh9JjxqDrw zZA2TQy5DWt&fSPaKy)3P9`=VPZ};~PPEIs;+9z`j!kCMR9FzA;gAp}Drc3+ z1~l_x)&w}~bjvW^!uo;-iIqvqQFnotj$RE7vDl%&XM*K?+-d3!fHdi*b&k>9Cu{v947dT@E@&+gAn$XL#_TV>$BkE#_ z+xK|^C`Igef>SLlHSd9SU>GW=cn<*47~ta69|)2WylmFRU9bK+>e84*UKvM5@v9Fr z3kzO>chjE}^!BB?yEhHG`hBYOsANx!RI~$)8g$Bte(CR}`zw2-R6~yYF>}_N6vs`_-pg9@RHb_P= zDh>Hzik}J{*sC@Mw$OL9A4V?|SZdr6HEtURb^>MRg&H-sW*0M^Co9+{Q7byQVwon> z&#^81MMXZu?gL*YMkkf}Nr>*6O=MLhpM56)WY^-s(LIc(7Z*x}&(Xa@3eD@o{l_rU z>VE;vn{*X-lBlNff{^@7CuGk@`A(4`10dcTMbwaFIJ(ZVY0Gt6k(Wn}l@b__UO*;4 z*6Kx*jv8htB#ot(rem;E$g?}|W;AT6m@nWI9~5(vx~R~{8JRu|`3u?!DCZOQLwPwm zpY-HQu4j9#80(Ck+zo@XDUjgP3&4%rKMQQG*?ZhlP4__VjAN-ph z|5fRuT!?bq%btT+2MraYU}RUOwC9Q5vLIMytpTxJ2Vi?zCg8ONLMQ@X>D_7wv#nu` zB0c-}8g?BO)>ETr@JA6TwTpf?sN6RCLpuhxvF;=!&6nB!qetQzQ(Q-FsKxnJF)!h9 zD3viSY2p;IGq4SRnE=*w_Vh{bA7ELal>7%bqnjVL9K*rY=sj61_OkucQ_IFrbl<*w zzJGjjI(%{P`snyyFArYzhyCYoemUsxsGgrJHFTQ#1=IfXueykX%o6il3l&NSOWt13 zmOE$Dd^{Xo4RIft*cF}#^R#~{{kWY2N=UTp0+YS_s%!+VdXFXA=sn(g{f^-p%;H~; zfJGT+I|c-jaVuSHR%d<#+)5DHoaO??IReMn=>+CYc=BgC9FYup+Y2Rb(MNTg9}j1$`sBR0?@D}ghskz#$na80~eM_O1H zWUQc?-WxU6D`veez}Pfos+W;l3o$l8+O)u8DFe9%NNgG)HnquW0>c^rXh4_0fh2-P zZ*cSAm&VS6AD7oZ|0I7GCI4xG>cIzr6f~VHIpG!rg=MCfqp81(;=#kmU=z@p4-mh$Fi05X?Yh8|DC0OXX$@EOV_Kg z0dJ2yvls6v#qIy!xJMvzy6nTvcL}nqBlT`9%efMj=cByDQa&TM5QM=BMkktwAlx&m zyQm1ptK!|MjTIbd9i~hFR^2{*sT*y1;@cXIX9%Y%=2nh0dG`9v@h@+lzkH_t&I_wl z280SCbGp=UItbelwW(7RHv}?fzjhi{7_hJBkUKjE_t@vfbUqm)B5Q?7%#wgu{Ml+* zSrK);E5-mFQjiz=wqCAQA)ALNRGGJKW-q2CW;#h%lywBHw%JFOozIK1U}2YthR zXj!(N9l!0re%pWcV^{kdx@5#Q+AD6;B4=KcgI?D@cskl>!>;Q4|~qVPG25 z4Bh%isda6oxZ|?*Sc!`|1ujf^i&e!f5~VF9*U$bex4Olk9V>642FtHckjG`WwR};e z-`bz%Oi!b4OGgjn#gN%iAo{#x*L?=(f|b(zUjP6A|Nq=w>u=jO5dZA{6|8LxO&i-t zhkZ%l4q4G|0gSC{I$&5_xT+;LMrFy9YKfS|QyzH}sy$9w!P zVh*oiv+5Y49KtT1wE6l2xtRt@Rec~WI7Rg{sn;%xzCY@#qPr2C;E@B(7m^=^3V<`QjsbDwU3 zgl2WURDg^;8ds&2-4j)}38sB;D}Zx&iikv6Uxj{Kj}a$x=HT=m*;DaRmV z!CLsIKqI7sfotH_eucOp#=!%A%7!yIE;pCU^%?^VLsE#dL@cA(8;D{o5aHq0%Fl>K zWB@CS77Ik#Q0(4cZSI$3arahzi*6<{r+o7BHG zjy2SCxKCyvenc3pEYn*_n^djOUls_@>?Ln z>`i)fzm!ta7TqmlP;E-WZ^%Ct1SAmyvW(=Z;KEtQY`*|Yxn5@9J}0RH8X>8VI36Od zL6&*+D}#L6fYX4Et^)iGrO>rlEN>V^9bFQkP`+3omcWo_(FB=*4j8KL>HFB|`e^J* z9rCdzr4nktG&1b!N}l}7bR(`uISpQ3%aaUz9yb;Hp;4Y4aGYZTdF!B_9op6~dKJQD z22aV~>R$kr`L>uRCd$C}*|E-P>~%Qrx|J){tg@0cjD89-g4>_@u7CvO7x~sr1y5`r-q)vR zli%LH>WU-rTpWGpfYPs)<%}!ILCiMA9Q>}`c6CVaJ41)uB(-%;O2Np_YCN&j0%XAG2=NDD=@cxOiXqJ z)Jda83HFJI!nuP3KJo{K?l2v;E? z*ExUp_Uw&6qj#FZQb;?jm(p#rZX*7`5BcbankJz*G+9{XW3f|ZC8cH z1=mc*9&q*Km;$)edm_iiXuCwu9&+NC90%u@lJyTOIl690(T#`k4bHNGq3D>o84ToJ zjkl}yKy~+`Ek!h_rP)2)XqNBO45O{xvFm{3eaz|{ZG|@v^mwoB?GDgx7pW+o-Plh( zH-@_wApx!nb5EQniHewD)f2@`%6$egP4bRa^Vb(@Q4-W@9f4DP!DK|Ck zSg(GTXETUp(J`iuuEGm9&{!s5Ah0OlAWhr-Q0$6BD~(KIQ4L1qP_9wwuj=Vu+X8^> z4By)kyr=rL*Mxq>=19G&gvx+9eCJi*qgCLX!21KWbZldhuV&!c%4r;$my@MyBJ`Nr zw(M2<|3q)udloqi?#(afXTOU$p~x=D6tzb>oHZGFRzNBP)c`~#llc!N@LWV!`7$=> zwtArG-mXKA1&f<1dJHPB&>G0m$yUy$m53H)Qd~zxyg3xf@YC>+65E(wpgslh=w$|p z7xRU@u2iQFaxoUvgwBkkqMx&JStR8x)#M03Zj!?JGR)&Bp3Juegt!4nTF=!(Lu9h5 ztKvhR*!bOQN_>oVM+{e3?LK~cNL06ypUaEE22=^^zrj|DtD`u%8f9B4F+6|q&Cx+H zTZw9Zp097wuOUh0K1gC0d|FSg9;2k}Le6KYao8Vh!Si}weFg`awF$>FSu4~Ex2eg` z$W*q?VTi?OHkn+lTwZ|K5ZZ&G6$VP?(WYZHAH|V2XK9uf}IqCQM#defHI#(Yp{TK zB>MwEgtY7{;taTF4=7&!tgyM6l0o?E@N0MY&8SQ51qKQjW}A=cq@{TssgjC$Qkd3> zTzFK?IKR0t+rFAN%@j0)+p0SVb=!r877AY{JT2jKozmD((Sb!(9y0Q~=x(Wr)bmE5Z z+p-tLl&0qjnBFYqY8HyX%IGwup{PwkVbV|R!v>uk68hJvg?dOA!ac3)I}yCATR-AMVM zUoVW)uF}F#UAytm2G#4WV7JGQqv{1{#qL8NuT z6oj@0Vx+!(cYe<7Pc}7e>80*&A|7^=*_rcgyU}#{62U#UZN-;N@$DyNAhu0izTqD; zoTYN4;e2`r9D*hp1kTGuCK7eg8i0u|c{+zQ-8UJ!S9YnOQpisuACF&4L`LgWsJTgO zJKFIDwz1@a$}ipNabkf*G+Fp@3`A3@L!siDtPYshzF=H8V0q|7)G{-GTgC8I-Rf1r z%$;?L&#D+%x{Yt=8iYDgq-SSdS4v@=2=gkyt<@bUPQVYvSv+flFwU3j-Q&7j;aBYa z=!C139vCsk>FxG9a)l~4w@9%>`Y5R-u*?544!yE3;i~Zwjbtbj*V1D4RZ>fPYEFvJ zlDmDaI!Lbc_Pe092`x=yfs5)|Eq*5Q|0(=Sd4Hg-k?q5W8Cp(_x+z>?U@R2&88;=V z&^S{q;G{a&_q5|m%p4T$gKyFG?Ql5VBSfUFG#=Pqe0)B*Hv_-hvf_h`2YE{o^twNIex+k}m)N0RR6Q(uoWJ00960yj|N) z+dvR~->-0uB@=3lP~WH`nifi<28cq0S_vs~NC>VH8`-#3iu&)J%iiOp>O=bivAte< zXLr`KXJ^jnew7`sj&}{U_VKf=CeO^b)&B3beuqm?HkF%5p+=qX6j>tS(RLjOw(Cu% zC#(OaDF3d3+k3jbnLGQFO$BdPb}wLCfQgMMWpY`eG6hd%os%npanzx>dr5&D@qfda zgxl1KtT{1;P9jN~lSn^8qH@wlCOKGUc>=ajQk2O-Is>Cbd(E_8V-|qTYaRV^X^OG_ zN9vJoggcv_dJh@YPwWM@fLQLL=bQbr8uA#9$xO#6-j1htIu>^Jv_^ zJii(DE{B~Ux;-D=^sleP9^5-5lC|LMI=H$XV;U6pyUjVf&MPR<=ltOF`*~f{LnYU@ zhPD(7xL_X^10zeaRpv6=f73~Yltdg!nZ$V06>a1Y`w%=xS0{gv4^IuZILEQ`G|61# zZsDZDUe3mmbwqa$IAt%f#Yi%xte~lGQIa2=Yiy(y zC%O7tNg<3}e$^_|nx?S;A-Ao%k^CXD1*jeT5uD?^ERcSde_@S;j-oeUp+A`$F@C2) zpXwSN#k+49eWNt;Re{i4gL6RjoK5p({=9Z};W%Rpe&JZT>r=t#9rP&{QRzys;*ZKi z;K6xBvl9Lid;-PKQ*tcyH9DzgFOt_8ed5b%ZFQ|uPRhzGw?6G<*olze=-69N#o>-+ z8LZvR4z?GK>MhyiRN~Af-g@)S_Y}ViT~}e{pknXJXEIwBs2Ev2ipR7Cp(0hnyi{dF zJNUYq!P#Wce?RJtzD|a{@h63+vH?ZBjzssUTAsE8XYtll6?SB$pArD(UpHFYIdW11 zY`WiU@zVhbz4!?yNI2H!iI<1s7m@<#My)uKA3=+kV?aLm9Kn1j6siuRp=y|A4$kL>#FIN%!8J-Bh$!-r-d55vkavXHsrEodQYqtDBW&1OU$U(7@9tWo3YK42| zn8$?pW=#te20l>I$4Scb{Gg=my5!>@OB!c5S&jvAqQ{5^7H57Ldn!7{*!1E#FPizr zohT+!Y~Ov$y}<~pTG?vtaq6mNfCDgqeO%UcKE;>`{~Pxk00960>|J|T8%MIwztN}Y zmDm+HqY(n^#KL$N^RT(sJeJ4WzQzth8jv=UMynZt*^uwP^{c9$?iq=Plf8RR&b{OW zi&1w?KdS51^nd>~2tO&x*Dl@Pq^!ZO#zW{R14d~6>0?C9NJ zxz)pfM~)s{e#H!?y8YT&e4DG2 zFz{iN3zM8aFg!S~n^$y9Myge2e(h-UZral$E`I+Nqb_vyJ+!@DUzk;Oj;WvLzc7pm zt;I%_w@|47=i=KQ3=fOCfS(25+9#%tbxT z?r~pWP;Q%MrUh`@qo??>;VrY)>w&H_@+LlJM0yAmISTARLW@*zO41(Fa}7IV?2x!m z$eUI_VO0iM32bR-LX1SRTX4}~wLYP?E;kn|B9N>jj^n7Xs*`?L%$dQU{k%#=udx}) zC-N0)?})9xb5p#~MenRxM&v11*$PWZ#P@S5qkP2+e$HV0lEp^mirs!YE2Y?!KN56d z1z*UL)$n|s)E8`8|FdQT*uz|vTm%LFEKPn%tT50~%Nbwjv->1GlUWAV3%pFl%`$eg zQsk+)ITgZpNGQ&Wdonr~m6d`v>J<9vY+JKTJx-LFw)dzaIK$lIdU-Y( zz-VBd+=&z6PmK8yW(BjmzqwT|x8%p>Tn>rUnfG5ds2fY?QV9xAoc7Jp{li# zl3qIDVV6+!0Dkb)8knWo1J7gPT|f0;b|)(1SI2uzD%~)PNkC9X#k9L|uZ^^G1mQ9k z6O_GW$YMcwEH-02N87S}x*r84F3s1rRp&?;m+iil z{G>&2_@(hUi}_{kz)u&1w`oL)Kp5ESfk-UW8q*Xe{ni+_(*qtb*Zwo>JMV)GXjY)A zVnHFk27)m!qrGk!PNyL$SvtJBscW_F2P4760CO~#-gdAJM`Tbl!FxNeK|Qk;q1)g|5UyM64Y?v3HmJEokG6&#w7%*!lk2smQt6xj|M}hi5Q6nO!&)P3Jgqb8)moD; z#F|I&2L3m_W08KofBKaFrJusTD=SOSzW=7tSZXXco;__WFMqSxSYCX(_>K8pEo50qV06k8UJy?EJ=pX*_@aJTTODk$*4q?-l<2lz%_t-{14^=Vp5x zfr}l*7wI)bl5N~>GJOin&akZ>5WU2|%DkXH#NedIs)3k>yHO(CJ!skINIc$S`+S|) zIZ;BA-5|T9nm>b+a75!lVx1h|)gcZaeRD85$8GFe5>kc;gQ7R%36WCV{;TAGQO_DP z5%3<%Ay(~L;<(m%V$CCP%%gv!Po-8rKfHb_Z%bL&b9zy`ViFOzV&*5O^^21m} z@}a~q+x^vIW2)Y_iUO2PEpq95BCSu-7_9=vdPIDXFx;PXq71tgLm?fyvG61qYRDB(wW?7xEbf%&7Mo@-D_IIbnlxNei55+*2DPc`(8cqd3CpJO@=r@8 zm*b4_IAT%Y;sbJq-DE?V z1Vb)NLTpa4z7P%5!6<8c96?dCZg;jU7&{)AeDz zK+Ap@v6gi{xnz^~3;Ix#7?Pi&zbG9bWCfBqBgLOf4yUddr>+#I1bZzW&E;5Rc@_l8 zG?R<@&<%It!2DFUxA0KSCgKjSgZh^wIH`V0!<7al8 zox82h{Vdp4V`#rr>wmgkO>R#^lz9wM<#FydJUDIO;Q;}fqu;mHvtLRMi|CE+kL;!T zH^PkMopm2(Jv=^b)B&d?H~8f_2cyhha`7PIgO?btDakH5oWe_TP4HI%vs<97E3eEx zikyRkprB^SAR@|(-1;~_(nBn}d>bPc4!p+R)Alaq7K6<+VCl5nz*Rj5;b6r?t)vGz zCT6M}(cAVUAWSScPe>XfuJ?pT)?#P`Mqi&9H!N?0=wxjIU`6al$s>S*8A)O>XVT4Z zcg=K18Cq7%n*$ehNH0iCZI_X7sEI?^(~4SNw%c48r?%@T-x@t+RGj&mPAloYA0%lf zo}{k&gDWfOwgxS=p-2NQZ)52F6PXOi8d}OYzU-Ea8;J*kN7TOI*tj1jYi0dtY7<~g ztvq|QgXF3`NN$q*M@p@F$)we9k4B6U$b)F%r>FtbcR7N!8WSf?84Je10z*wmp^uVw zYXsTAK9P$(1oQWq!6QeDK=HpO=*h*6Ln*ZIrivqz1gH8F)Pu{izewKbWs$^FAzKCF z_q3zSBOCOg6{05N}FcPht|y>1ksy9qi{lr z^(FBzBma$XC9~9FodKc80e-dJP5Pg46q*jQ*YHZ#cDJP}F1_K+fTSMkaRPZGogjfn z|0ZBz|JBi^Y5(vXC9y~*Y{3ADdsOyw_I-}geJVAB#XKUW9i%!;Vp~H~At-C@MmOk> z`zDFe7062=i?Z&BvwTOyp@Xv6B>%x{xWnh0yNkeKa(2E5#pald$Q`2jNoETxO@jCik(F(Sf`dPZFfD-~$Nrx_1z4GHzH$sWWhqdR7xY z0o@y%0?sYNR9pN&iP0x*WS=4a(v4xotB|rUo@+QUS&dcN31@t+c3d9HobHeOPQwm> z7(!&uCj}-?;vWVh7HYnK;wwOs8@udS1`&~9-@VrHw)C1*J~Pi+G)V@DzES*f zu{zXaAuJW5e3k2!z3N4d5pD(+wd5qd8wFX90zUpPqP1=5HOmQbrfE)3%jRXiNvl8V zw$|2PZES9BzkajxU;q7fcW?jTuZKs+Cx3hQ{=@&Y&fA^n;MhPG-^Ut;VsAFm5;yWf(s%WS5@}==p~zQf<#VZc%ZRK6}Ak?i-P<~CW7B$ z;fn=EgktmvSG@}@Xwytp(ihd|JlaDYNT;)|v zXEGS%t4T5MU`I7?Hc;;4m_(EgA63hsiMcSh>`AYQi|%AKacrviuQa_ix9G3>pZ<<*v%atAr|5Gy!;x0FCb9zy+Itw2hvTSA

}Q#!k7fq}@l@mpa%Cui~~|u2yVB9xZ?|uMqmrr9|{1HocA+ zitD2OInYm9W7r_Y|JXYSr>Apu!fpIj|2$Xk=*K31y!Ben)lHKczAT*X+0+9pt~**N zWuh(12kaEBVh0jXWgHF~ONaEvR8%Qg6xY+@k&IF?|eRBf|g(kymO%RLzHO_FSv zuN2R@5K_QUkzCx<`@~YN&kLxsN=^6x3s7 zqu(2G@_9)s(M#E;Dq4V<_sLcYG9!{pDsC?4kpgM=d7IhQJ}auyQx?EyiWH6j_SK!k zo%j6YngIy|Q7DkYwa-9k0z&6#PG6|~a3XOF7lbq|B)CK&#QBxQ=g+LPTM^*T!X>;Q zFh4Y&FM%fO)2Eh7_LIy(2l7AW$!}gQxlCBx2l7g%lh{^?$Yf`gCQ0s9OJ{ibdG)lr zN96%l4*NZ1QaGP~%0GusPQ$oqNkUSugimq=!Z2Al%^;T;_7quABzQS%+dY=fDFm$f z8k9=-1bY)ldGKEpLHhmkO6CU*AGEu^AG|)AYLs;RrOvz+9QZP-rTfHxqc1LD| zH)5TTa$}bDMwnePr7v)Q5lbeP$M0~uY9gw7=ghNW>S7og^6Ko&1ZbTO zk`N?}E0er=AZJQ=npNc%Li$s^U15yEYOfkgp{%&Uw@c2P?O!S|3>&BWOcua*s6%V< z&jJ4tb2lgt>WCLgYwu)RvHr>0%e9AxR;%(N5AaO@0O>& zQ$}0lslSD(Hp;m_m-2ru&*r&mF7Ylkdc&`Us#cbnTpIWxS)eit$NdalX~>p62#|(U z9A!tgvx_(;is_hd*sX@8EXV{>Cg?UO8w|mzP&e?#;Ux>tP$XjQke$XHIH4TUIf3Qx z28vPkeY2XAQ_D%fRQx0IX*_8L7GzMK*2#)&2sEsfR>51+);Yh|O6zJ)|M;mO6z5*{ z@murhNf78E3g&`l@Q^0>e~nx8q+~S7K*KcZ(^7AEc79wqb1iZr%wqD}7M&MHqxhO- zw^;56;9E>`Pu7aCkanbvA|$v>Vyw(QwdIW)8|M3PQRMv#{>8mS__KPNn0@pWirjfP z)6cv7T$F4`ljC@JDMB1fXHDBH8`unpGrsENdTZHDqR*qvehn6rcmexfkLR zB-^h@x01j2)HLq|6ow&-Km4r&TX>FW_>xm(rY*StaVykU5;IW-i6(nrHfWmk&l3G} zT4k4U>xrj0pyo5ioNL@YURw%i?+fu6&EwlwK*Mw9s(S8fIA^v!R4_uT^T z)0+b#YQ5I8m69vkL@OI8d0?@TRwTLhv8J2*tcyPV!xbEXK2 z@50;vU&=@9@B*gL%$&p`n1LllrDi7JhORYu*%Z8!S^~L6ZkV=x0ZPHz97S&9rl7WQ zA(2VAotuKEor`27+&J>ah=^&=BCVRDs0B-tCM)6AAi=gEXyYqtISZ*9ky?PjGFjb7 zM+JVDmjbYmQqa=ZN8&5Q#DInnkVHTu2XJlylvS%vY%`Ip))!`wgUUK^-qhrRw>?83 zc@?ea?gE)%gp9jjEb&bQuS%p$>R#A+b=w8CdX!nduqnni`mZ%9dPkxddta zAP;asY=PJTtTI45yHXQVV4GUNW4nkQJHSj1bwe(BbNr|c#wt0nV; z7QB+x3nW+y*JjtEWDUA^j#m{@!j};Ig?z5dSh`Yi{_MMBy?qftyq3pgOip4(?d-Kp zu+hm%sSLhFFP1h>n3byk349lvD*MoRSy-e4h#773|i;H1)1*iKvQOLO4V%Rcj#)G$q^-CZkv#oqqdANzh zeTL5Bga%59Z--4g4-Io#SNoN#vZoBCf>6OZH-L_{;PKF%``N#^9+8ZMM5F&j^HwGj zYV}R5q(tyL(9%<)XOG0so*F^3FLM(eF^9YnJ^)1YI!Ayr1Z3=yG{@3t6DSKBWG`^) zH*R-;I&8A^Lv_qnGVo<-b{ceUPqJ3IU4O`tzvF}jx1%Vfc2%+=1s(<3J)*eC`yY`^pL;rv3z=W55akXNnhxmJFk6%+H-UW9JbZNQIm89fT`3+S0aghIVpqTl2reRfvF}{jj%>S7eIkNafM| z`X;FdY#z_->EewGnFqu;@H9%6|GyGe4-<1RIs($c*(AYrR4R2(b-7vpOrebgaLen9 zt2S4M@mi`Jb-%eQ!LKRDR|Yd>W7`SE_p^bHKnp;^WH zSCZ4$2USYWs?bdcW@JBYI#i;;CBLiU&qP79YMih}7lXqQ+NaeL0}Ovhij|XTh0GNr z)dQ;I^6b8`T=ZHZ8t<#YA5nN;>buoy{o?^gL13~>C*sBYUNP=AC+qOn$@@=7LXOVU zEB~g&4+Z)<$i`kZeM#^B9x&0q+4%KW+k#7lrOypJcmJDQz=CJ2D!1DwG6MgbeE*oq zC;QzaeZ;l#gYc!9zsld7;ZJ4;9GN)a$i%@Uo0{4=Q_M_JxNYLEhX-*C+V^2)a1H4S zeLHl0ZK)pQ|4#JifRE-qG7I^D&`hTXaJdih;nB8>ibVSZ00960>|J?p+c*~g+x`?n zk|K=}xjJmeX)&11WYd{qo2F&NTyTdVt0tNT*pYK-!aYhGLSkMY*$t!MOW{}>UCzxKagAq~HK?N+_*ft>^? zqiU(G`y1)~{Pn?CwL;HOQ>U&XLwo#Eo1zwVMTLoL>E^z%1x1mzzOGSzO;lIz)${uzda!}gb=bf7Z2{D7yGM?sgzs-E zdo+mfXTC`030}xlx9+R!u=OkVhEf1>aURm(Wj(CI%R(Jqs2%XR^)#4F>=}F-YnS>h zo36v7Lt*Wrk~q{C7H4~+GLCIF9h`k`ZPhjXY}J|gpe%4bd46XIfni(5A}cb{DW`$ zzy9m`zm99Fgh>CWXcbzHV3Jhgh$o$88xQ_%DDm?4@zEZ(Lmtfv6=vK)H#C|iVkv;n}X zn~q+;Ce=+!V_3JXu3?5nC^z{7D-LiqRrWoU*kU=IhP3vDixuZ*rzbT@sInKq-Q{UNr+RnEB57nJ*|GE0kUdT(< z`)cNrZk8s#)7EHV`&QotrXZOE4#su55Wtviy#z=-vt9z)%J;1w(xOEE(<2bzc&_W% zu8%GK;{1s7^-Xn}sXDEC1+oa~CLBMxg8HX8rM5U#8mKHhzZ7G`rknw)rB8BmBiphd zJPT2|FvBs-)iIq&ew|MFP8}CSz2`T&dx%`dfsjN(r;?(&wgoCD3L0OqyvwMgJcl_m zLUg(%jaslHx^&rOrG?hS(6K`rg&AFo`fIvRjU6<0UGlh6jPGAgNq;fSrooL8MzEM_ zH{R~FT$FaE)_M&wJhhfgNTN73EDxJM9YG!KBT25W5= zjOUQVqP;D*P-WM`Qtz7_zrCPH@p8vqQHC+wxYQOAUKnf3UGpI4Tjnr(!6&dNiyi12 zI~(H@op_h1F{OBpEluzNlu(}5!j%kqVwuhbvx4zjxfDDm=rKrEKjg?V>AseJ2(r$P z(WO-FLFzIh5D{26&~YtA?VGHg1ouV8+v0)B9qvPKD1=r@$fqfkmYT4sqM$=+nf|Cs zUkYjZDAi(ez`Ce$awMa*)Ja|lt`wHjL9?cxJ}m^Zs}_{nhxb3fJ+V)Z-dwyqI(~og z?&O_)_V(o6(fe0#e*AF$^ZEOe(>7fsfS{yoh%W!}#l$4U{r?*n<811k9v1tLlXq`U zUf(C3H_zz)38`SgnI!Fz&@jt&`KF!|_>OUP;Lxd^HQeuZp6&1BX~HG8tM9h1l;Xo3 z$GSXw`~KD0n`^AG_UTK^Eu=#&FPaQTuU{RVx7)`LbrAe?Y5T0E)1J1F?b*KQaMTB* zRC|TIqWeCd>%n%8{3Y^N^F+;0Jr$~y$6av3Ir0e_;a3=5K@uZA<-|9<%|JD!fWcRG z&|B@co*-YfvBg$%E9>cwhN*k-Q@M0VYoj6rQnLRj+EF#foow+oh$}Gu3jPE>nCtgoY)xOQ`GHXH*c`45#!#ZiJ#% z!7578m~DilcDvOKX6;#O7d6e)2CA$`SLY#l8TJJqDAR$hz1FsMLF)V_5gpfv5>drT ze|7H8Mv7uuMOQCaP|Q2-j(Rl1P{eAf_nSHkT+Pz^EBHQGl;a}~0qyqz9+}Q~NaMXx#4%1o$ zfTXL6l!77rA%&isNQBF%3JMKm6eT=-cH4k>N8yLGkf8$_M78(KYrHnDdfV3>n|^W4 z_sYZlX#SciJhvlAy8SU(V=adEw_MxMO;(mk6qburoCZBp>up*x=0s*Ac~p?Ub>C#@hnISbV>`)4r9tmUdD4fNmqf? zUHDkG&NsP?f+8A!kQ)2DzNE`L`?5bG5qwD;hgWx-XxHe{+Np)YT_Ff^&G&IgbMAdb z-0j%UY$XPdUn1KJb;zTtu-n_#>kvvdAwae zhO(JtQnlKZdd@YxWf#k&12tr?-NM%g@md{fcTE?-N~7a~j+zthr3E0Z>P~f*(#^JT zTdHM4o~g@^ql~JZU4$Q(Ad=`X8N)zFWH#>m9y3fMHdCA-VBKxmFz+L`1K)9o@D(u$ z7iGXPq)@@3-gDq(a_RZKYb5{`bf+Jat2WXOV>3Tk;i3P4zTFE7!kgPNYSj>5w;xCk49?&>l zMk+ZofFcobPtrvOwT(9UQHp2Rz9?o)NASdUn->zqUae^d z?17-r-t%Q4^%a9Chu;iisX+N;1ig_N3S90BW=UMLXt~z$pyf97j4TY47tsCHU_(-) zbK;XX!+{NR7x>M_*h^K?`i3;W>#h2al-Fy>>pfB)$mm}7aMxG_OYpR)g%?gSS1jX^ z@vf?P)tl7-l<_340;iE$gQ1)vu%L-+_pxQN8vGAp?KDcxdyKs0WKQz_umEW4Dm_4Y z-AAPc(9Zgv&J(7~bXvlV!UbD{7at|exOy~Xglvi1iRJ-9rmys~l7 zzZ@J~8$t#>OH&O&=unA5TTR%Y*AN%`{s*tC(wgG{8RRklUXB*mA(P?dVsy>q3IR-C zTaZ?stDJv*kL8VSp!A3u_txMg4Tzm4u7giGOnf#L$S^4~cd%YF!%Z~7(fcO%9Wqwz zJR1VWve4|anPq_(Zuio0uf>A7($r;gtK8w^k(|gsK!#{IAmfmY$~*Js=Sbs!^5&lGD)HoY_q9BMg(F`;C#Yg@)1OQWu zjZr8>I8wwy2#8j5yMv0R8o~td8qVps3~8Cfv^H4s$mBpTH&_nqERAGFMF7QV&>Nn4%{y;0=xs>)VX|W-(--fy{*FzjD)?=3vye`H8eG4W+9016MOEh;bv6f*{1RVGib#kAE z&gOt$ACqC4ONa3UGC=Q0^##n?SW&L0T|5S}r!sN22E(6@UH6&mb-z9y1Q~crP(?X} zD5Yn1sL%)3V)eh5n0*=n;y$;V6^#zJgFa<(uBL%;;obvp%6bkFN&J(R7Oh{h@veFz zfb`t{BAmO(q=3a!caK(Rb_=~QiMMa^n6738_)-iiAAk@~y*)xSw{-SaWNld`J$XSl z3X_{9Jy$c0SY19YZ~|0nMIA2d;ot)*Eon8EyBeP|qsQnm%iHRyDws%A`g-YE8UsF2 ziXfVf4gdIw2w%QR?%SQb`enzx+I_BG|@|jI8imw5AO@s%q z%`numnGXGdX(LQk3q0sm{u-3kolFrLnALwiOygp}corgnC3}R9yaD-(F@uv<0n1WpigKAQ0 z7UNJ&8c8KAYTBf6C_GyCVhCz5C`{U5LmX;yF)pn$5y&%`1oYLJq!Cp3wCRnIw8p|1 zb%V`svibM1^_>PAW7Q3|!zSBC(g}uY9>J^|40(ek-()h%L$K=xLtP5v*9|6staUEJ zu$ycMS{savV@+0subPRmtoDv0-6z0U+cA-=vLR@t;DlbaE7TEo%{Zw9Xod1U-9A+9 zs&Fmw5VB?JS24K8XIvEtzv^HNW-AYbxpkX#&l>i!4S}x~!q8V)a~QseDK7>_&r!_C zQQ=o*K?rQp(ozKwE1Dp&STs?k0I_jRy0#)d7E&_C09l93czn`$*rZ3MWmQ>*gLP#A zuv`;{h`Hvl8dl7!Lz5nv7Ll(YGuu{NlEwOaC6YiiITDQ4&XF4O2vsYpZ;*XW4m34X zVX7~J2~acwaAF`N&QzeQHDPjPS<9%xSnc1GUCVZxFc4kmQ<_ts+7P?W2Xvi9w%zcu zAqB&+a1QC$cU}?#jp`(eprCt4Z)s*Uu{ntN4 zBb`D9U3Dd7)7F)O5b^VhF`R@0Wob!%aa$VZGiSx6^MO+bz^k|%Gp7p zxs);Aayn>gqyxkfTn-!b3K>Exf-E|;e`eU`F$xq%`qBwKM<8(E!H?OK4)U_P4aK2p z!g;n2Kg_%1G-q-h<8u>pu&>4ovD}N8DtmL6hNTM47lKoj#Y~?PffawU0_fg4K7f?1 zG+1crVhowypkB3h((7Lzg85p8q=3RsSKe?jsR1DS{9JR}q z5YQGzp#_^laiA1C2|NhK(~=T}l-whw8Y{g|d(vo6cWFnBc8t=Xi(#DJv>|wl55WUl z(n?WmVF$EsaKzm~qwUrwTh*Q%g zLijT|LS6DE4Kzg?R%UdmgpcTUikTMfBBYSC3YUV@9ZYF?utwiC0u+Eyl+{m0He`DR zQ54jU;&k9oNQ5l5P?&}d8+%j=*D?|-Bl)b1WR}s6c;KXR6CR*&GrjFYDdO#3ATquYKb`CmEHf~@BXE?mddv?eo{q1*!zUez}ZPi%NnMH zMirmh^bun%zqR%(&wDd@>_=fg5+>3s9^G$bm3RFmuIkLX9sw;0J!v6>9c=VF*q=BE z4p%?V?hYQYbC0o>Xm&@MB`>eP_#U)3l}qsZNRz8;QyA0R^$Kv2d72WCsf-l*-IluJ zxwT*}#Kq0jWXg$+kqCJOUo?MdIU%K?7uWT4o!en~-g6h(kZLw}+zLINAueh3KJT znQewYak08gq#F~b5$y9HdQvVxmugs-a==w^7(R2FP#9juoKV=X{a zABJF4k(fYn1JD2$L>$2csW-QXwS=mNGlAlk#t=bEW9m2y9L9#mX68^oqljpdWC}do z0DC}$zbr_Mxq?LSVqw^#ED#%5?H3p$DabEQBj6ZFIh%&igRNA=&;eA1XiR}t(!iE4 zgD7l8Bt!*7gR+9BdM5v z|Gq0}Uk1q`&`WmBN?NR4^j5t1aq<<(70H9-ikRAiv?5ZyK0frK)NbKl)hH^UA*e8T za3&8;9a4Jk(Hex|rq~z&I(#zeVJKb&`?ueLHW}6Xqd}P(EYh1u>dF20DO=}h77M?I zb%b`y-dKFFCuj1Y09D@Ji5Lzmjjrp{O+k*>jrN$L9(%+|NBv3F_kwc8MF+j!HK&^L zhj}J29R4s2sJbH;p&--gG*kx$M>V^*kF6pLHb&y&DAyqb4;+xywp-Vgs7*stghffN zYgEls@=bmJ;l?{ESD%23d6LSqgF9~ewIb>>rTRi>kO)3b?y}xSH_G@-!pn6U1{bf< z+pWjy+CAq^xjfg!F%h^glX?9(4u?RYuI4^Q8ocLvNFyem`$+|aJD=UYP1zYUk@GAH z^Ht3%Bjl;O&AiG@vXGzyDwJ4P9eeZ7#WC%wO?70XfNkl4VTs-q%vOH(!o35YFZ3(< zukscOx8dPyCZJ_`Hi?KWMUa+MeTl1*WEW|a=OweX`OpBC*K)>oMb!!QM+xr=YrH0L z#!>QRtWJzaIKz8K0gTv=nqBLiYoMG{K+QhS#Pb+=Lgjln;Qh~H{)@+3P2rjQ^!H`K zU16w2fo27FpAa+%h1-w_&~2uhe$c#A1?P<^wm+f%j({C<%Y=R*F^^4Q4yf-^$l_Hs zr-5Ns_MSr&dN#0AZ!rOB4J2` zN|!MxBL4o28WV#dx|h;$qf8fqSrp?cShxMYC|S~mP{sG_9!o_DTU}@(nNszY@X5F=0Tw) z*g_5K0skyeUA!CH2+Vo4F7v7AXGF&QXn+#nFQ{mEJ?xJd52wlRWGe6)QBsiow)0t- zs`&H#Mp{gwMlBgQiptM%IM{*8B8VAOjREXn*+0LZ{f2L}Ic>Lar5(hyRASnlyD3GR zS?J@2%Ms`9A;v0RR8IUCnZvFc3cHEpqF`6B66lZhUV06g@cxHzZ&fBxBsk z!&keKkYsiN=g^r<{KKv!guK$OzWsy`nrS* z+a=X-4heN9UKjLjb{N-i2qDOISR>7^b&{0TP%8*^xwl0v(v0i5Rg>g(R`3lO1{WY2gweCN5w9OSGJr6pM)R%lkVN5P;A6W^!p zqAoj)Q%%)$s;}EAm%J|*I3q&VJ4wOmaE)xP65#}KIxbl!Kwb32N)eApV&Q<-hy%6N zR5hn(ZM>!J zJSIeh#z?0{@Z!CBN2&p};IKdKM^0gXBp#;ud5^DAyyPMc7#l@}>M%SnV-=O{D>d^@ zfv>m;8kvS-4%&M;bvCuIse#SQLI+0o@Qw&Gs&BnGqn9Y!>{?>~4uJXz6_#u$m_#Vu zbkk^4RkP2gRezKXImGitbU3|dQrNL!COJM%$IXZ46AQZ?(c>Qvr+D71DU|wV9i0=R zm(MSdd&!5Q3`G+auxnq-b`0Vb?l!eZq@dF#2o$$Yr+8D1yPQ*8D}d6aAaG%jG{KoK z%%VV((AWFhhe&5dr#Bzao3ncQ2$Wvj3G$u17@+HOkFT&J$af@cKA{_Myn56th6vK0 zESUk{ujAj zMG)MQQD>!~G4GI%hMZ)!ECl?qKtNYsLt*Hgy+D@`Y_kTbNMxTunrg^f+2?S=G4kpC z{PhEm`7D6|TI>#x@GTiLf8_u}N*g^REWB1=g2{N^$rLgMN5K%VEnrR><-99Lgm4w^ zC$lDuue>k=nE(u9VlwU5MxO*}SC&EXzvTE^awu!L z0*-uZqkPJ!fS8i!hnhu6_D4Cp`E6Uy-^8=gdzw9~--?U%fCVp#G6CAiTZ{Y$00960 zlwDhI+cp$_PJV^pbVwycPLrltSD+6ARty8SV!*b?0hKMr5o}qSB;N-A`0-pxO0tu^ zB$Uq~#hb`O^6>jKrcHD{E4@VHQHU(RjHzIej{;{6pf#tLmxx)qpS-DBWU$*$Ceh!Q zNOI?&nnpdWVCo<^?0cyC3aIbYiFF0BwgH2V;V5#t8A$!ahvi4mEm>?O#2iXj4Lz+J zk6Qy^CzQ@&3P^Mm_l}@BDLg$3a&{E8BdraO9;_Wn;_*db+HRW%2Ycr&;lUKx1A=!b zo!)PDqG2umTeSVp=S|g)x=?WWlh(-QPyyb(%t4hRp$;%F0+E2=s@jeQ9R!jZM451%)B1oegM29f{zCoH;`Zps@^;Bj2~s&y|orOgtj_W58MhM3|OwXa@$J+;SV7I2eB?Q^=i{f zBT%5}s1^6rR6%VPTvc?VHX#&Of`z7bZX_tb`q7~ZMQ*FI$Ojr`xvVr{!J~!;KMV!n zvJj|ZmFYQ0_S(p|o-adX1lts$F!fsr6X*ez^Q9{a+Sl#%N4j^F+J$^C2Q8() zBLb+9~eCZ4lmNiE;xu0m|aT8?ik0;W1--ZjMdVa`oBFHAQyi~hqf zsizD(%&DBQ6FSc+_u+L{y}{M{z(nl3~IWA2_Vf0B=m zbUOMZw;w+?VWl%DD|g&I4g|B!g2zrYJ4p0H_*HQe1>Go{>nFG4nRihz6ne=v4D~ng z`l1gR<|J1aHi`3fVHJ+}9 ziT&P-&7+Q#jvkS+CA>XN9$`+;^ACfzo;xcNpEUXQ$yQ9az_9Zmfay^y?yy>ct?Ajn^n)lkV2$4E=A8`gT^m@>`t1<`1fOfm zD5ui)KI&h9xpzWWbQ@MH`gfq3Y?uu^9BGi>32e|0xVWIu3mpQKj*#Wx)Ay^_TPtWM z=xWzqZgV`frf$cc{{5?RDa_HM0x+vb*Ckf)emutER2(K{LsFAD!XcyWo;u?l&HmVB z%I}ie;5_J!NcM6;6Ym`wchHoM`{}3RsGo+8`aN%avW4Rz#zVTyJi*fI(*JJD%7_3T z^y@&=J07_*oXWe3mdkBVYD*aai-%P>AJlQ+(%xqufj_{ z`&hNF-%A0ikr%dthkP7N?+6%=w2BYFcv>NFwYl9GkHk(XcDBaOUrjXMG>utzs{;@t z)pjYrA#q+=A+PXF(Rg%n_V*e|1BriammO{f`^Zt%3Z+P{sVMI&l=W-X31=x%TV6Ln zdRGv|Th|<%*)a)t;wH4DecRgC+GHj$J4|BcEd%07L;{C23^V?qRRS0N!8@jlHZ`1~ zWq_f8B(PO2%!B@G?D`o%`?KM8%{20P76~35=+JE{NWIz?i*>eg^o=&7#Cr1b8(?3I-i$~u56cibwjB@=Mc28K0k%bB($9U)*V!l+_LKJ4ZIq>E&aIx+{dqyw}|Mr!_UdZ%xl z=`=EPR#8G0xKgvggNlk-sg)%&Aok6KPL_0rW2;;v?u^>c!NF+KBev;Ft7UOQ@?6Km ztMG|`VL&bfNLLiJ(}a=E67U9~XGZQyd=QYtyOK9z;w3-^6p!Lh*)M0IU&F%79PI&SeK+aP-4od)Z&>&kN7e!Ru(w zh}pJ54o+R@PRIv(v>X=U+c=P~&96{hdW3_-36ypYl3YVbfh$mkro(hDHy+zj5*6F=_(6{2 z^51WFB{?>Pq`l64=*)ST#F17jX3Z=)11% z@SSnud*9y&`1`dtdwcW^*MslZwO6&*YxVjLz|?E?z4}_MzWZjcw#I%aLOz__4|2VD zZl-Z$IwCOb=?$w4LGkk3XBGVux7$=Az2t;PXhn)i%fBJDxZ3Qg{oJD@e2~5JnqC-< zn1mmC0;5hU0XqyG5d53G>x_MriQl39653`d*atkZg%`^?e+G7{s2fG3BJOf=%jFxd z!@Jcy101%8yWsgT8%07q^*KbxcAGNOH^xa4?wjUxI<1a^v^t4KrYCX4W{X7cI>Nkp z0dSuEhHv|Wxt+r%ddy?N8eh1N_it6(7Df)+13N_S;M|}btR}YoC@{w{Vi@ATz_Uh- z1#iFTf?RWq`^9O9r(Fn1XKM>F91GxS2(13-M&i~ECaf`v)opG7C^L5c+hh3k|A4x(*wdEjGEGp+|t3krU9d9 zciy*;yVgbfyt`@4fp1|q>@^L=zL7|(u?>U>>~Y3ND4cS~{55QX^Zi1dZ;n~@J>J!N&U*3@>7*odIsXgME0op)XZlJbqOvR1ZpjMRF z2rtkFN`Zt0R0DIC1NTI5g9cndY{Xz-piv0836MySfS<0;5KbF9u=Pna@jR4XFl;WD z0bVDXOk*Bx7YSvvIRmsEL&FAh5||r2^lUdD{*Jgu57>)XR6i)r**uW2balW!#mOCz zZ_Ig;0pUq**Go~!VB`*9^>F|vz4J3gN{z;%d1`VL(czXE34rQ$3A3JzQqF!VKG`T8 zc8^al*gZwTVjv}yS(r<}_AHF4$5zOitX`-drh&X6tyBOdc@oh;h8oCF0~u;iacH|Y zz!{4e+m!5_ONB*J(j?)~Xtc@vKnssN>L`1Q(f)G_-;N61)^atlf?}Lq*X`u%Fi@k) z_f$D_3@Q%=1`59%sN|J}Y_O1~76`isAS6zDY?2GPfr%k2BO9IrE>CD&vC%hLhqg;>Gl~>4*a-+T%5uZBTMZ{N<%b;Oj6MlF4~51)j)1Qo z?8Ev7y}P_`uvq-X;pa}@Fk7I;InT!ZD$j--8)M$vVB*s8Q|#{f(T7g&^JQ0hP?w($ z&rUn6Z&Xb4dbeYmN4+CSrdQQko%LXyj_HZK?U`oxqK_u2pSNApT{2z0D--d(s?|+z z0*g*{kPLuKxiR3WU3|zxW2jV=oFwG*sD%t{LBV$8YYyqL3v9~Dn{Z#L+)vl zUST}9{}g`eOBWPfE7BRN#Cey8Zh+Rur(!MN+Pnp+Z%u}oO^CO)vMSUI+30sb@ds;R z@+&Kkrih9jSY!||m0aTtXjWQ+zo_g_^`VBG0wH5MtGjUYv+NEZ-#*z{-s-IAkjC{L zUCmA3ijJ}|t?q0&BGu#5Xl5vDnRt;x4FlJbRCP&>V3$*NZMlI^B3FddwcD(|&1&>n z&+a#ubznPA#BaYHefC)+^iSc>5O0^*Q`Zn}ffX)+@YO201Y|V?@*{i19j^rS@Pxop zC_0Z$a4W!o%%LW17-8_xXh`Zz#UL5O0`p7lC0KOVv%!<>8<}%JKv=;&FSG{(aGRjI zrb=S4rCEux$0+xT;>ER8k4E>effn~^scOW_G^o)q)$QYD6d69|Ht0-Qvy+vUvT||t z^4do%d>Tx%Z!tuHbx(mvwq+(ffH|VSbinAYp_U8zb8G7%p*2~k-2(AgLZ)RjT2l2j z)LB8ARdmS{Wmb@9ljH^je(XBKr>j z00960#9d2o+c*$D+rL7q0FH$wc8^6I_t0Pi6zJx#DfY4|3MG;gwTk7{!)><6f8Uwm zTcl*#aJK={q|`hE;yHn zuh}#HP1*WT{wiZZ^f?ZWAp{1j#c>#9m!+d_7g$a*$jgJlvN9O;V9?Euf#`YmPn&On z{E9K2f9%3pU{Ea1(O@YjHf%OZd#;g@2;3tcjiyq3zo}3a0-Yc7g@j& z1UtUiB+PRBh!IMQkaN-|RkaX3cwwR6urk@1!xW}mA(1exVqD<+#kAr%vrDkbv2xD5 z-Z1E#sTNUX1q{9_MS$JQ>{mz$`C`MRarK+R|KpGtb=vVeWEjr7w&a;6zvm6d&JTE1k#?7v~MWg7fV-tVJsUQ zBRb~e)U|t+?5od4?!>BbcluSE#D3aub5@ zv8%vosHKl&gLDStncd0!o_<)bi*de znjprqa>ijlJ(gjZh~5E8x0e4afEh-#FQ8p<$VqUc-Y1oG`%EXXJCK^1_k`RNc<5+} z%f(-HLH& zI3DE2;`gF2JSg2$fUi~K(chX(P9J|P20mtZJ;gW@>`F-UZ8u1OxWaY($eO9jhKB$p zyMS^bFKI0TURk{eu&lc1Rk^9M9_d|svWkWfIr6F@GbK881IVlOtoh!AQKyh-+pgSI z;`kD_lW zOzsf5+$dmvdS-48*3$P#IvMxI)7hpS*Btaaa&{#Y?Nk_zxHd=OG+51_S=~Nm0^QhM zEijMTg{X>H#nCz^JqbRRO;Ttdr6KQYjI9l@$F*?5&ODuy_bTbsdz*Bp8YaZ4rhA>} zKL7v#|Nrb=-*4MC5PsKR!D&Gw!woRUO#)<72W$(lmjXkFKD9+)q+Vjoa|c`AQq=z6 z$0J4ZNS?$Wwgzkske6809q*HLca*+624tJ7Wu<;1C=3GwO4&aC4LkAuJ}eS01t$v- zwT2xU60K)=TzrmG7BcYmU}#i?j^Pop>1A1HnAbK#V?t>f0u+km7Y&Wa5Al7q|Mt-$ zN2f)GpJaiFpzO?+OM?s!WjZf;`3A}+*R$3Ad~?m?pc_n_&>_Y-p(EW<0 zHVKCMtUtDQ(#fU3_)5i#JS0^N7!pgb>R`+!KqA-p;&;}^LHHFEn@RHQqsG|^ttlA) z%)>$+ybw@^ht?|FaKTmI9gYL+j}E3fFsI=8Mn{x9R82%0)CJtH=b})vd6=yRg3}o}R0c2Mq$8FQ?BzD&WE%8WU-Sto_l^jJw` zHcn;Qapu{%cBFY`HsK69C?YOVHc4=@me;oIfVt*3nsEP*Pg*2hOvzgay^R#^!brMTYjcgd#&nK}V5czj*7fPyADj zA|JRffBh8(8lPUYDy3GR2W#Ff9?en!F>U@qJG^ z7S`og|37?okIufji=(qUKnFTKZ`2yEB^Q z9!qlHbv+fBLk-I^Lz_O_qX(3>lw{C~aXiS8$E)ntcpQpz2=SJkt6qOu%w~E{xg6%i znJDVAKZ#tDa>4{GZZb84|1=Ak8|1T)J$_#=8##cbVI%{ZcA0vGY02z+R=!o7V^*RW zvhsb&uEkON$B_w-e2UOW^~0>0sfLl_!nbu%YEErHIk_rOgRJrRTT?wHIr4X#_YimR zX@!ZNXvoRLbdh1}LBWS_#Vpm#6 zZMzvaJc)}9Um|VXK6%b(QgJE0&U5A`Jwf>h=wlrpD&6D$M?ZIj{UOagN_~|QV}u{P z5$yrD^8$ABRPFqJk)4OyR}mjq%TEFk_;xc7hMkIQi*JHsD*Y& zg-S&&v%-BbWi+6(Ml{Ze!=4(^Y1DcYD%^#!PYW7{4UC3}qV++WN6qQ;dVA7+CSQv_ zlP+c5aQ)=cyGRMD^DUDoo0BFwnJ*rlOP2do+LsG8b`TG)iX!*qy?v(cG z+~%x!+W*7e|6{S@5885hws|<#))?LUe@xFWrdP24$7DLWyqHYSVgHX8SJS8cKmGv# z0RR7@)BPU+00030|EyhYbK5o&{w)3qRAEa?74>Gfx!U8Vj-@1;+LA|78sFGCTb5{> z6H!!1$#$CLzu!K)07%Ntr5|plu_U}KfW_j$F392m_eXjQCJmW&<=bzQjBin{Dge<1 z2a+5nIFhI@i{EcIo4@(Z9l!mrdb_oUhxg+{OY{*ZAq7daeQDBy(^hNv3&kdSxl456Cqq!R42C4EcYJcx>r!g3e|Yq^)9b%hFR5mK zFjhys7Zix{dUyNderG29Fe>c1mp|LY<3@}!EyyoA)Kht0yi{1VXEy%2%*{g z*Y=Qy6>VKq6wE$M^TPrrGw>{hDHC%iDmE<3n#dy(#%MCm3En26TDBBJfzObBliI#K z!US@}Kr^e!a3*U?O~Su5(wGx7(^H>`+SU<|8MZQd1(d^UPL_!o@T7R13JNWS!ABT^ zHN?_Th5s3#Cs)5_?uKGkpWr%364F5orsoXLYcg;!8$nZ-(d0wm3BS>lfFoJY&E_)2 zYg+=d+$B&3uuf%L<1!&++}{dI5-rH%MQcjN_7UkG2y{$43;VUn7cb&k&O^a?bNr?9pG3nN#-GGk6>~>PiY2FcpiQLg;w2}#o=n-{cM`@zdGbs zb0hxWs_Y`WyvG#cNlMeqC>ElSDdgc+6=@^wq&mX=IPa!=8xeREke<@xlW~yZhb?&k5zEF8n*V$mfv$dA7=K zmRja$>qS|8`Jz7O0%Dre>xyds-k1ej3IE`leGG+MY+R2ld;@s$tvqY<;Nc<|hqEH%9 zS@g(7oiv&5JF|2}f5PN~954PQUmR@n7YMBxtM;!a7~vwmkY`3Xo+rN{PCil5b&C6^ z%jeEpeA!iQQ=JV?uur_N*X!!cAHP?l;US(Csm^GOPbel%9u?K4M)*#4(mkY2>fhfe z>#wpR`HJ5vKC{JpQqJiK+O|?AUWvq8vppsJ(4DQDl5O~y^lv+v>B4|7(>B*IJ+gIn zRs_HdtU;jzj-yG3#7LCy6XY!UtGSDrk&9CqnjQc_x~w6ZvSm#|xVVmU#i_hMEgag1 zH;b5T4zay|Sa=Me(U?ziX$_FeO8W_bWQ#VBG)M$`D4-yH@k22oa?z}6I8S4tv%=dS zGH_!p@c7V9Fq!4-9Xk$t=op@Vqh1dOZ%?GYYtd_Caq#BJ1-VkB2)nwo=5yQk`)AlFIrgL5q=ZPwwkdHb~54Hrc#p>pHAOictdSt#1e3DjvKv=w3} zomfqNqPguB!Cv#DVfRmPiykIx7F;P|uYPAh6}PtL4-3KlnDW|gc1n?0*2 z15AbV8>(jDu$;3Hw_SEh>1}wuvPF4ORm34Ey9`vcLt||y_k}GLRTzTz-L|8dw;7Sa zy{%N$Qy$2Rt6oWeI$o91@vW*;Ug*y=4{XJ}AxMkOU6OJ~JCT6=u1GGc-+yZBa_CA6 zOvXZFTGDi-{4WA^W?4jq8j8?MXTRkUdmC2C>n67Ys zqt87ibE+`=r0^)6Un-KS0~4dvGKe+pqS}TeiXDeRgkYRB#6Gh72L$o|{gvFXn`vAb zQNaQ#*c`f?8@qpq55H1Dv|N4Kg-jigrC>F~!4YYdYU{l?ixtdI;K`H?(MAt3Q8{ib% zf{PQ87tZ?+UY(#ashCmq*PR_gx8()*dcU>3y(h0FRLS4XWwhHC0nVEK^Y`W|>x<=lon9pO`%dm6!CbQUBUlMN$Gotizu0CkgNJ28YWLLh=g*a|2lk_CHJeT4 zRXpWdS(m2c|EI3i);}lr-|QH7Bx^iFLs$~Ol8{UtUjEF+xiZA2sbZ>mb9kvPeJ`6e zs$(~30$KzH^#)Qi@y;fiJYIbWB~Z!yK$rt;khg%i=1kCna>}_<{Cskq?z=A>tq#L_ zI0?DO7#DlPWN=r^kW9l8Hby?vb*I_`z(CNzDq5C})1zfYd}cYFAWYssaS|yDWoFOL znQ@uY1BMQ!PQ02JQKSfNX-keiX(8!0D;aWzxt%1Ap-dcwE=)@k)A`VUN^=FE~1zD}HkUWlE>y#^n`hQr?ST^SLb4G7GA? zc{qV-!Z9KGAPm4bbi3wLda%TjekXDuAFh}<{@RqJLQG0t=-j1K+A{f~s=|?p`tk*% zBOpDMT(zsb)AOx*_3S^5_ve*HgTLTkwNZ6Fb^Zl}LEJ*IMx$|FL9y=?`JW=rE1X+@ z+(S&1Df~q$<1E>0{3qAh^Tv6uyY$^{e0EAGoKn-RhJ62skFWT{l~GB0Ua$V+;{Q-^ z<$EI229>Bc_S8qS&t00=RGvoTC-GRDq^$fHCzJvH_W~SZUBJ)PM?<;&!7WI^`C2o# zf&>C`M`0NhcpgPh&(xtfEg=|anMz4c5a3n=QFtdNCjoAb<&xDq0q>D@2w}&J{^P@2 za1Y~%*V8_ohr01K9#uZ~TTMKAr5#u{e*U;LfuPyG>#lfL5)*#Yvq8Lg*53a0`Fr_G zfu$%)_HO<_u%}eL+B|Ev-{T*Jj`hv&#fsttl`;U1x^4Z#pI=qbH8={fPZ1rzB2SAH3V8#l zp0(QBzhIg%ANffkgdL1}ry^MSOGHa#xj)}OsH<=VKKGkRGMmGD#`PksHE}vjec0_{ z^O?zG3+6~;OFH$F+HN*0ywd6-#!Qm@BG-iXlF#GglTL5wHz?sN9{Ib&gMMdl?7OZm z$iYSu&_?rOPbCq?PD9}`G-yxw=J6m zXw3KXZB|qcuG_!=)Y3iGll$1?(ep0{`V5H#DYpUbZg3-Ib}|Krb8;~Q9US>l-PCw< z;=esrtyaDLUjP6A|Nop_TW=ai6n=Jo#fq*(sv1a|*p-M-RQair)rY7LeXsT z6c9%32!Yr$26I9VY&ky}RKNK7>x(-LNgv;TfV(tl3}GPszo-ILO$j7?ZwFRN5azvqPsAOrz@tkBdJKh;j=(y<5 z$aAL*u*C|46Pucp?it+MwQA!?N7K2#R2A80=rm+CzsA+EwW0SzaKh8hQVpi+U#8F@ z66@8HL7(*e7V4G;SnTQynhDY0gZ>PM zlgEMDc`Cj?#m8^YBxw<$)4)4AW{B# zaCm<3hz=|Gnf=8x?vqE!IUfnBl-R*{PSw}qYERC(v2+m6$m>l)TZmSCvC8szq@>K^ zkn=qk+ITHns^YI?0Oe_Tp@x;=man)}6?i}MtAPS7Q`m@D{ouL{m-|eG1 z87-ZvtG$Fb%p_8`mh^E5p3Ffl<20SW5KS6At9SgwKA98x5`pw0UzSNr?>D$m7G~!Z zNtc>GwVx&CX8}nRV(=T14zbCsx4ltPVAn0B?oA6bc|J7AG)Bl46$U^rq%<6=(Z;X< zzHy*)!KQ_jSZdz-byM^xYMgs>o)G`@8w?_xH2A1h#rs+$-l_IeT^C#+3Q-(ip71H_XO8 zYY#d2eY3|sM8n@nO6vxDVfoYa*J=88n%+#)+kQucHK-%je4%6CQ1Xj5fm>waoDiUB zty*!XN9M%Jsec^YWAhXuDbx=Me~>_O5Iib#YShL1th1SWLQ-65b}HX^Whe2~$eyqB z5KKn4g=F<+xo^n(k;KgIGm@#pgY|2wUCx3dUNLz8(B#FMeStGT_+~)xqz)Sr(zIrC z7XqB7-E+CkXlLK4n;(G`Je1c>27xC@PBP<2)Jb_WzCmrzAc5i z<#!e5Ql|j}z&vZ^%kT=%ZRes6%_|u#WO5Pqp-=;`i8)+DO6HuDpx7p5)sj`}Zn^He zqMn66wR67EksAn}b&>2SVFhC2U^n-UscY|mYOI#cb1I*Fx2J*6=3`~X63V~3*6Okh zbpsX>+YgA^WY9_TPNE~F_s~|}#p$MN%EakL%Qs)4!`8!gU!7hPUtFaPZ>ZM_-o@CV0(F%KyDAbe5LS z{4McXERhxjWPaO8)>1`OCn?8qw8Fy%~fO{iQK+dPQ{R=dp?zQYJDkBD`VQM(G8GYl6% zzqDD_G#b`QVbCnP1|$X(Wy1gIi*RJKc8u2KZl)#-*=Oor$d##(Y)F7v*o{kcAM9OQ zPuoZoevW^|)QJ?r#&#}jwfz^s# zRa*MsV$XPHeCBq}H|IOSsXug|XtV2+&Z$IHR#h|_^gCVJgT@R2>0|mn;A*T^- z7bqaX6~jH|Ij$J&+%4CYY{Dl*JD|>)k~0jS%tQV^pflyhO;iyuf?a=sp$}Mzf40Yn zoEIp!jhQAvw%lO9%!BIcik;zXHraNZ<#K6zjqz5Mg8n@<*MkYOHutE6--oImOOSty$N}7uFt<5|x^;0%%xLeR=U@fe1T9MYY8tb|XHf5xt2JMhqg z0S^kmM>+0cw4?kZPbv0Sj2)&a<;LwyBkXn6Z(2gI+0Z#V$IwvrrsHHUrLTnQ-4)d$ z;dyPWZVnl&>*VMD;H0rA|Fq3Z!bwA4dZ%(tRa5=DY3@x%HpYSYU?^vcNA?!1 zogO2Qz+HhNO>8$d6d~D!$IWP+%_}|Hy~c=JlIkoS|3;nVu+{qX)y*|I8qmc5fqawYRp%OlMArcqQ$u!T&0#O?Tmqq6hrlM-nsaeq*q%R& z-HH>h*fNlwd=tfU;fB4cd<+u7$AnKiW|XQ%G?sG563w?a&f0DCn99>(LNV{rXoe-0 zQ9cikyl<}1=n93U_I$Y9Ko{Y}CXNiPAuw)`buXPVQP@<_(v=w1*kv~R!Vi63_1PN_ zY;K|t2P@^GeZ9nCMukv((+wD_cnCkH!@zLfHaxQj1N6C4ihjwVSuceNp0J?`iQ5!; zb`7d3OlO6&%Q&L~@`0q=P7QPb-wiWPE+t*T263du0sYv7jLbO5Sw%!b+I+%F5r;&k zB+I?O&qAA0bR!)O=^Od0V00r!A}bRXy?!YoQGNH-17ESGOaeuYk6|Ggak1Bzrn=!N#n#eaIcwY4t(Q=zz(#DB_L z<>D*;^IzjXaj&Bfhzd6d>ICZ4pzF;!ybx)9JogcvUyYFg#R!4wAa9YB-6tlAJ%a@+ z1_hW8egz98s2QYvEC~uAYO96?JdP?A-r0rst8fw|mGgMrqU+CeeM{G0==zSX?~U|x zSX25ru&MGRflZZX!6uHX@pr(c^#2fTO8-!B6Sk(wq0&Y&BG0xs3Wgx)U9U4;c1DQH zw2&wS2E1h1vvE&ndNdMx!F1||lK@5@9@HT*42*r8f8#-*tbLeU6oo`5;1tYDgUz%m z=^ASK&8MTPDO(O7(b&5DLxr|1Tc=PBtocvLm->Aj=f&$Ywj zdb4Vx-v(AA6HaTtAC~sN99B)NzSLj%$eR90r<2e+nF}(Uw5legPD1slx%X?c`MLDz z^r!(TL9Ywy7)7E?WH{Nc$LW*)Aer3KQj>-M1pom5|Lk3RZ`(!^|DT_NQ6%_rB3-9w z57(=LlO@>^&M#PUlN1JIilS|yHmMV>#CGcM0DnM$zutN6a+eQD&fy*f5;(R*?sIl# zc6N5>x5E#^>@9*r^Xr4&F{BubhP|WH!}hQ@g4KAd=9^vOW>KG{O^XdOSFiN=n|>6f9zd8-RPTaETk~27dd`bAuJ7zCwJ?o&W>nTaH4P!7JRfw^aVXnrqR3$9QIjI90POp9PYvzVJFM`R6Wuap}XubW3hK@EtYBVwaC({)N_S zFhLHm=N^+wDrNs~8ZHR-4&9k0ifRVxW=GBEqx&TEdGJjqXo7HSsr^l5h_n zqNi%};qJESf)q3f7`EwxFtJB8-Qpq$XSRKI0INZ~tp!$l2nYjJ;j{b1RkBa67{&KQ zM-&%v*GO}+_X|2=r@lck+Nvt%(%$1GxH-9l3zjpv6hcSya(MxcT)G-P1o&5RtQrdO z5#zToRTGCx-`tBDa#xQ&AJHgY0RImkXH#5>rqRC^IQbw?gcHTPgOl^KPHzW>3m$() z|JH?aBEt-DQ8S(zGXp)h8@6|TaM&LVMU12^^2Kvc;>aW1{Yk`y0|l^gvU#8^76dAz z7_M|N&b;auwL9sJyE%STz%z`mr@7mKp;Y)ZxNmSoM{A&16&7Z2JsDldu$^B9;t32= zCwhSHWl({U`yNu9B1?m@z;Q9Qvgs}jpM?d_*MT{t z0)^g3@YT;!Z0MX+Ird4S1=Z!j?Mijy4AjZ zw&lsPBx=F5q0*B0vrYXu2Ah38OE7qH%W?V)c1Ol!8WBaL=`e-Bn+?Q!6rb;W5nE`8 zlHMU;dNwFC2rJ=nzPX{PMw+1xvs65NIJwwF;NB<*Z^-pR3pa%MARUd2egi537X@kn z-HgT#WoJJ(d$f5YllmD*$2L-TC^HjJLwtfgoiXA@I8T7>6fF$gf~G@vZit~hR~~he zrhI|Qz0Lck#=hs~slk;@M`#ZQ%)1P>aL324LE-w>PdXtNiv#vi7IbLZ&_+!uB$YA+ zo366`7`>KkJls@N9y>X~jSGO3S4ybX(2=|#a0bj&#*Stg2 zGnpgXa)_#$44Y1MKTHF(=^ECi@nt}*bPRKn#uGR=K``MN0aqaD_6#MdXGsinTEt4t zs6E!r9t_+Rk(tq*j~mc*l+Zy6ZKMJj6kjh;_)!5Sz!!=KM0|KX#ll5EH88j&W`PqY zu_qNMcLmbfe2i*1of1s3m`JiJz=0uk$j z(zJ9E4TqCC@6Y4kVpRDuAnW|D$>EiT)~ZyRiI~H%E2DE$yd*< zc(PVQ0#t#ms+8s?TvdTeG$J{BkX90N|VjM|N+pBhy{tcLXfj3~odP>@tK_7xSi zi|lz7wa|H1MJK2Rv~5$Ja{5eIB{N#aK(?O>!;71*Yy%=Xu6W>{Ga>R4=lW?n!?X6@ z-!gK}QfHQqN(h-HAkqQF>_^%7;gLCM+75^{S{&5Evg+W41OJy*2(Jq@@-w5#0;N3< zof|9YjY+EL4ezRHFuBT6U~*Mx%yQwuTLwKZPP}w>JC%=oX+(RkcQJ~ zWy7J?OLH8&&~DM&g1o>}ptKabhJ0~)n>tu>Mjg77h3iK z-m9nEyK{8aZdynv%1l>Di{d(zoFk^v&IUOtDJ=c!yCzL_)EQ9~CN*r`h}uqumst_K z-c$$9>R;@X&$-iQw=vA1z${;+fM;31XUj}F?FK5)BOPcd_MKd|5wuzKq35~VD*u*h zy`)*H7^_M|+nZy}R8o1rqw6WCZj}PxeJYYda+W1${EI>kH2E$2&9Y82lS5d@5GSh0 z6gaL~SgVAaw3M#LHFrszKutH(kf?044$^IYm8%;AV;Nb>1dXEwEFy;B`lP^hL

^ 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≫( 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�!gCtUm>klAxZ0l>0d@tYb5KR(D~IO!B5A z%NRuHZ+d~&kknvdVgTq^l%ChKR3IHm#!nf3>0=`rpw=*xh z#I}l2xyIq?UtM4Q>+<^VLnauTKo1U|e{xwM;-8X4 zKJm>&r+4Cv0Y|2$Fpo=7olOZ@US;PKz`#ey50+@M+-N9V*%<9I`Eo>|*M)-*J& zTn<JS2L>s* z=`8WUFDr>AVJ(h9J;Le|E>ohH^77yM$|?~MA133%vXv#v$YMAL)Jj&62vp`x)k!LK zP{9org@hWH)m)W@QDF@Lb$>^OM)6q-%Q+dpgdM_#f%J-9&1^g+ZunT+6}w)@QbKmV zm?wnnd^O7v+4&}Bh`?KUV3$hMhC;E1@Y1EqhyOMNA|VH2tpPIiYORzV+^y0XOJ>0) z8Y@4Uz~mOb-&bU&R>8YVILWj^hh5>5wG=GUTp_txet$13XsW>}?8?@vu5hZT?XJ-Y z63F1hdf6pd`blodH>P&J;M*y&_CX+Y>G(HG#+289A&H*F@^R?TDBF?{(JAXg^!?GKv8Z=_a}C( z7U3pJ_^nJ||Mi4k2RyO`pVo)m3z-I+X+-aN$-d}`?h_1ya3Y)6gRTku;IxEw#TIc@ zJ)A?z(Oo*_EQI}sEBp@t0RR8YU0-k7Fc5!+Pr+k1m5FR)rF+_jstFB2m966u1;R#D zNDxW1?%U6Iwv)31DZXS<-zX_}_W5G_{{7DL8Yx14*d@ZisOo{o6)lJX5Y%eK%ay`| z2`1-C={eQ@9C#dk8gIojsz@a;)mcuC{X~d67~Y7jur-a?qZ_%3 zGs1N8u>0xMp={XKxdGb;Ieq| zjJOQsc7Bn#tUaQ&c_{ba6-GaF1oIV}72S>=@OB1nr16`PY>X0x5xwmb=it~#$zVgF zUAKeAau$ulNF|fd7N;y#4PDbn{Vv2_YN8os$hyhpoNqMTp1 zE!;^vQmxr)UIHO{BzO$`0fllv8xi0aWv*-uYC^Yze-~P!o)f?G30MX7qY_s^{g+xO zDC&Xz034x+u^@ihCuXDTBrl0Xxze<&27DP61V@5w7>NlQU<@xO9fLz1Qdajz3qphIwum0e;{W=UMYJ>X>;Uyp7F1-A%xVbc2& zq*)XQZY%lW(_^?nPVCWLc4`copw?iL2e`yHd!f$oLW_Gim8Zu)K(uXH&O_D%_JuXj z&!YXt;4^GpGE9=!C;fZ$fPK#%xB1o=NY~(sgLakG7Amd`s--lL(`{ZP`MGBZ-y$~3 zLvIKHupbE~_OVIZdo^NANSdSs%av*+wY`ed(wJlz9cAlSHpvReldd&~suYP9dI%vT z_5^3M@~fAvIfU)-lvz*P8A}P2gYX}}an=B=tCCTQ)F4Y0Dw%P-GKO-WA$WvXK65h>(a zMO*`j?8wwXTRnqg(E(~Ugfs#XLwfLK21pzKu;1W-GN^!m{ec3G1F~0Q&I`AoQ z@Ukgz*@kgAz@UoBQx+4j zRn*X3-zcp*0}G0#Rme7psMKL#LCw@*M7Cp*hYWG8J47FrFtDIX`Xe-Q39k}x7Ufou ziRBDn`${(_wJbFUxEA=_-^smCC!v(6Mo zC~`u?8P^!AR8iO1Dh%c&wv^>l00000|Nq=wI}XAy44vC+aDhm00R#gZQh^gxt(X8& z_5RdJlh{cE#10EvhstqXC3*fme=KkQD@&RC&CEw1^ym(793H?!Tvt9sB{ycAZ-u4Z zR3b8Nj=u`dc(cWMgp6Qr$fuGkbSV!dmuek@BsvEpTW>K1`U>w4_Yd~);8x%1KFhk& z;U}Vs20|;{;Mq+OynWvJ@Fgl+LR~@vROD~kUmEl~7bs6UPG^?a{f(oWH>@K(D{(8x zd{n>?<;K1+tsG!+Ro->U6PX4Yimhf;Fy_O!Q2cJ=Eo}KVZxs#gD50?rDh8)9JN9W9 z-UG@g5~ft#)>x5#c#|0&bvrViIl%if2|sL8q6$H+`T8^+;cCnkW_oud>MT$T5~|f) zdE3kRaBNQEFY}yU@^8dI-I0P(r;rq9;hmxk-xVT00030|IA&@Zi6rk zKDSSSdfH(J)NZQw0+V)|H1%9XqQE46Dynp^KkSfVCs2yRp;wTcKNB1K^JhC7*D3@p zk#0W*s))P8&t%{omWxvfbQ;@0lwn?{X{i|hQoQf>917~lb5c`>y>#E-%+^B!hCEj}mbqHW9oC+g8|*RQ*{IxDo^v$eJKY|xZZ~5?K)aG-ewVZHv1@G}Wy(sTOJ zSq6Baq*O&=bI}5sJhVfz{d>{9`AZHne#@(ONGm{C0@L2HXj z3kp)<2mgRi0nJS;D1Z;DkYO9z0*!)#oJ#1vtkS%a%p8SG&}pOKYs^wXr%dEz0vj@k zd6nSC3`(J7K;a#1pr#Y7MpA$rHbJ)O@TMQO>zK(f5A&pv0?^GMX&RcK=3H)K3G!(m zAZc)hh6E!}0qAgw`~n4y#I!V^zrb6ZfuRiZtR~scA}&FjlRgZEoRCe)b{?LCrNG7H<|#Nj$NP9X`8#=$Z5zxupy5cy=|I+yr{|Rdn-yf6P4vy)Y zRTL?5qO?8q6k)(IiVYUnZT{2G zfdZ2zH?f| z^g6xvC)#U+Cwu=m1HPfxw{EK;;VQy?`&snRV@M@Gs#IXlr5<8_n}O9C2D8b6ktJu5 zQ>|?S)DI*Ytc&$L7H>F2SnS~B4McD9nsE4GyKH4vn(^eSyXV;B)|fu=4HbuX^^ji^}M|bj`2K~ z*28hY-ayHWR7@-qc93PddcxEx=RbQ_ko*N!9T5FM$KIr2F5j-kDpc!Di0^r_JnQ0& zW5s(Xb<>V${;4r%G2Tl}E#xEeud6ZHwy0P43k+)#Vq1VM)u(2->`JqlE`T+8j<@Yh zzb5iF;FNko@9Q5K;kP{h5cMd70+@Yr@FBH}>7B3`5gJE7$eQP*X$uv#gOk@o{VR!z zM2Q(983=@83QmLY8Q7|*zyv!>*p7)rytqc6=6zbCL~L_j0z?Xe(qigM3(Vgi_4 zOLjuEgzB_~T^;#EI$O|j{e%mILjc-B*KzL($P*Q-GD>n_JQv#?+-3@d(@<_Rn0pN2 z`0@VX?)vfJ%LEuVkxh$i5hJTS-6GyuXW3$4Ta!L2%B2m)1M1g6S_>G|97=~qTZk1h zBS1eHnT{>o+JZcRjB~AG64f7L7uF-X+h9_#EM3i2@^EXwh9LL`iE>k@wW`X)>J!9M znD9|!ZS^MjuaL;=I7%0K#f5bZJFTv+VQvaVo$GMOP%f0;^R2kXO`a4Y&4^sL2Y%Wb z_bq8bLlQz|TJ^e-J)-H}R~GIt7-yR^J5RFKY&ojYAl3w`YFENhF$z{~XWNiOjbXviOe! zKML;tzg=pLm{+!FS!ha{u7elc$I3fg^u~RG;LowVq;f>1N2O2Y6_p>U{IuT!365e# zbNqfz&4?P746x7~b|Ob^Aq6auV3H9y>yns3<_?B+2!!_v!=$hAXvT9dL4q8a&C;74 z_jG~*nXxJY&Hvz!^SFrfU%25rufL?Vv^#LU597Q0pEr~10U(x6o7WI7e>9>yTzhx_ z(u3b!_hNYExkJ};J45*6!t036|8%_o00960)Lp@D;xG_BYy0k7x*7Rmu`ot%i;0al+sk1%glMB~jKaed5E$1~UpToJf1-I&<$3X9D=NLykh<#KG2b8Tz8; z_V+6*;z!}#H$KE6Y4&bBsX&{zQbNl?dp>MRx?F4|5Wn^ufkK^H2<>(YFsP2cQlG9z z0|uMq=9US|F<>Q7X$O9}V6?_~0zKyr_3ECZ;lGlSBC=PwX9p?WS zSX661^*%HknS}x_VSTAP>0Im09{k+FCeT+sC_Dza-%O}+k5!kBZG}UdjijWcF~^=1 zQx4s;0fzFIfpqoA29uM{1gC&gBUPYtE2wQwPwrcfEN4(00960j9tNQgD?!e=PPpDB(xvc z7woj-&S^;jwFMNQRsVkPJqHSHC+$>KB(~!`JH`nP9(4xdD>Y&#HlWdrR2GCf`aO6Z zCJGdG%vxRRNKS5J68xaN=1*x^h1Xh{4Z*Gya5_60tJ@-Bt3B^NB&=l9DJ1Q^7x#kI z>>C;1w!yMHy9h(m{QU5M2S?HKxCivLnfHQ^s55=%quf1s&agpiurC}?$yU~%cbmqm&jtYb-pnKCZzy!Fvz5_@oDajm_?{+$LuD1&`;;rG1F|&H)xQYA-4=*ZY7hoE}3A-?y5~!g*%=)OBwTH z$irg8W+l@&!+XMvVs>C~mdtAKy0LDYKrH>Qvy6Mjz1{ID1sD^a#c{ZuD{e=EpwJrF z)i$`=R`y(04%DV?RzqnI$v=RVUl2nL@7*dE~VYeq5RE*Whk_gmCo?ljzq~ z5xkjH^RT@T2$@GtvzLb4KJpd#5I(_Gk{|E^1BkIvbBG)<8u`iS`h+C|r7B^U;^|Z3 zlh!Wq;aiGzv*FHL1z;rTCgkfHAyzB|h%sKErxWE^W{VmAm`z8d$W50FBN~kZq*y>! zb3_8-O12J0pE#0$e?tna1@A;G#tWi|!jZJi38k`uSY}na?MRPKxNc+@iyXQ)++93`Z%dpd^i4i9EfI3QcTmfJ5CCKMQMa0 z!v!Cj+3d3)6$Q(x^j42Jo*yV-Lw8XrCdQhxZe-I)*e{~houD;V(t%HO;X9_hd&RSh zcp<9I?ikd7xz!UQE6TEhZmhUi^;E?vP9u5brJeDu&iOV{F3%3-Uf=PmLP_;Dg5KyM znBvc7&udR7A<&8PQ;ZL7msn2b00oaQc;n6QgH8?fu^v^@r zS}sd6(9k)8T_3CFaZ`T?U=aO z;s|M{BE>}aJ~gy}+f!pldFUNx(y0`JAsB@Qb9TwGva@#I%w@?6Vai*~)OyBlY(c&K zRPTo8BE9GAJ*o9_V|yb0-wL$5!dQr5V~TKMO=mHZ&FKJw8(zz+D@8o>otXH{Upkj( zKS>hQwGK_f7$mJUr#65@J`FLUq;}XD^Nr&wL1Lc7sE-?yIrCp@b)l?Nv7?T~xZg%Z zz*a%#(xYaLdjTn=(2nWn@D+w_p^vA9~%0$*|*=F&F0+$s8*2AE=#_ z{&mgt0y2KMzxiBT-d+{&?{2TIzg*wlel9-V-4|gAW?t}=-uvr6{^oz_!JE6Q>yOv( zFZlx+>(_;G$q33zc(83X%h)2_D21D>L7@N=!$2q^ld^nVZPH%1$ZxYE)hIp2ad}&^ z{?|^mN43}aL+F`@)G`*I-1Hl|GXY}=CSnyo_qlWHm?H~dh*_U~`RrohK6o)I{agMS zPCMr>+H}PXmGR7+yqG00Z7Z*jErHakj4Ux}Ydpa_l*=pMd&fmuG0m<~+rBA;k=;|Z zV+pFpZbn~eiQo`1#<_D-x9SlV6>>!S$7DuLccGjCEF-j5UD z8VygH`I7bNKhC6JSXt8XUbIk*1InaAORNGg9GHu8F6NamB?9=npyq( z)O%IcT}@H41NdN!$Yy_3SG{`mnruLS=(T2-9#Uh=36eWoxDLnFwF9}vV^!Eq^h|j@ zGyAtESB-wiR6{KXK;Cl_)xHl+|9lb@B-3#BFYy!t?m#f@aueu+_-@k*@3RJ!SipYn zv&nBh#QuD^-(o>Od@l^|2g`ane4W}^T{HM?O^T21zo8WX15vCaG->zB@!2<-5tkA-ZIusu&pc6NGC1@~ z6p4eEVVAluE*iT>B}@4QRLQ)>b{ ze&oQZw%izi57#gMQemAOy5sez1Z(AN@5~IpHQE#(khCV<6R0#e=g9@sehsmfxj4hR>7n9g%XTAKLTf(8#40ck4 zhj~d@!qOT4>r!a2*za9L!6;6%(Q*#;>&x;ifka<%rMDNk4UElf2{yUP0UxY`fR z^zfhmAm- z(!UMABhJjY;#?K{BHoho4tK{!tn*^Zpc-4+Kkoa-y9Wdf}tKRCd3)jH-HjnV`Dv@%<#u zS^M)D)yF?h(x|gk{dsxw$80vy%IwVoQvfUZXJ)P3)~z|#=J1Qx*KVy_XC#SE2b;i@ z)GgbhtxX+3tXJ4Ms-xDR^<4-J3U=xmm3r#7?QqFC)Rk$2zB z0E6oAgVVConjY|!=Euc~>ETj*hiz8pg6#t4`zT)Xt(|PsL{Fi13QMFT5pX%ECajDT zm5<#0ci(j(POzffOp8ZDG^P3*-jM1Wl&j3m%H6gzd=4##@1|QYaA&N`Qo8DX)~HsG zc#HJBl$-}IE0E$-TF5dbOTlHs{0TvqExi{u_?VpqgA+X{VH5t)vX0DQjqNkCFi>m& zM=!(X9dIB~Nbw)JaTnxx=qc4>b9U>#$FR)-vVvHIz^4~ifL++tbA0q%ykwqk6D}SSXDv-tklDs+us`EkTL%ohVsXmx|t5j<8}uIdZpH?S+D%kT~5L?4iFnRON?sBA)AB1g{V z0Cw=_p*i^dRHQ56nwz~}6MCjNlKLrNCWu}7_FV}OCEtMGQyZ%AG^HopwzfV~O`!+N<7 z=*F>SFZ@L@?3Z3K{q#Inr0L-xX}Cmct0id`!St!7v8-bjhU}?DP->Y?M}|WnN{I%p z&Y<17Cs&Sj->S!rNjWWbQ7F)`Q-S%v-Oieq8^76P_H0abwHs(aF|(&BpSR?@Ri))B z#6n6kb4u6KoN4ok-TAy>wzHP(Jeo2EYQ*fQaw3l}c2bx}F~$)^!@m6}F@CRjq2&3d ziAo;KZd1?KItZVa%%43-#JbqieO{%-?^KfI^$phXhU3Ef{!@6NCP&x zR2H+WLZuyFTk`awL*7WuFT|&T-jo}wCg zk|$4@eY_nwvxvZT9k=^?F&*iVWnku*VRyUFSyRPimlBj7dChEjmK@A>XPC-z+O7NZm|!>v1ni z2|U33zrNX2b5IgnfQh5O;%Rr6D9~of(V9=PGUqQt_jo}@m&H&qVXgF7)FBnO5i(KL zH@xeCB-Pskse=x9mWfapLw}s#-Em2xm(oK%=&)p=b*f4Mrs9ij04dbq2;vZ%=W@a& zPPB78>~-Y=$ROfs&U1eBepi&9ZcJgvCQv0RjteBSd2 zj)P|2wI-@5pF&D%>YkuekYq-DWeBR(&;8jCcmZ_EWeGj|Q%Vxw9MG4w_yMfvowuO< z#W0IJ+Zkgo1@OejJD3t*?A!~}UtG-(*u;8Tuw@nP(*IRpNnHtBS#IIo$`o7-xHtv2 zap4%aqS1Yto}ohN;V^@@q9=I5p^s?p3|M}qCit05+Om}}%7rRpStB7KF>9QYITdd( z?5(g7C2-*O^7)*Xw$!yrmE~7AS`kTCk;%0WPIn1?D9@Wzj&M1vBe;|=~!v1a}hOkm`a-5Ot}xyx;O8PLqS}1a7rf` zbBC|tsAUKDmJc!=U^-`gF92B3K8mW1tRGz>snmXRp_9nX6^ujTVXmNeK9gkTT}n7G z8Tp@w&g+81tU>9Xa;1y5U@{L*1Z|v|qN(yOTI(jOO_|W-qrczk5DuON9&8S7sIeRz z*Ol_)HHXz?VwkD-ZX-!|X9rVsi{i+)p3!MH=e7Zsgdo_@N3UShcgHlRs&THC0L+>Fh@C(yR~ZVe;@@N@ zbXbeQ=Sf-PDy-}67H=O==M{YjsY=@eChpi*ff&a?HMICc{s#a6|Nqoo-*Xzt5zh1c z6%)OjRK?-bT@oiHm#bE=5}QLHFN!wAx7h%diw|>P<2X%>qTG$7 zMm-vuVffOtS=C~aoxP1iZ!9r@y!`DSN4*2{dndJJlKrQ5ulW1}?w_q`G(Mc`9-h2l zs&3S|N3R_-L_?r=dI$vuI+n{x(8!m`AIN*W(3uZIf2{VIM*XQ?E$X@6!`Qnx@mHq? z(3^f!{9;2EWG>eny2M3F!$;bczm%$)Gx9XAk(5{T zu9oo!@{#EDC3fvM%f&qCcfv z-heLwIEDS`Eh)DavmH3z2%K`P8oOMFdxQ-(%Y@P* zm0#N?CT#X1WCTnz@VY|XQ0nI_8Y~PySr3a*6RFk!dz_^5j1r2rNwrE@S0tBgYbKhx zcX>I{Mm_1HjH8w+$5|hCS58mcbjwjUn89DjzEFwFoZgU<`#R(wO?Oo0t z$4X(GhJ6KL2=Y!sVX#_mC-co#>QWBUjN~uI36yiM|6}=t!s(S}5TmzQ=0? z23!q!@+|G#)$}q?cRWH@{2*s4im9Gf+M=&25A+7{8teVop+OCQ%L0}}DQX1t6nF*L zJGh54e}%0e)z)xaI1psOV@ql+R!4jBTuNLuZ&yHR#if(cRlvC24%4Nhn@OlyHpRk5 z>@6`wS)spLqkX1M{p)96=z^-#HxJ8&$X^NZNXr5Fvg>DT8FmhF+$S7ueynbM!5HZv zrPkQjl&Trj(@+dCl4XFTrdkv4QX$i)fpRZ%N0jtcVF6PTL;Xd_7N+&?X(cD?db1bo zar$f9<&~N>Zf`)1vRmJ^j%v>sf9IGRz(k3-gvN2ETN`cu={BUM@S+A?#YPA3WT!-! zts)`@X{py9A0AoK2lDI|xR%ZCX}O^1cm$%nT_DlxG1vbqLfHs z&$9m32H@o&A0)ysT6ngqzsyhvBWu2>zZwmCubb4P2e?S!3$Sy`YBl4p$Ro(aY=FKc zT(G!|h33RIe#R)!*=pt)sa)>Ck!cymU-3Al#NUFjh;|w{3bZyGU3ktc!DiEbM8+2` zcL?<>>~n&Zq@{kPsq>1bbf+QB>it~}Fs~yDsX%a%o~5vu5eifeTyumEHG&#LTR3Xj zgapzTuqo$(y9#;VI`#rpyrE2anc<>X7)UG1{%{Pe_7xK(6LW-2+*%RE=o8` z4IgQ1PdP^lNIU-_jD>@PPfH{;9vv-s!aT#kw^t!NqW43HK%&#HO`;@?V{#O3>2LI$ z>IBCY@Edxl_*dkE=X8B-dz#_F(B5WcnGLEtn6tmO?RnnG#-rR;z1;ST^D-;%Y%y|# z7+rf&=D8hS*iJ7iFTvTLmpMN%7#i0W=rN)O=&2$8o`0&o8t@_`+4>$e3BXH;eUd@-=MWlLYtwRK4N2@^aw0WrI8Odok#?Y+j(D{Nr`W zJRx066DzK0z&ZU`3_AUB7Zf1p)WTp`QR_4@daN2kGDe?ut@B{0{j0nr@eQi%yyzFy zC3A*c6xD#bfao$Ad1u_uN^?CfuZN?YgF7riYJ}un7Ng%S%|PY)VVwDfNVwF-RW|5g zop=<{I`VYw-Ehna3YvGnn+SykmD_H9k$0-%hE|uJq;5vztK5jZM->Fr@7qD%q4Dxt zqrAK+I*>z|UuQ*W!H!av+{$nuC*|MTym++X@*Ca);{g+|(DNV0G@m^if!oL~X|u5~ z=~d&_{kEXaX@zzczlB%mhp_l}w2g-LD!UU(mOCTcgSz#cE$OZxk%rBgoexpl(7bcUovAI7|j^bgvI&1gBf z1>T3UWR_Ks_u9bi5$apj(l6(6=zDkn+5T{Z&DPDT%woj!|MQ%lHf25_c|o1BPG?+_ zYVi~N290JkCS@xIvM9U(pv*qeHWyjZAD3>Ac?nX_LlPl3iMFMfmqw&J^XerKfdMxYS6wo~Bhjd|7s7&aexCNtfgk1wcJtBW@OG^? zCZT0>ZW(+%@NEJJ^TH*0$`dl%G^{@^TeaiT7mnSOG}cvYOMpI;zD)s7G6eGDhEF(mQd4wZ1&eb<$$Csfi|tgJ0(BwU!M6IYbN0dh%Gy zC)mQ2YQb8Xe<5B!#jq&yr&+}1p69rwcbm=%6IDTpUIv(^F?LJRuk9zjaH9)7VQI@ zBqC64mH-OyN+XWz#E<=^Gk2zbIvV&AK6w$mRt>O{yLOxsS)A;8@$LPRh!duICw%6* z4#%A6d_E~26W|tKtDJMeM$kDJXC9fa#m39!|O_xXOb&X2BVTu2lod&U7EQh`1GxL;|s)BFla>%ad3iD76g zJ~$`*_!_@j*k?HjfRz+RaNc<}*Zi)Q3lf;nS$_su`HVRXA`t;I&V=jOT{SJ|a!U^$ zyAn%ZM6Y+HmwI)=tBC~cn(uORiFq$T<}TlMoY-JbA`+S-53P;ic@9&_2C}DwmlIBS zf1Z=-N+m3+U`g=>pK!O_E+4jx-xHCtWtwh%M?y*;1^^RQ0}rJD0jD4Tx>zlzKap|; zECmnntMc`JS}dpQ6A#RzF8;}5uq6p}`C@yM`%m=>yY8Jp)VS<}wpX}jb_s##} z(@1aMzCG~$C;9W~>9421o&FmD0RR6oGc`6h0p0&(Y-rA)U^;sL(}2W3|A zLZICX$=M{LVIpwBla*M6<7!!75syhC1&)IuRA3P9`GOu zwq}=)IC8aKT?tu1^NliR*IncwFUQlEO}r<^SIAt~2AX4L+*OY;mA8ff#pu?iT%_+DER_jb;fe@`Wgy zn7q7GFe9dSW|2Xqw~uC{_ZOBlv1j`N>GFQMoQIwWlcj!B@#K}ZZn z12#Xf;D*Xj?IrAhnP8wt7qn%(Gck7mM-FkDaAj`{&l7#!${ur~`vx~pTu`+XC;W%M zD{A?Fd;tIe|Nrb=ZEqS!5dO}uIN^RUDyB)=xUHppz;M{47!WUMt*Sx?K4WBT2zM7J z`SqRWnc2JLB~`1Y&6glqcbu2G-PzsQ*_~%*{?+>LCdQZ3|6cqkm#_NY7w&(EK&AkO zf&ahK|DK;pm+$I-FTX#1_ErD;KR!o+>*e5i?Pcw>R65d=Dn7c25u|zQ5@y6a;dP!v zMF_&3mCGPBLdix_a18CmzCeAcm{*%D6by=RBxUQ^U&rrL%ib12E4mAgk184jIS=7S zSB?i4z|WnMX(sR+)?ULA5n*#C5A-vtUj(lJ&dTE8cV4PNtycR(3bg37nK01~un0Ji z15aXBbgqz_I$-$yFc zS2hE6MIgLOe{Kg=YJC2@FLlExjpjiC!%!t(mDD1Z5)Xy$B7o5lS9RgM8kw$~<4~ws zZb;24LG>-Zjj|=x$ML9j@{<<=acP0S4!;V-FwUkLK&D9EyPD0IJ<@}pOZ98HDoAHO z2uvLA6Yq`R3ORiMJuX!wgA|%o^34-tA!|))JV}+Gcv}7ZF{4WFPQ|~=Ur`*&nS-aZ z@f3=FsnqQKcHL@s!b#X|^k}%_=aq7$WHX{a=)Ddbqe-_e+dFiMp5>|c)zfNoV==*e z^cfx}%&3X8QsJP`lKHMf)zHW`pe=gm2N&lX!%gb8_15C^D%h*m`06|yuwoX!(?x}k zA5|I{Q7EVcJ^8pFH`r!wa>a{L7k2{D=o=pG)-1Z*_>9$Yh*E6N1~M% zCZ12Vz{$aNmXaTg2AESO5e;J-GoqhoU&sqNqu9y-m_kM0>!dgwr)dQP7*1ZmZQ67h zX&%l%Cy&3+@k|(C+a6bZwi$e>F$n9Ua55a9OR=HjTN2YMcMan>QQ>)&7?74WP}KK_ zXFs2AZRa3#;GX(IDl5B28MVd6-NNn{)pfQ#`-jl8btGSCcJSs!XXu`n`^(gFh2<4s ze}o7{TSVqj%vdqh^YDPTaZHKj8Ys(PhOO-bfQhJ~(DH1Li6yT=zZ0?p0k>N%6R13> z@H&T+MaUI?Vj959+{g*f&GC780#6z%UD~9b-YOu4S6``z6MlsWfBPYkTp!2@hXbGW^L+%K}Uf`ne>XVsu1 zr8B7>9(Pxpr+CiWE9gNhecXrS<;_Yt3FSq2n9Va*W3YNK0)s5klEZj2)tlw&U39P4 z7$&IU+ITU1f^}J`VJeUB;VL0NDr8bVJo6E3&GJOk`Jf%PCRZV3{-hZW8~f5JI8KYP zQQ01d9DnLouNL-)m`GIBu?+yIx-UKD`Crek8cKkkyigmmsYqA`kKJ|-svK5VDuxrW z=4w{q;2mmZyFJTVZl2!@s1o}vG-gQCJVp${zD)ZGOaC(-Abk=Jd94M?2af^jp=FGL z)0GQ9?&)f3Q)Z-={C8{_P81pJoDMUW?PfR`cbmP2HE2j)?Kcs;O&n9IPNmzcT7iOg zp?etae!bQ_Q^LJ1w)o19aWB`0^HWi%U~jW1S)Aa=b-7&3v3~AzC7Mp5^F*oYDK4m> zlc97+0C7N$zgAepdkQY(y@S)nQsL5x`7mPbk|lxz(HYH?ltyAgMO?6zWgID>9^}j@ zzgMYh&JV0eLRmISUPyM`$(b{cun4kJ2e(L6n3bJMroKH^5lZRI(smKH3$F{xdJwGn zLFf(-Ajg&{Iawr56Dkyy>JA|2oo>}47bxnu{0*$xWva(p?wLYK2Cr_~a<_B`dC|>A zx=24%&Vn-52a?g5S@xeiEpFy8dAB1n(SeX5>xTR**JHOVihcW?1b=f*JC&RG8-rAko${J26Z-!F^ zD;;gm?P4`8rl@m@Au2_qW~u$0ju#GUgcaVK%hG}awe!>pYeT!+X?Md(yL%Z908r$t zKBO^jDT~bN9yxg|^`Y;kleX$1N_lDuz|Ka&fcsj6jveNABIFzq#vRL{Yg*L)R|^`@ zGZ2ZAF(;8x)xIeDDgj=BryJ1B7y)Fp$)Qf%5s+Y+GtH8O#JlW-3YuxEf`t{Kz zH)aR4Z0+HLqC3Z#2{~>nOf;*i$Qwq2AF(O(Bw<9$A#=vcefb3Eej5>V1JVV4Cy!;wEL6Rpm)U|u&5B)*`-nd%FsdB zpgcW@AM_QCkf&U488YPc)7Gem-spiC{WMsFc0gJ*6t2NfWYapHfx&{v5R5K^_Iex zDN3RqDe;l-4sF#ba33MF5^5Ww1U`l$KIt{SzjLkjdO)O>3@ah)I<0rZ? zW7E}S&ujJ`D8A-S-G}Jf(?s&jXww3U1o06D(~ zC|Aivdl5Baq`O;&-)e_YkF5qQqb;DP0SLDXV$Mhi#`mODJ|1PPA;P{$wif~?sT^cE zADM;8D_S=ylAllYeK>G-T)G=d`Dt=f?OIJ86Kr>iXH=-fdIzvMq5F;CZc;YHp*H3PFed&$GiIVcBJcEKQo{SdHO~BEWco*)^*R!uxWIyb z&c0;?EwkHdvI_?XHk5)XD=-P0z8YKFdT~dby`LEWe)Z)2_s6Ck@*EZXK5E)O91FDp z@FtFetYP&qtu*4jZV@dmWBz)DB#$)l?~%!U-O3m3^E5;#+`=R%e5UO3HP2ZPdc2mK z9Cbvv;n7iFeK93pSNrSNxmbtm*LL(jRqN~LP?dJ|2^ZC=bhfuj17#)AP|Vfsm#P3h z$fwhJQFZ?e=(&3ET%3jaejIgyf{lx_wec9rnD9;n$gIVs4W+CbAFg(QDErFl zwTWKj`t6HUa-ldPV$LFvRzfkBWQV#tlbk_rIX9@gnoRdKBNC+AawK+^qfbpOFKm|3C(be2j-kgb?uFM0R%O zrzCDg_oBR|x9j1~jhrVA?Cc2_@!xf)yPRf}iljk=DblU>3REktE-i9Sf3BsdCF0I3 zV$8xsfQ$4;?cQP;z)ji?Q(%Y`n;xA$cIs*19#p(Dfz_z85A(A4ei?;gVrN}awVZQu zCE0p0_T5Aw!z3;-9Gillmk9;UqYZ^~-Rn}hq`ueTv2uieXUV%DxYCtSv!6W~DZ1HM z%ECJ~+;yW?Htzb3lWfgzTHX%CT?VAzGjwQx-g=xfsM=+W`hd=^IXmcVW`-##iK*fe z|7hON)&rqbqo{-ukr04>ZSDR-)_>-j!D-#O`#p@xthiRKhQwhoI9>EygKB|88xIly z8U%83_cZm3gqy98t+IGXZCN_i6~MCj6frdaM!^L5_eEBQ_{sswQs&fTS`}Ajyyp_4 z{W!Uq=Y31OwI_qZBLZhRcjqJ=Z0MW{U~O6)YON{9)sVVE_HZN2u1Ri37A(b}wsFPV z1)sW5Ehe9Orc8lghJ-ycIK<@oaZATHIZR0+}UCZLdA#1dLm^}l!g*`D$44uR@K z=b=&w%dG90@%ZwM4ZP&5O3MvKgLY~H^NJ{ND?u!F8{Jorlt5@xOmxHUFVRKaZsaGM zqIe7fJtZV?|ALT6i0a zj;5BxY6gCKC^nZn7EJd#ag<2{F~iRI@|$e$Pi{nBOj-0abA0TiwAnIGt4_LBtk4d< zzC}q@0$JywgE6m-7+U`%hYkl18eb(pf3?IW=DyHeS14062-#XLs zE~UY9nIDSHp*kN=+($_o5=d7ZLI+VnnwxpwnX$u#`@v#5ACKM2OyX1gaZO!wihH^& zcq>@FhNT&16NO-2cd*c>`II44p?0;Sa z*Uz*-f6R`6=uqt<)|h0v8BQY(AL(8@BYn~n2){Gly4cd)LMcDIrMSbzb}vHHo@zt#&8)Bj;tJZmi3b~&j!3z~xq#VHo= zC!_h8+#KlCOB@$2{Bj~4q5&1_nn`T}M<6b&I{pJ3j?ob&m<3pH%5;qnKnIZ z0)LRSB(8z2M_~wBde2||^IVl2L*lduz$LkD{mvgrl4fgh#DYsiP(pmfyd$R=< zJ!;0mD!SJg7JwM6IX=>W#i8=1-xO`1bEm$kRj4SfwSzP0(ewfkE3ro^scJrY={Mil z%&xntt96=EREN85h=x$c#*_Xhs@Fq<=-;T`R=*cu1%cx?Z>&I0r(No!H$}HZn2p(q zB=tjtUOkEUvDpa}>APO0DDV~`NTgVyM{(_cN{+nf3^{{QuRCz|au?N?npAm5geRGl zNZIn93_%tP));hk!N5%~BsZxAnOPU;OZ6S@rxp&N)%>{HX5hHWOASv&DM}A0F^X-3 zO6Tr)`-@ea=wTxQaA=G)4VGaa1q!v6N@lLNh*?gyKX=Q~)gNxoT3#-cQPuDOLux-N z9ns+%qWX9@`!Kql))t2mR?XO}EX=&fk52?1i-c>)Kl`!AJq=dzXV1kDe3k~vZip-Y zj)njFC#`^ASBhrF<_G}wI_wHC7&#hk#Jd*ZW&l}(pN5s$d<61k{br=w9gc>J;dI>X zA$D2YdJ({3#I~;Zl`9Ib3Kpr7rQv06JGci&dW%OqU^X+EbYoQ0<)&&`VXBzv)WEfqKI}r_Jhe{UcAE43L}y!K$XFZ> z|H1u!C{<>*DwB+cr)MSY-|LT)Vc(n!b{J+Ub;U^$zv$ms;fv93x8<0Zc={|k(T|Y6 z(w#vv?rM}RsxOk(tsWOL8jfz8UG+>u5>yx5mX#-5A-=+Orqc1@D4C3afHn$SA~a$E zFu_CF#>io!EIJAMf9DTrv4@`29OGoAPUeCN_hzpBE2w80gmfw3VQw+wjez1hh;q7d zoYS(i2#dhjn>*ylT*wOU>qMAcqk}u=Ik{9D zNAzb8J#P3#-~-8fsKt-2xzUHgrwK8vnmw#{nrw-J2=&C6ku3`q^GBU!b|1xfDfOI> zy>*m`q}tjHTOdY6j7^sX8owKC3FN@b{+S`u%)dB@L#g4q&?QCE5V<4pX@zh$4{kzf z0E$n_Jhn!g%)<2q&_OKHlx?_OjerJqII{fkbza>~uTm)?xY|gB2ZJ5{L80yNAm)T_ znLR8iO9e9(s@O0RRQ6Ic5Y>3E)!S9V#I){ci@7oYf%a59Tt5Jn>G+!AP(OVmE!9N(dE#(C z(N#TEy?C|3{d2SD(()*3NA+LVj)>EjV$hz-wa?>+;Q@9fRTFSq3WD0Ev;t3dD-SRy zssK#e(44CQQe$CHxHsS(rnIGKzG zCxg@8XdEwy#|-I?5w*=3D=FjK=?~hB`kUnp=pRd+7t&~8r8Kt!qAb@XUdxEgdi2w) zS5@J{@;0qNG8(@~ffS*$+bNJz@@aboM7Rb8jxOH6ME#3CVfh8YHz>sRaK^MywIE@sIbGX86T8nA% zg~YxD!Uy_)j3jlt-PWaX#j+a+`h*V-t5wbpe=}A{4@mcW|1d`|m?ahWih5o@W{dlU z0w5v|&czIk&_-ke(4jjC!2wh$m#yCeETCPq<{oJ7P>h5a`5@p&WdBJE??wpxn6seM zr7AmugAPme)}g7}y1+UYEA3m5CTy%XLzr zAAx0z@{U=jH})cj>eX1H0H6ssBcoK} zVU^5%cKxN*Th7u)oOSyJf`G6M+Zfo-KW6Czf-&q{-mYkg=Fcl7f7HeD^h67aLgLR* z7Hlk+UqGc>ah=s=^@?+B!hZDvy_G((BNmyKJ|@GFITK)v#&Omn2RmnWcI-%ql@+!e zPh1S4P$J&YHIcq+LLK2FvV{WZaqhUZKI+XUK%Bg&9e_RMVZ?BP0s=GrV|q=Ul6QX3 z5RkIUSLt%6-S%+kKl49+ZT*Z8%RP|iSIOPDZ?jS%!yQ(pW(cX#iN2%Uz&4gx5~S1S zPA$)8l)CmVz;z7DZl^HAOMl!*fcZ0r?8S#!%6L zh3jU^NQH}Vs#CC%m_aO-{;m3r+uxx8IekQvPAaRx`?y~@*XW_hm$!&otd2p1J_ax9 z4<=Bxbq26TpGk}{W^{yvqvIg#b|q`P5M+5V!B9!{GH^31w3ZM#1}Z*$ZE(FeM!IH| zGzy5vl-&?+g>j%x*%pazpB7G_059m*nC8DKg|#q}GOUbRd}o+okGpZqhhrkRylHDt zM>-ZrQL!J{8ce;zN4=B;z`fp3AoUHnVRQt(LGB!a=2}!r1q{K&t2X$IVRCjc6-xsf zTOu*H>J|KkR)z_7R^&l5bdUAM?w~BRx!W7*^ZJBvw!Nu>Xn-Y_t(mHk@QC>p+}QjK zjE=~O+U6PL>GAf)*EoI$ID7{*bg#WRJsrG^LUPi|$b-9C>=SH0iB zkD|b7T`W$7wMwL+DmjZ~8?P5cXMMd|y|ytg_Y}Hj|Gq5t%i?-}v0?x8H5h@g7p+qz zW+0*n&ac`DGj6|Zr8s#+DTZDGW9G`6|+qgf8g*UQ#}wJLCmb9Q|0I1;)3Hf6qC zxoyWW=VIuZ$#boHgiAv%eu@oOQ{fUF!;@^dTT|h(|Io;Wi^CpJ;reX29E`AD$=Y9@ z0v=P7+p%rxqzVFDYuKmG561vCu&%GnA5!^n4>Yqm&aT1XSWO|}zijQ`LfeI9C|k^K z_YTVe%#^}}%c({az2~ubdc>l#@xVT6_a4V?#!qB)b_)D~$UbSF4S(?C@sUL_pFjR+ zKL1Un@P>DI%^h7cgKKj9ye`eh>TX4!Kj9tVxeNFM zAFGY|xcS>#_NDBIMp$)+$?=6b7d|Gn=DUo)@kFW5c0nz$UDFzVSKTIFrVt3?%0{&f zf`Ryu&gV~C^%brk&#HGq*Lo$%ZrlQIAm!`WED0J8KSST1cyr zZVC$HwFuZY4>EMY8>j*)R(07SclY5J`@3$ugKZ(YXpRP_qo#LAj~cBBHV%N+$R)5l z3TG=Glhh>Zw@qQyyqGJQer)!;$5Y#PlcXdLC$HZy|M8o*cg9Gnt`|pE;-7z!|eiaU5WSkGr&S`)CuzL{dq z$r|waJ|ak_oia^r9h%?(*^h4HtEnUm_m|jKI}V2Rn(7m7C=dM{&EBO&u3S3d2eS`H@-lq@`-6uMZ(shoFk4 zg|^_|{x!%JKm}A?_0g21|0>`w)r+7cj32aQBR?m3;dvO&+HffgUb!|y;pVRO`_z7n!IXxfa3j+};&Sb&#_=wcsu63o4) z+OFz2&I~oHRx7lnf8d3#L{c1ReXx*SuI9FyAQL{1?8L+Gl@RY$oQf34PNh zx6>P~8zdVq(5~c00n)%(Kbhz^wI5di6pLWIG^VmcV)O~0rjI&>8X7U2+#-6c3I7&#SVZoa8Qp#{%s5{rm%j|aw3 zJ|3JwCTmpB9Kn)0W&p)p%nH=4O$znx16NfpY zo);KJiAoaq-S(={w-(mEV@UlC5VL*P{tk*KWCLhL!?;Gjc?JiiV{a#)qs-?-ZrNwSTdtX1fkD~^exScL zRF;fL1r!v8%ScQ_gdzosPU9Z>+cVGQF1b{q7DkSirRC0WcjvJ)-{;=2e}ii`r%ym> zC#at7c^r}9^nN^i87(IW6EK;LqLuHoAn;CWVl*WSvr^GtYLCNmOrqSVToYMZ=gC@8 z&hf0Mtb)~nR;vnz&w*t1QzOYMRBhS7u?L+8^4w$#%1EG-?m ztE)@9*G2ZY%Y|*s+`*^KW)}zus^HwD1m*YQp_FkB5&a+6Vfe$k4(8qzd5*Gg@xSw65el=|+jRSW6a2ipio4#rBM_O4Bq3i>vhG`Phs+s8f3oYaK zZs;o&pL*3z{3*SjEtz8waRf(v=3QMaquD}z%`en9Ab<+CSxZ?JUfH3Et6dJ#6ybuO zTUR7M2WZ#_c!xR&Ny4A@y%=C`E?7hSiYG? zi*Xb!j|<`8dxL>kGo&{?85t-J+a#%6DmhHQqIkAYRr3jy{mGMy>M@s=6~tr~_su>< z8i)`ct$3V5-HFy5?aN6=pV$ll6C(FfVHhpZw5F>uulf#~ZYsG*6F;Yxl;ZE)sECIV zgXbMVYXtb#t~T!=4QT5-d8O7H^QHLcJHshhu4A}C4VWh5HJN0bg9cP%i)3Iv`5J*F z5PBbKt!j7b#t_A1h<)rhD{?pDnWryj;FykaG`;tFm>bin#}?ewGPOKPxhAm|p&~nT zMG?eQQo1FnWCMDu=TEjL{8#WO_AcwIvL0=$Z*q-dxZdvi1{@)2ZurhdMkBM&HLcqn z=eLV!`Mi1=?!jt6bh)Bf_eZ71c`w}2NQPYODdm*pA5*ZJI|5Wsv1tU$RwZdTU#x=b ztMDc`pC$#wts5p0T^35Z9Jl%`t3l_ncNc$1Y%B_-o%QXjFnIl#bA>Ht86EBnNf;b- zYf9m5y(RMv@{!T6&*TkyNGSUi1>RZQERr-QaSXdRI7#>;3W#8pyK&wC0pn?)(F49l-l zVKkTJN_Yo!sIaULucByVbHx7=oT;bk5S|~-{*$^4k0v9va`5298O$b#Nn)GGzNG*- zAM;I?NCj0Lqr}W7gE?8*$~^~wO9fYc*IE>E>&JK4+GFh; zO@b0i{isM%X|V~>ogFy3h;)_}F@Zk4qAF2la3a+1STku-e4~g(LNc-7o;nb;D$c`t;k`G zl*mv3!!F`?ahdkjFt(K1dHNr-ijt#fA5hqvp9x-YeWL}F+iFP#;!t2; z(7&Z1%LPc?X??3Fv339q6XN-HyAG3235QyFkzddauh$1f0?h7_isoM8gvoY`rooZ# z|0>IT@pjDYjhb^S(Mw7RR9j2gVTGiYm*D_8*0>OQPNsIn>9xe61LgH z>2zk6Pudxj{WA64R`Vv|K#(OK!?GOX3t-{kJ$~p9NDJuh;A`z`lO*NGaK@r0W>#oF z=Q98R0RR7@AWED({TzcL<3s$NF(U-Fk`-9SLGB7Jft>n~26Id?j#x>AoQVUT`@_@& z00030|HNHOZ`wc*zVj)r7@zYhQ&`f9u$=yZ%IZKcR_Za!O1`s0B}+sF&ZS_C+-v@4iyleMfO z^Ly+oM=YvBSq~A%qk*R2w>AhQNx*=Z3(Dj95VLQ_Hqxvyd?>tgllDK8z$7!7*Zoz1HQdhxOK}B<62LM z*x^DfutnSz-D2tX80RJ&FGj2TezXW@tBFEfK;rW{>d!O`?}y>Tfq0Myd6hZ(} z5z`3S_2izY``RX6RoWxVX9LU18mV`xeRC$p%~^0gn<>(PV2&MW>>O|8&=}6n>3Q%+ zkN7BU_iNhH+~*527(Q5@H`w^nQdX~g#lBxhcdZtIJ1d<=zX)!Jw3Vjxyn^YkEhT0+Id>a z^NACP9fgM)p)a+}bR6pa9#~1a58V(JB8RudI^O(zMb$l=gXeUeX6f@Eam1O$g8_r# zXJiTZ3rPlb8qU1V$xW@R^fS=@pnsCBKL$=lj8>G_q6@ixmYsg0%gqs^g_L!yWY=l~ z^i0pV(QFLITv2WX64Gn>NHgw|dfKJ?B+GlwMtxFxdEeWL7b=Gi?gf7{^ueo#;lR|u zUIkyi0+eTwCnfT)%@1f#sU>8hl=LsYrx9(pJ<1DTve-l2Dp@4TZu3%j@GyeR=TA10 ziA=Wgk~IoY!0wV~y-D(%q3a5D&ekU1hrGUgY6YEwj-(=|um{ePuik&$aY>B`>)I5W zqnR=k-L_G(E2-LkN_={^)8QuEMbuy2+>Pgkj`ND<_cl4UD4r+F|CMBm=x2F)mQA)) zJ#o-;xK6VA` zkEcj%2XvA!J^0Bi?; z2cV7Ru^GE@B|#f~he@9;TIL)&WOVOhE`SFWS1Dg69Sc(7f>M>nUeSvnJ}0~L9{>OV z|Nq2YO-sW-5dAClrqGiJ;<2`riilDQUJ6BRDj{uCOjZ2%&YO?jolSBOK~E(iO?I=B z+4+3$f_AlHsHorgeWjgF9R_WB_$cxvm4D@#m}J!6DU!=$%hqB(TG1=G4Gh&f!JZ-v zg%IE90&#dwC|UEyw>$ul>R==26bZU zrIpQgA&7^`bTuO(n8$9}j`)MTH&@U)?B+vrPDcux zhVzl1C3;NOUh5sB#L_r(6qpG7CdHZN`$FS1X)6tq2OQzR2x~zDw|f0x)?-YtMmdk3 zy_Y^TLXgI{*&e6Xf62NJ#}uQn8Yi&Dl2aHW?p;VkCZZZy_e^1?SeWQeDWTlIxN@r6x7qzX1RM|Nq2Y+iu%N5Pk1g2+l)nz)_I&Er1^c+i`;W21!mF zpnywBR7^w?1yO90zwgeOncZ1(Ez4rtuS50oMgNGFe5o~&Qo~w_^F6pAV)L>r?FZHwp4{)uiwdJ=r7{$kp2YzhiP7@7$00e)hfLYXBb%WV zFg62+ZHb;^SY2m9yB%okUutCYXqcf8aeM;kAQtBtj+{AR=+TOPqI2i0cmC^+9Tm1R zCj&K@J{jCETb~TR6ZAr_TsTfRf;ptFZg$9t#=eIjfM}Kh3hBr|wYqoNUrQz$lC$#j#pqs5zm2ozQjL zB>B-hajg>y4SzO3?zAo>mshCEyA|KZs;EJqF9@|IHD#@L89|dQ9f2B|`=zE28 z+pndhr{w%Lc2lj$Yixp~O|0}VfT_ssGw74+rz^#{PF7;vsXW}U(;J4t)LkO#mF$NQ za}4P!QktzPEw)&-m6LjHD>x!Gbp3z=j%$gCKc^b{v1R?nb+UZJb^S-EW}s&VhaZm5 zdK>*uJTukUZINt0lpos1!La7KSWNg1$|JQxM3;g~`S_caisyK{h3K(KDC*i<5ruj0jyQf#&}0FsbLu2(z7HvA{3h4J%#bB5%pe z{kJwStug8W{0$*FV6UwO8qqieG1Ou2Yti)rD8kl_O;7)7rd{RJrg^)8nlKw6ai9U7NKOPRh zq!Y>$?c4KzQH&}7o;5auo&YDD&o3NPa)RB~WT>tr$kL?BC2uN6SH5SQ@`CaP1ZOzb zLjIW&aLNk;rx4dG+#I*=p?%JR<|UHi1df#dhEC1N0}KZhJ5WdfJkIqj)FbL4d^=iZ zZAM(iGMNo8IT3=gERa?5exgd`ypx`;;TM=f*UF3W(%{awUJ%+pDa2x$f zk+fAwyVV`Poz7z^SEi+-&N?gO@OUst8&{j%7CBkuP`B>y!&i~$oDSqn`9OFck#~t& zRG>yR3zKrSgHva{!~O+l^bXSKJdvzUAprOHgkNy|4E=ciw2P+$lNz33m!K}hS= zL<`{GZjT_l8b>9;&$nTYSVhEr0UpJ?h`eoNKc_I92~iWD|9F0U1QA5C-rz?6m4rat zza?^tmiCx(C6!}(DP#op6@_T@|V@Oi2eRyFoW3adh3acSa zO5H{u*%HyBh4g8>`YJ|)w3|t81NIldo; zWE-#+E03~xt3bBPWeUocQzBw0+ZYbDaogXwfY7aV8Ov-C@+3nh-8XZcHY<9|`Q$Cc z%17rD85>e!Kgy@&DsLYJFfKE28}Aw?JU#d7NQ2sJ$9^4;CC4ILeTC_&N4#v2fDkC# zHG;rg$Wbbl;0GZV(b-*;!c4K}>+;RdN(FPE8Q$f*fDLx=2A{2}8Y*#EA`h7a%Va=I zD=;KSxm?M~>Y931mlybx8H2|4szSQ4sCUqH^2ohA=uq8lwk`#R)5o@0JpGZ5|1g7h z`XQRS(kQP;F{=t~#{99%HZyfJro=7~ixbZM^cXpbU#+!(e5RuCmr>|bRWdRH%fl?>RSPn8$1+5?-Rr$Oamosqsk!5bM@AQj+uJx>n zm}+vSj7lowd$lBc52glxLgTtq8faC>>`p7D_&WCxr%Y-PAImKi*{ko~X?P$qSt-gw z^e{FD>k+J0)Rgs380IzRD%+%N-SU$BBG-nYqyp?47YX=6Pf-rOLvdYMC_3jTk`J`V zCs^MGdan#i+jAQTI~gN*=@+3Ag=VD!^l&G1@>t!T;ZaQku$1Ch$u57CaY@d<%Cd zSeExTeBc^+)7jzX52(qvJNg-R*YD61J6NJS{IiUJchXY@p{hIDWAhx)LFN6 zD^ehK>=bhtU4!nkF$X&(JKU5j~_OLabW zH*qzDs05BYeDVBZ7^P!TxArtT;TtU~N%|RQCaxALAbe?wfvBMxt9rpa01yi4XEtXW zF%K7J!?VtBfli|?WEbP7}k{sip8iU=S95!xjxTCSCZuD?DX*Fw* zP&~qFB;K7aDt+YUq{)m9rW|{6Q7>ZfalV^_MwWLH zfpJjAHF%0W$n~J%#iU`@!XUpl3gu`_-|IsI1f{UFc?390cgTS{|5j7 z|NnelL2kl84E#z@sHgs+9QZ)_0Bsg20)a$UNagi-W^89SL0q^cY#e8HJ@(kJ!hL)| z#7>K#p*!>fk38z)lGErpo$vi-FF-L@vrTAQ&XCdkdd;aa9s#SPD|Dk&3a;$KfQto? zc4~{PNCOtH$yPIC*yVLc>Fs}dO=l<({s)O*)n)x-cPr)RaGAbpJqG5_72k`tUlGdq zC!{1`ZE3b)S+?c2rWTz!3qQTaS(4?&A?mVoDD!JMnsdU05U7dROE3k!Da>Vg7Di(- z$-}_BiO3B(QGPDr!o{|Z7&X=P_`$M*+7V2dWhuXfP)|jw{6qdw3mlUf1`Xz0Rd3;* z>lzWpABOs7+v|JS78&?+f zXMRP8t1-YaG>@FZEeFKi8ICkvypatf^MBQam6k;hpRA59ndZ(o{Q8SX1K zE?wVN0kMhdmbkm9sA=sHzrSm8rw&fK-PZm|pCteP((nL;;G7zh2-I*uIYoqyvSU}* zUBhgS@)&-N=jgFvRLiWumynvt=R&@f6yz%#o-zth*f0FwgWq%brb7EsGGJm>`2%BY zTfZIElRi4?o^?-7ek{@K%d7M zcfYcaNCq^lYIQQ#tWCknOQ_-rl#FB<>yqZhul8aN#GbwbYLKe5W z-7*oZ8f!(srmDN=qz&qP-um6A^gk)XVnYIKA+TJ$ik6qj#J8NYXi-s#*MUamh+4){ zQxHa^Ip1Ix8><&t=S1n_kw^=<67kxR{zN^HEiBwgToKu;Ta;?Dxix2T7xz^yS|i8Z z(5^{)!&UA6y-vYTj6b%@UwsA`%O%rrk2#1IWwT(%x0)Rh|4pSzlx6DO=bou}Ke47M zh1#vH=wj=JxP)wT27Fu^^Adp>IEqW!QL<|-wqNDc;MK`ni}>%f@1PJUa3!;n>~WP5 z$$mw0u*kwTVTqhAHcjWS>;Fx7t4S+%HM%p9qxzDQWc^@@9VtI9FCD(EP^K58f0;ok z_3T1x=gO^MSZWQ|5t4ApR~NLhpQXOTk(zD{hVlyb*B~VR*Y%Vr-=^_Jp^80tqjJO} zg*IwG%(dDNG#l5E^|6NN#xrU%o)Je6#t5A}EQA?3tWT=s){KWr{86?=RmJCFy#g#^ zrfTqeKzwq3hdb8v6@Bc~+)YQXSJgMuz=|I5@;W+N_{bY$1yvakuh)ZkKUr!?fOfI)ev}*bT+SM2oPV=g~F7Q|bNa5lX+u z&KdP|@uCKlfI^bY{(-kM`8YC;#>vOBk`b<`x@)#*d*_$&Y+_6!%c7i^$(u{{OYITy zP9SP_o9PidK8gcx3AE{EOB!JZ6l-EOYX&U@6X(g&iANnSV$ zXrKyLx2{l{hViY$!-ePtQUib@^8h-u9|qCH&q`wwKr{ansk4k%fi_gfF8la-;?XM! z>d9X{sqcV*LShMAb|D7#h;3ksAS`k3Ij4Sdb-j|EO&SNBa{@o0<-@YVyc|)T)L#dm zw+PDDVKW#BLyn!a9hrl9BA@AV7!g#qCTQ90Xj1x8WX-VOIv(^|{q}Lz|LtWP$eAPn zoaMs27i>dwu2>(QzlYfl8L!bKWs)3Q2cC)nj!ue zI5KHn*UR-sWOtYeok0gexFehp=wul;jPRjoy0NCCS*p+Ewdc)|4X55Z5ok1%1w9VZ zLqvII^z!O}Kgvg=?yz$Z8s~mxr$98=Q~a>Lob35W3`W+xR|u&WXh#7m%-K#yUnM~-5uh*aRd@^ zS}!DB31_Om6lCPGBeIrIyxTUv9{!ey?F`(P6XqcRQ?BQb#x|nmbs&UzJ2_dewwfR&)vrlA3xaL-80whnm=|Qm~VS~j~)aM{z_l@&izHczWgE&;xT*e z`gVcj>R{`j7VPcpJgnpUWBUGtzJE*Kp9X^%#YA5xX>^gM$=ov7YYI1HItZGzR`D|% z+cN7mhTbs-XelQ5>o(a{6Jup@y$M%<6cWq&Utb=Nf|tzT6!cc+3_lOL@i_?nVFO&_ zlk}1f4v}1l-US0`LGS{40*Mi$1H`mhmGtnTzCxY{(-?TeP>aJ|b1FH=l_7QPoz0Ce zOM31)XidJ$#Bzvc>Z@I>W_79|y$s%VhObUW!=QEiE_mDO8#Q70?mLS`1^8af{p%T} zLzpARC@ApcAd9YT#DKY@wcqJ>hVLMTUUY`X?ZF^07Q0c%jm9zT9E`fHe$X5Bdnbc- zGcfuF9S!FGHDh~Wt=`BOxU-b|jNr2fHG&Hmdn$@Q0KJ$g>s)Nw=@O5x{ifSrX!B@NW>34JmQNadZoqf0Q zpN+r3{$D5mp+%6-KA!(((fH)iqjLGb`{dEiqk{b3*?ahZ`TwWL|3GIs*lj*;KCvR4 zlW`-UM#q|W&&F`7TPStj(Oji8s$A~{1GcbhwJe$0xr}bKC8|l3vOr zRA1I0OLb$5WFgd^OTuuvkZ5S)8jaIugrN@@M{o2Yc18R{Tu{ws^Phlsz$iDuI+c1h zR4EJgII;$)3LB*;!K}9h)@K=L8=re?#St^BZpl<1;VM(@I~XP^B2?z16o%o(nnn^FsSZC@ov& zh9pKQudF@g5`KtDb7PmTVOsu)V9x5zam z%JTcit@ir&rrk%%q3vIR`l^C)3ys?YRDZX+}Z^v=4>k-|7bFAhJ+Mk$GW!ChJ^F>l20_xAj zB7Ps5gQ6a^7NI!+>cRdZ{577%p|MmC!euz4UoJtE8QEVN!$qj176j=%SR|%9bm_0r zxq09r6~+|H5d2Z-~P_I&Oh;9;~m#C?x%WylddzG3x;^2COdl}`YX;4st!4N_Ir8OwOZ94}F;v;-SGngP6=8mE8$^WjA1SI{b4#H?uvA%;T1~wfHZ3}| zl@_`U@rf8yy077>-EUAV35X2bV8kEC@W>B!#yz*zV#1!*Ed#PmOmadBI*+~E%o|^^ zbiZ^l3TV0QjgtT5a0Bh`LC3-*`Aow#{C#7IM9_5N#}|C`2F{5voB`?cX^=b2GNTW? zJTSG7A|uo+6X1BdWb7+Du(`)TdA0mBf>>V@7C;rf=o4%8)eN!Ow~DeRcBm$&c8UXc z850S}q=pj(pSQ zD=BPf@0pFWXERg@KkaFq!VI)D%nkp^lw2&j!}j$&bh)G!`p0z7-5 zJI%>gT)3&lzOW$ywj^pcr6zc}rlvjz9lfPO&=Z;Plb=r@vo<|QLq=+Z>kUtimKGsz zAL>#b4p7qa!j6HRVP94*coJ$KLRf)yHS!Rg*cfBJd|0*fafcagR95+eMAN`2USvxT z*?t|W`C)+o&do_afBA~+EldiBve~Q)MTZ$IG9$?cC}K80BP~Z9JxBIBHpdKy>Pcp4 z<$W^Xx_nx0|7_GcR^;PYtjWFvU@QW#FkTLul((EZJ@Hb*l`8E|TGKRw_u2&z<|4(p zwX|3PhoSi%G}=08lV7+blUVigay!{M>LlXlM@TZ0s0H2qVXPSW``gw()}xI&vYKPe zIDz+V7ZtS6=*3Vmk!Psokh}I}_%dC&x5H&R3ZqH%^8t)@t#EJ#wyAOUvVvU+^vw;| zeY|YN`5i4@uUal*4~7zGRM_*2T=8ee4OHidfD^;#0s{0d%9$_WIF?o3j-w0)Vlgb72JT52LY1{->h=tiR$qp~TT`)%V%`%#ry1KV;nwlk?C;@7$ z^=fvE$Z%fkNmXnOq3CD}N4`>2P3<$|5P}vXU3At9AO=cHl@ZeIEkG1xpwU75f+Ct5 z9u=j-{;|KXxWL@(Vlz$!0WOJ?9MUrI=-hH-L{1CF0B0l0Avu?EIL(?vI77v}>hnCO zSAa{^0JzW6yGpdL#(!L-hL5!KsW-eMsUN|G+Yxn)R3>bP`1L9!$jcdZXq)XAY1Qe7 z2sbrMf%rjEqPBL@B!95F!AIY$-VTs z9N81v-m#e>B zIhX5>_pTN76Qzr#b4cuPvT}N!2&~SABP(3KNlHzB!0L~Ji&%@E>D4h z;$b)I5QZu;*>Keg0Fh2phmKMz^z56AOZ`;x!yh-lE+CgwZwZRX4+3d{{es`#5ao_F z5&5~9N%o`cas_!t;1$h`QVXPu87p<`B$4p49X@>VEoq6N6*S=z6Nx8gAps~~#Ta3F zV)uX$JKHE^PAJ}#J|y^QrSYx)Z+onA-F53;1|)#`Q?Wv;>pchL`%+K_?@V%SMN)Ca zNLn20dDE4kWl!mJs2fsHF=4Gh@|@1KivS<4N%aFuaFiHm)bclp8ko;W5wBu7SqP~g zl3(<37tK}2^r1@otZovMBs`iT@Tj00py*{ryVN8Jp*K!9b>s_mX#?@sv4|qeKgnP3 zX%QVY$@v4|ygBS_tVFKo0$k5_U4kpGj8d1n(N}|I(6o3m^f=|o5 zDLs^L4+jZT=xFTd&jY_V! zRQ(6H4<8K{wQ`mLCW@o+7GpPejw+nX*%QfSt&tO5DsWADaVNtkwp_llJPlc>4@CQqiFr_nV4!Z3v+_n#>>PPH!HC4gP zodg0858qFMBGT6V?He9q^v+dj~kat;)T7i^2Lq++>0qz)<9*q)3$HrcBO%FPDa}!e`ssG(9|17ui6=gYl5P?;Ob2{(nj6Tp zoM^%lZCXFsNQqB9tz@r_u8U?OBqJfmU=^H?EslFw08ITT=f8LMl^nJm#8c|HH2#FFQr1VmdHhxOE(;6{Cye8wZhUn!S zIV^4IG4=I(1tS6#H^A6XBV@V`sNZN_THxAf`Aksu&D4j3K9o1+{4B+26>+u5p2}SX z7H9V@wye($L)6|Dxi1GnD4E~|&5vbFYum9Xl>gqq8L_pt55KoDYGxsN8<+GRPAP1d z&nKS?1En;)Ob0zuu-PWmJb4Ah0%h`n_)gJsew3sDY#-%b++NTZAJo=CEhh>pw)vU2 ze2@93_}81@q1sUZr)=xCGJP@Hs{vOBII&|mxDuR{OKe8L0I-P>z37zDxzi1|9D0Gd ztY*G~%Rz38NRHLUJA;5@Sl?tbzsNK-Qc)*7ET#s9Zqu2<17BN%w!L+cv`m;Dsf32P zRc$L&>9)BtQPi?gs!x{tgh1u}b$aGgaQ+uv(x|3DX*h{OM(mivR)7n~>`c_Qj5*i^ zFcc%!7Mpb71ycpF^P)_u|5X-xsFY&oF=EK7WlL%SX|hx4m%ywiFW=Dg9nxr1OEMM3 z*jXm2wNWH@FOdZVm(X!JEg_8)4K-bdXb-;p_}_MEL?Nc< z!&)~R7x&B%Q~h=*DR78gE2ak(&`t+L6|GZu^QT9HHR6s*F)VXuZEdUwHYL1e4o;90 znQqu^)|zSts~@Czje}5Rv_=s6)e;^Tx3zUzOeAghhp!u34^I|u9&9YG?J{2M&d^i_ ztHY}o_0})Z ztSS==?WxzA<#>lLJlo4^cn)mQC#tv3c}8`Nvc&K)QkU&t8H&aj!zk1nw(&rRTaiwwF7;9duRD)sW@qf3E!Xzc z!lHFugN(R!>=r&FOzvftSP%^{gkK>sY55(W;^)B3B@H)jm?avySoZaVt%C_&BCBb+ z!z^9XSk9NsJZVkwTz(I?y*ArZ1LCREwiqc|)3sL~ z`(k+~O~kMCARqH)vQC@m=wkBEYm=zRnvxKSqxBtxJZa1~hv@s@ZHP@#=XOwQq|{Gr z*^WWX@lC!J!&Jv@HbI<=^jkK46>D8d7}onKX(n<|U{f8>X4|q34ua?8Zu zF#|=*x|sFJjfdx0KXSI<3X^!9E#HOHgv{A%HNY_W`ppcz=q4tA8a9r#TE(Lfr%PwM zp%PLp!BJqKf1r8rJZ)p(NEHq(g=aO|FITf85}3#i6!e0QzdiVEq|a9S=k{!}0)3)w z?pw2~%LX@-4_;Sr7?w(^;`O*oJ7HQ)TM4T)UkkqU95b+Wck#7IX0l~N?9R~x+|W5p zUj6ydEd}v2Og6z0;7HPcuvFcb!~;|=>vF)b1ID-L4)RqIaG4Jvr~?nsM8T_?-5N`Q zKJ*Hn+g$)TjP9V5THBQ~fAkN79R>Mag92o+W!D8M?OqzCr_gWb{r&4 z*v%9yJCy(H0EwCLlIliOv&i)!LHOGq^4KmaEu}+Pm#=1ZjgA*^>UqAqTJk=Y`DWnj z3Az`xw~{uEKRx3H;;=>HAiYD_p}z>!gm5uc724hivarHejI1(w@QQ}7A;l!aB8@6Q z@)@gil`&qhPM=T)i*ZamN5`Ocz@S-hjILB<2<#1QLC?7E%ycm#e%LLJi2yPI4>{Mo z2O6E=9^SD_QO}JwDt67%Nh6`Lt+>Y&qoAbY0r1-eHLObF4L`A=A$GjPWF@Wq7(&*` zaY_mHAwm!iC@A#?ieQ(DwoKD>y?}APM~z)Tei8})P=oTeWD|7k2p>-X4X5kyWCxtm zn_K%rH9ZXIJiCt{Bx50AqbPVi5py^Xg*nXn>B7eAQF2a3&=MCp(<7)`p~#Am6)}A5 z!~{R*yOV`D1^L<&62T@C!DGC$+eoc1!t*T}?=`7ej^c3HU%K-7f@;apeFXIVy%56-&tvV}B-e!aVlEf9Ou<7}1ZEl%sjkwRP0LwW=(2;&A!NuBEJyEoj4gdgNB zW+iP|Gx+e6&Mj^<)FZTIv?EPpyJLDHAo{F}SGj`P#R#M#6UHrIp$m2$mVU@AKno-7 zf2HfLAxL^r2$!~6QvJ|uW8eAd#%Us#0VdWQs!{?n54T$Oy0guG0ddB_j5tLm4Y@`l7wQ*J8KZx(Wl)p2i9G;5leClkK1Pf>lLuY zxdy9PtCVX3HE7f@Y3`J8jjX)QQe8uahQs{Ss1r%%Bh1_f#VySxIJKDe=_r9nB)zC( zd;N-Yrypa63fmy;D>Z~|eqg^92qIgP-%Q++VjGXY9>GWa9@@lB;P4Ayk*58q~H z9*4R(@?nH=1nIyEsW~#ca=g+q(ToU2W-!so-r3JA^_p01^+{Az_28oRKJTyr#pjx` zH(cc$evUR=TWnC*I}`hd;?1NqA1R{KJr=7Nc*n0>!m9Qdr)-Vq(AyrZI(C{_$)2#f z0Z@;!yz5>1*N;xHkpk1AWkPY9qF)XfHiqTwLzRJtpsh_lecF5(ACpY)Rb^=dr(G0W zQ+pDa0F&I(b3#(9=ysVj{MjNby{EM1U*oi2iUE47u&^6(LSC0*aR;nt5a2UBc?7jj{ z2u+Mo;LiTCGxQxb!HBQxanS1x;%g4KrzteSgKgMm(t~YF3TVS+1i=A_*A||hqxjG@ z0F6=c{a~&=$Qt)6ADHx2jqjc9RO&tQS&aDxcW&KK!UjF2%Vs_j+o^>54y7f_B!!Uj z>SFTVXGR$117}9N(MPTGMpY_cu=kej77zm1f^35XR))0-oMkhc73ZMi#D3F8UJ`x# zFYkT0`TP&+URrr{<=b0Y9k@r%)<4)zpC!Qym!hPqO(GJ=Wo56AsOi{7wF`HpP4U816 zL+Ytcwl+E=S(~WUBb%cwcGcdi444eVH$MEKEzxBlyz{jzKg(c~EjXjVOd%b;(b$m#$3gf;z ziq06LYRRcwdp;!|O z$Eo)jTKC7NE@*&4^~6bH{2F;#Yvht_9|B$A4>NQQtqiuhn*CNffo`yzEKKzg5nW-A<5Dog+R`Bj zs#i>V0MCG6Br#rgHaGJX^kX~^;Mn%5;4}0dYacS*d!!dzgQRB{@OM|-&+5gU{X(W( zcInwru>mxUaSFU}l6H7#K~mb0qKU-dN_M&LSKMvaOYcV$R6~|Qnf|164(816h{+-SFEw$lXg33iC@f$Ig2NKMiNdb&KB=WH+X5F-E;ZrHggB-or~(BP{4(z5+=O811-es@ z0P+D{*bz|b0ZEtgkC#>rw)@E{sn0+txHv+6l^3qn4+vXY5|i)D7GI8%WbluDLeZb z+V01lB~}$b=@3z(Xk`VD);3g@zjqvCGU;EN6+>s11fd{RQx>w1L^O_UWT>{j5FfQ$ z;qnr02pnN2Y5*CXwC>(0*N2dG0Vf1JZ^1!SQ->yF?dWpAQgl=!236MC&jrnLPJt{q z^9?|t>gRY&D>jGoX`UOwI@Bw@1a>hfPV)UJKnky)`dHHrvLZ*c* z!4#%sKO3t#44}o~3c2Y|JC+rP@vbHTOr>SlX83fF5$DeVz843WGy{HB>?pSzdy-~W z9gq=M!?X|r6@mxnXDAs>JYR?9bGyJub`KjnGAjrDd%-z?0Ie+5;TII_^rH*HX`7-Y z&ARh-h;ExoaIm%j;T$JyUjWoXo9s&Acvunxr~>J?wr8RTMmPA$5iWNP<7>Zp<5M6p zmmh9`QZb62k2&N{MUz`meXP`sa}#g*tzL3y_R2nHimO3AxVU?LC1Lh5v)A-e-#Nd4 zrxk&mZblo2If*X@oU1ltf|PgL&mw;MQUu=nB|L095p1*|IHHC;q*|tTyjW+b%}JNi zGRTO2bY;Xfx4R*)OdIQ_D1QZbP@FJjW@U|cY>xT!s-t)UIi3kX&r$U>u?**)BuHNEz7`+39( zgRW|xim&~3HWqq9Tt#n5gQl&GHrH{XpvWd}=0jnNVbZkwBOo()=rmB~z}VLEyOZCA z2VGDqXUu?%DFx)4LYoZ z)!Kz?GnRgHC%t;;NhAkTWk!a?NCqsjn0-IR$-=5AN2;~Xo`DTN6>EynQCpk>X$IcIB*G`^(|Y=n`UnjFZ^21T#4tf|Rv_Oe z9!203ZAEQX1QlL4a=Vg-~IJLTE0ufw$xyk@rcwJ*z zcu#p7UJ?cl+lC^w zb%6R)C)nM?Rgg$|w5~9NJSf6BM{x`Dz!#>?A1w~88iS*^<9dh zC|w{HUL!mLW}=6+Lr&#-{4xyY_~l~JgQLhN+3(6YaS@aeB!h~=FJBm?&clnB^lv1& zKYwP_r-t-&o=GO|-Aqi@G~xtn&s2#FC`*X@X#&(G6MVnBa2#16um8CQdGs7MDP#mf zwKSE?4jUJWk;7=+YMxyLm<5N7smA6!as8{9&2d7N(aH@EUQ?S=GA!dQPmCI6SGe@0 zrM#dCGyOw?;8(R?w4-(%WCCDB^myk-I=JU}vp3sQ741?4VGs8w)f1-vbg&;%lL5Qt zNUwxoVd_XH#sL+DK+b$-Wh@6m)TenO{Q{tj7!T+o+EZ6~mqGp24^S^n?EFgs(EWmo_h&CdvK*Bk(9zkP44_7@C}`mbZD#u~=CYIk4iqqM88e2Tl- zHi%#v9C#xZs9)~0e#%tDfl$KFRbL+&tB~4$VO&UDaeE?Y{lNIbfJy%i#x>yQsVn8) z0fiK%#-@G1=bvf9ehi7N`rVzP6w(~hX5}IXd5i3h@kYv!^PSgPBI3C&E?F6v&|ctv zQ>sG-)54hJK~B|asvwlvDoopGRnXPQdG(D)hV>A>+j2bGRTlvdjxv>MN#=(sJGU#@ z0;$V9N_y+kXbhTF+gA2_&rPFDh<6bE_r=C`;2M(9x%Q{Ct_?ychNc|dF&N@PSqWh@ zF=ZHKHn}Kw^_q@QoJ3W;DRRapkDA<|dHRKLIxL>Vc3>O*pba#Tm%tJnw|D>xR|Qyu z^KNt7(?Y4pn4U;YS&;z+pDF%-@(i|qc?NVJ-aP}9xW9S^IsZG)pryaue6g+W`h^e3 z`>5#3Bl|mJZoMkaREwr9=Wz@qu`Njgp*8Z>;B2LVzuZDC%>G49EiQTqj47`OZVZH8 zz~+j0EGaOk1(SDka*^y_kNw~<{tv$uD-z1xaMIOwju64}>0saEDz0wF55A=h-I5BN z?4KnHVy*ejK@AB>Z- z9D0#z_pcVnlWM3z{l5K&&WYKUm>YlZIk{N2{yy+VQkE!o|tSi5J0sdZyU zF}K+{=EoKR#TPcif_%RGvFysV^ol0w{!*^#CeB5p=9Gbq`NW0DwWr4diV%&m?WOhN zNmCF>Us;tdRGtrHBGc=(JlK>?zq5 z1Es%s2A}!<>>1nz00;l_3@{P@>KPoD)$_i41^`lRAGnN2%!=Yh(M5+>8tzw-m~;{` zSgKQvk;-|9qf~syyk*SJmfSU%z5KvFVBFA+{Enb4gLA|(8g8#+aP+)vz*Ug^-xrs-KluoFh3t$ zQ{aqiU{$_&WN^xpSpyng$7yReV`C@_2 z>u?h@GFai>jfyTbR6Boo28HW?@eI2E(KDF(c|((KQ{wSHK-$XGZR?94E}JlJaLf#5 znfs^|RX_Y9_f zc?Lm$cm^4%fAS2>|LPeaHu?XZXK?dhc?QCz_C_#ptnZ$I`=2}msXuuJBJ~uce|QGl zzj+3sfAI`<|K=Io|Lz&=sszOTgJbFt@1B9%-HnFFdu81po&g=!fAkC_T>s`7p#Gz0K$H0Yd(S{LPHFac&%mGa-7_#X z4Rrs_GXP2Y%`?Do`zOypockXO2)JQ!ZR??|2xlsXYxOL z2E?3y^9&&V@C?i(U=zhHj{ey*r~rTaA9@DK|Fvh}_rLQD)c?^lSol|-LGjo>dj?4V z3(uhE=-+w<<$rhv#M*!I4D$Y4o$(&Dlc$@foKZgBr2UtqiK^ z-80zz(KA5x_{}qbrTDj=f$o3DGsuta{#TyC*FSp(f;tr8nt$&Z0LB0A8FW|P z(nS8Bcm^~~fAS0tSr6F$v6 z^MB+Sxct>Ki2664fzZf*_6%Ss`b&H$L%g%SeAyz<(0}&~ZpW7P~Bh zg3&W~VToO|z~I+&KDg~GzQ>CrGrzm@|Bwekb7Wl&jNXUAnn+&E__&K)&DAQzE>*BK z%E!~J0c2U!I2_JmP$S!zhSf*6idPWRbaq8OEqwE$Xg44_t2HRXR=|f2I*ksOl)jrr1G>K3)xeSOCT)!Dwh$2>f$cs7>t!TgK1L13x*IcddW}3M`2p~NHa{9 zu1~5RL7tV?BA7myC+W6j_uCXx-&zYf_dM!Vnn3+3U?O%XHg6KgGA4FP-Jp7wzWAws zAqm!C#?hac+GtVZ81+F=i|`DrBZ*>W1x30*0T+o3j?1n<{TYP|>p`}vy$^MKgxZwpmUE&+1{E9dlJ1f)EVX6uCZ%?Ar)nWc;~4CK8OL z_s-AG)~=(z7xY<+F+h=Oa$zihtc>(hvdZ~IePKB`Wn}u+a5ZD=2OyAgOxVsb++Dr3 zg$ZRX#j$r?SNOh7vhA(yQM7^hv;BF@KqMZpDT0qi^pHL11#H2g!bw}qHEOXqqupom zOEQo}I;vqQC8E9*A09X9P|zhKdsNz!6!h)&+2)VwB6~~%d5$AYX;vjN%=m;;nfEwd z)bT=20Ou{Mad&JtReCJg`>|eqd;{ZA64Uqdna^~a!^W0VU#It!<=3xZlh?~;kAbx- z?4N8*qY|+6K8gEF-@-)J67{=cQb2jjUn<=dy%8>?f z&%fvoF)2DJeM>QJhRFM78Qoz8XBj}z#m`iL61uhcB9OrUM|{mwz0lrTY33N zRO^!ZW=Qq1Dhp`QVT7@L>pfaIM}_$%eFpi;99uP)Qn{-`t!U>pFs%^D3Nro3$Who! zxbZviRDmOXT#8^eM@@8pMZ=2sSLNN)9`UjVKrEgilEt=Ezhq%0aU3oJ9b`C-7i!Y* zm5kMFpEp3?4ANGM(e8#Tw(e;*!Q?YT1)gNt7^MEDTKXpJbXO?l$S_^G3;rHVV8MAl zd~6^^_f!7YS33d-T+8E0LkYxIA27nJix_EtFKvwb2E+UAs8XPqxrO3q`>gpd2Fnk) z?gX>~?0(9qqGCKenCeF=V?vm5eMU-QRbt2=!^D@v)6C}jJVk3lxl6B_D6dNT@uG3B zsPC4{?`@SjdSW*%{NT9_?plwX`PXkClb4&LLKf-{jb7^!kjS8woGPgspQu1=7jl(! zh{_1B^!G0wwFgV!n>_AU(TVK??I?-Jje6zK#TTLFgYNUhDPQm*%~@s#WTKQnq$HW1 zAU7trc8@q(*ZGRX#2%JUy_b!Ctn;FkwKzt>iMpR6d?MMUcNP!i_A6f|T0w^7I|*b5 zvVE%c6T=kjK`onKmi#c%Khb#80cRLg)2YL$EjHIWk=(W;SIMz)vS^Oj+E#&Uk%HFQn9-F_romqX7P^q}RISYRu8OJ!Gpt ze4x{ijhrZj>F1L`MAPrz*gG_S+@_9u_F!pp-EN6y*U7lta7Z8`?<3!$B-lrdc3AQ~ z+A|+VSJt{M(U^W=NjZL=cJ>O0iA&c7nGc#nubSa=ZzW4OoAXqw<+KGC>zTjjlbbX^ zabv`Hk)PgNQy5?7>0InKnoUjc#Q&<9+5Y;tb2d~L;n>@L1%xutschYfGCmiJ9_YX* zss%i7J^t$UsLs?#ZJb^+tD>uXXnG^brqdI7fm8kZS&z81V=`L>f>$MH;Gn$ZI|Xu5vLzn^p+&4Bbvhl zW??j!n<~?T+o|O~;G}16ouR}!c@W7=5m)|RGr`@PYElLuX!=*B+W>%9=wCT<>`FokW-4Yf`9+1PX%&KY95QA}0#XG9&G@*iB6)OfIN$EI zHC!1`U@mww9BgbXY@D=I?DTX7Oib)_Ol$_q6odj_k^8mFP@ms(>1TMWN~>ZlRcGon zAM@kIljseG?b9)L3+3Q%4I~JduwsyEX{%|8M|}GpKCOhj3HbODoVJvct`b=a`4wV4 z3nr;~a+dM79iC;b8aA{y>3{K+uWM|5D!B@Y(;vE;s!E1=6et@?nT@OtY}6*{CSZiWl85h!>RBjsbEkSN zp;Gl2&oiC%krEbG8Axib#z1tRi|cq8qmYP5G}aal{!fXgBST{3Jxv=PXR89j$T15k0<;WT!G_+~O24Fvx_XR4kKf z%Wj3vqpaaUmE36XV`tu3n19Hj8l=OXo1^Z@A$`vOXuXJDH>)E-FG)JRs1<7VFt z7vK`fHP3J@tRyhM=P>HFx2Y)R&H72zQZn~x7`oU_(oP< zW^YyHm0!&ceLl1DX947|#!LgphdnPkvd@xjx=0&-7Ni4>enTa`YN#1d&|Lo(#=_cF zH0vhZ0xJ3ydCI$CS;Q0+hFSF^S`d_C{(%6$4{y%&H>{;8HOBnzgKt$<0b{M)M23Wr$JYiN5L72nF7 zSYn^RHcW)c9Gwxd^uw2DS*Q~-qe=86Vqv)33USfJ_yxFHGWuW&vU#i~JsBCRAaGSc zq-7Dne?~1cZm5QZV^!uW`UtO=tGZcG*>fmp9vjvKy)-El-R&2IJ(P?7NXzZSQ+2xo zYK4WWGKKY##17Me-fp)>sAZm~G8=-V$${hnimUx6aZ$u0T#Y@b4q>U0;@wJ5x7q2UR_-*ytS4 z$hh^t^22x*J_3}y3s?>TSvy0mSEvCM!%G8~`Ql)HMX+1L_(^C{r`%pr~)&P#p-4A~WO78Kc?(qRW?1TI^=Y0_Qn8Y{vc?sd=&nZ=1TV{zp@U1Z4;c2yYrcs{n6N>@yu!%n~ zUz;E>)Ilr@c8J(-9aSBEN1*y3b>h|NKCf>U3@zz)z{*qlg>=~$qe&ZE@_-NA5`Q(0 z?-x`W;!Y>_==pJRXb8Bg%65Dfr>ulrwgH+FsH-iYUZsCf5D68FDev~M14~DVZs*#i zkNYe=5PQ888BmB!3}cXYWUxesZL5MZs4?3?+L+-fwGy{i zMaA4ddyo6Wx|IXmJ$C66{A3Y!a+N)EN?J-mTHqJ!mWk1%oJ2GqE5X@tA zbT0IH0hQk8ZUnIfT?c??iGi?mFV8`Md~EZvvRHOuEej$Ff#(-MqRbsb8PzZ! z^p7gy{Q~&D<-Ez0>a0Ylm$>x^vCk5X95iuS3;n)E7avbe@2-WW&Te>|K!1)sbj$*N zx4X}DPnC!zG2S|OM4e^jLtGSmbpqA0i)f_Yn+Isa?bpMgK^kn1x_g1<7>!)?P4Uh2 zY^KQSDCyLaka;KVXx91X#uN0-_HXw_95u_EFB}2XU-dcxKRztpbcL_p1DZSleNFsJ z^^y9@90x~^)Xm^>0v@YOaCh;BnD+U)Jy@NlYXE`=0F>jU`8A-M&hC~UPZG!80!_{*M4IP8#LHJR zPTq7)!4Zup#~Ve zGA0^}2(+}_+s^^WV6|>x1E2v~3;c#A2sy?ma+B^89gYplwnIy^Q>8Wr-9;Ps54W4GjCCp>Pwv2&M(-Nv$1tsy7gp%YeF z_0yX*xi;(FFaGrI3Vem1J_!q35Txv1MRvVcjzXU&-Z*Z{{1lIIGbOo`;We{hXU&Yg z08>>ViPrSx#dx%V&psHvYAKAz36{1Z|+aNXJ4{@;5x+-F&^u z-n6~fiGY%H^5{rIR4~f}UKWx)7w;U)b-<0!_FiM3sFt|?F*F{Vco6H$w3YaV5m|pv zpiCvkzoiu{1UpIiB}L(boJn|6xzv-$=#bAR#G4Q`eiF zG>P47vJ}o9;PJ*RI++s1a&1}#;A{=GgaMeKL~Fs75U>% zG7ba9w9c_#uXyKVd&Ly=A?Wo!#qUSIq%Ndtxfy7WFyaDBar# zHoAZT>K~KcU-Dk`JKOgG8+-b<%#jWsZ}HvfoQRdbZ`|uXU+}h_zLrObye9X}c{Wo_ zvZIJHgBtq+vB@_B)T3&N{NxR=v5 zh*5k>yi}LnoTf?R>7Av2>7R1eC7cq!uF=0QoI?KW%{o@H6iU+s;?t3~#R1=H{s9(8}D-KX%i+As??tdbsKe7Z<;mYN8gbTWe0Zrh!6;lD={dg5 z06OZJ56v&LWvg+COsSb@pX3xsIZi55iQHm~XWg{hv%6>5n!e1? zwamE~sTVwMts=!tGeh0(nEl-7i>tFEjRLHb)5PHu&K!;Iwp7xUvB(hea_r^rVcrgB zcj+GSEiBS3u$yn7et6Abf{t_Ku>cw(orDE~-B_PvD`6X6lR<*7LikIyd2E-KD33?_8%Kd3_H&aOoW%reiB1}~+T-aTf&_g@)2biBoVaI$CKu^(Z5FKP_L@m=j| zeE*ZGgA82|YY*Xxrj#Uf5g6biSO(8=JGlj#L(>EGMBxU?BCkupBcTTjc+Y zZSi~37LaYQ?s|pbPJiFYi*f}d+s1(>4x69PoS0V_L8Ca6uWK_;Ot5^`lWkhNgy6qbY4u&H7M@5*% z;WcT1Ig-htS#?{Ve283!TCv<5!$&k8j~~9r3pg9psOQ=Rt||UUv=yr;D``^VX^K z>Ko~gx>btr%dI#T#UEZ>5pxpI^oz6IXBIIapcvhP&Ha??8h6XBGVILYQuMTt{Up|a?_bWy@_OMY03E|WtrV6XMC)NFAp;O8^=)3^{ z0RR6YrcDL_00960vM?u@4$X;5hvo#+ApigX|Nk;4Djfm<00960BG~@1AgcXiL9qQ} zK~($4f?#{Yf~fWe00030|FWZ(H zu|Vn2eRZNZi=0)QiyV`4Ke~%IVK|5W*qbn%koRU32lt8F2fasm5BiGoh5e_h|1?F8 z`D0zoXE~oA00960a&?XmFfzwKPXJd$&@?|!yu)H3d1B1awIF1Qt_4x%5HqrkqL84e z!Ja{$y2i#P_|rIC6=C!I;|&dr&CGS3{3GxiiKLJSQz47`@DG6_DI>u|00000|Nqi; zjR+yqRFG1lO$Gn}0RR7#+Cd7#AP|M&6A5;rqqA(gX}Srd2k8B8(FAP?6r4Z%$A|I; z1#$e$eu$kAgFrI~R>#lyhZyNzqI1gi46$;O;#qr!TA=7(4w@Bsm00SX#yvwVcTjqY zOiBAY>kUauaW673auF`^#2P0iPFze(OkB)N%v@9^Di#HSd=^hpdkLwux00030|GZt{ZrVr?{@px&AZ zOWa_EmrOemLlyc(oJ5D4bzrITa?w zh7|tj9R;>PvGp4T3`lH+(^KN~w!-Nvar#P}kXy}q;dGRVsE|Ioy-ruBuf>bdB(V~R z#haBCK^5wy%RAlPRd`W^xDeU`O)vgLDI~VR3Ej(%3JGPl!RmidA@!C0e;Ixmv|5gJ zQn)%VrBrxbw-@Sdw_7-?Erhm03;m#@L_;AZ8Xt7IVJJ4SODQE@F!(ZPn!2F?T#A)I z#NXJ|w}d5GC3ZMySXQmr%N9c0qM6&EDd+F&!rAh=r`9)%0hAVmes^G7n1^;yxWvhF zB{2Dxn97r%@O|-2g!L+n-bu5j+g|ZTW+9|R>x6o<_{-)@M1|D9DC{PvRw9T8ycS@f zz&0o?6^e4-`KhA{=nxVroWEe%!xf>})s|8R2XB;tV58*rHcmx=%1ZKvjX{`FC~9R> zc#Vi0JzoUh{C+CM&aTARUOmkhLAF_}^E5seak&SScyJ!4&(#XQaBo7tcUI9(w0Jg* z9^=_49*?8x-J)-@rwAPmA21IDJtq!?vtSrU3gnldrs>Qd?m zNn<@!N$9Mnj*yf#1)64hGG{A=JSuQgS1bZYHy}x2b2(BLBB$r z7`aRt^RDUhiJnz&RLx`CUZ^bCxl(0g7hr&}s5Q@zY85diMld2CCy#Mj#o=+RRi;_i z$?qfRuIeGC0r_?p&u7)c(Xm!D%*I=EtwYR%d~&88&cLZi{&6^-%s^oz)HB~Z)a3E` z(*a6Wp#guV6-oUtOKP`7qk2r~aZ28><~3Qq-kIz-Ph$)-9w+B7lM<|^A;?nr{DIwc zHf4U}e)hnE=JbyF){B${N6^S`cwh2xNMht^KBN;x=`cx)g=v)Mpu9OYnd3CT9J^W0 z9Pz`O?B_LFHM+;N(6=$g-~s1tZkbk{;iJScfA=(g#)qrC-O*TXM`$g#p^kAkDrN6- z$z3k2`!pO((Cqjm&MR8kCPc<-^UD#`o3@p24`uJdQ8k zWIp_Bv%qIwi}AXSSyuG0f9>Dsmsi~n{^zjR_AK-w3$S=yPk9dGWLDs+8~t!o$)Yh{ z*J#@TKO^cAZ4tFt+h%Tys7+MV)+Kq1DAjrmq7Knot|c&S<^&}MoI8!aCPS_2-~E7n zPn7OD*c;6AnA6M(E~f%m=Vlz+paNZisIuG42g3ur8o_aa(?k%vRpJUlN|FB!ljQSJ zlE$+g?+o`?;K7(=97d*(cYwRhGm!%pLIJJH&3u(k5aA5e@v6{ zI2rEVGaM`g@3I(&3nYKTazHNU5Vgol0~~iqO|-n-$aPK9s^behmOI5)ksUN=$H|N9 z$S-4`xBUOTu+=!u)o9KC>@s`kX)t`;S~80!Bl-`f|MvYz%%u4I?wna4E{aY{)%9ea zWB^`}-hE2)`qsR}Q2dm{bNn>D<5Dn(UKYj&EigL}Hp5O1tPN5YkddyN-aW&cuP`h- zc*u?yB-8e{(X6A>g3pTr%*k1yfwLm)4{Q(DRoB4fH>>jVMc6Y-^y~ZRG1`5B#RbSj z3L8MAVo{~J2KEcc@rlFDQhUJMsJ->4m?eS2b`>e?;~nfV*s#E+0682vo~y8v4hPS} zi%!rRKymMeUQZ|3iFW&OI+@L}=y+-TFn)SQSAxwHRmQXXA0=)v|0f=fb~eYig)KhM z4DoT3r#3R-X(aC)|gdJ?4%ORy0|N?RDXU-4^Mnk{+#e z(~L2LKb_J;zHb-DnBwUF0CV9!J;0lI ze9(2j`|M)F>o5@IQ}_T>l0xC4%f@XU9o390Cuw12MJ1q$s#NU)HvIeb*tw3Y z7}&667j=&3c~U8|GzaolSKy4?*sF=tH={V$ysw&83;3|BSB;Yg9`xLZMJh8cmR>Gf zefDtrwkDB5+Nt|&mVp`tMG{#Yw7GozHI1Sxl*i`jxD7=q0rR;`=Ss}F9_SE7x7xCy zo*rCE-kFKOk^vT~LRJ)zV@hgs@!6-ixfD|vLuqis9&QW?sIe%giYtbRl8kHIMHt6Z zmXwkKS18IBdKrd>mEt8tZOsidN#s25vD zBbf=6N+~R+-BDn9U|C(|xi{59CReh>6Q$ z7{x>zj{>Sy#R+oAX!7)4Bl~L?!L05T5;^ndJ0Ae1-}EVijG*u2)JMz5=}tN%V|d>V??3YB-PVOGq~5bE6*lH zg_^Q3SNdg!?7`K29SVKq=8qp=Ll*Ar&9_`Ihd!AxkYW){x4jhd|50zx?W*+KbGys^ zC-oof^I*3cthYZcjqrv3Pdti-p8mt|B#Ptf(Xal)KL7v#|NrdWNlU{(6ae7+{EBzz zNfNErHBuOGfk07kyGn>@987CTq85t(-M37dr9rA-Kxhw1I)%x+4$Paw@V;*RukZL@ zmcT3gZveBG*cH|X$PM5U%?tw9IN&7(+=2k}^_Z_G&=i5Om!=3@lYUQWrxajbj<_~G zrD{1pLD?Ed{EQhRHt$h}y}V5mGci=qeio$@lQG7N!LT4}Vc?n;>`36)Y+YRJgymqH zbTWtD&a7-;|E}q4ZbE^JsgyU>kKb;I;fH1~iM`lGo7wBIbihUANoA1G@|@5 z)0foaRn_-brms>M<=D)JTJBm!^C)~Q8Y^Ekskcui9csC2WmP$DE1$Jev^DjtBcRTs zEKChgsR#bW-6fQVA{;)lB2UG^1V`jbE-G$!SX6vm-QSEnSOaQM50aQX(75{F`qx)l z;ZQOU+)-~KWB;^L@7XvBV*17JEy@V~J7n2d|9AdsX7b6&;HxSf9ihz3wu25 zF8>b({i8z zw0F0=xBK>V?&}-`F1`1?B>$JvySf8u*X4IhB(u=9+-wpyp5~N%iEC78XeRui1hAMD zJ}vwaWdgcaXNSkrmUtdJF1T1+NbbagOeu40X-$rQA}2Z%H-L+jSt3Tya-$Y3LK;i8w3?$p zlLAZW(hLV!U(|p#ansvZF<8>D=M-hSWX>O7$Cf9@NO&$2AD+VO6M zs;RL+efCgw1K#j3Hg7iad6%Jr!ACav4~PG71p9-6zdz^y-0Jt4|GCFscfkMI+oIba z@!!9L|HR}B{tiHy#vFr)FW^c?fo#H7txPd;pB$j+Xg|UvZDNQUG5Q)hr3-Sv~_>BeoN1iH-G?jjZ1=hJ2h7{*@oN z!Rar>KP*KTf6VhVTS_#f)>BOn(8oFUjwkQ%D6Onk~|Fax75)4}El zHQH5BO^qR^O(+6J_8#QmLV-YqEJ1bDoIP(T*LgDjjkSWE80til4fIMniv0x=%GmrR z^YrBSg?je&3zJsPxPAjmt&j+3EIyv5zmgw&&qeGKGfgSxjGg#Q$GpSjYIi%Pa=}Qz zd*Q#quY4wH;=30wH9lQoX9wjsUBK91m~ff2&T-apm*oBxnW<_J%kg~~y;-ffa~2w= z9pqBTnn;ylV--6Tvs&Q zA(50h&oAI938zqug`9tn6n!c2M*D8&yl@6L#}BnoU=|dO3LO7QmQ%yI4ZqNn2{ZnR z;aDDZ^dl1jlPsp;U03bOw?cK{iM;rVf-zAQpB9O{KIi#Mu}UgvH$uIsO-s7j-yAKG z4Jh4$V|Il2KnpT7g)12{guAkB3#naAJ8nhy>0kU*(+MjU$$(G#ynOi*n+3P!v`_U; z5idhOm-qXSY>sE#yMt=hSrE z@j9JjupAcpQCrSMRYyjwng)hG85)zHI78l`Z7#b@I5;AWv6?$6&Y2K;QlE*c>Cd}& z1M`z{>N2IoaFHBzZt1-^n%%yg{7X1txQxC?EdQ6-qS;DbewW5!rC;uI~)#046O-X3KEZ2 zf*E@=LK4DqU1Y=DvJU3Pu5+4+x8+kN#THgpxtu(J213${_(x#Z5tJ&QfwSD)saw== zjm8DLWYRJI=**3zv)mb7hMDPKFw&N^-y}U4Q+Ee;L5}qj#nO36(SuiE3lCB2g*F~D z50x<>hAMYG=Xi?`C1oWKrFH!TS}<@6J=oDftU#$-YAt*cCrs+Pwr{ol0TN`;*R>sG zWE*F8_oQ<^^MiNQku`A5LAk)L?Fl#j1MIkBZ-9@Hj0>A? zGXfqso7TwW15;lYVHIEf=P2}U9)xQ1kp3Nps=pUSTU{y;_oHa1D@f!1KEiY44`Y1Q zFbLtF@c~G|yeWgGi_1ApZiCQ$Sq$tbWK65ipWLPL>WMNClMz8?CRP6?>CxK{%VE{YOpS7tR84Ify2v-kla13D&r?y@}@|X zRliik_PiG8o%>$td2PRZT9R%{P^jgkt@i*J#%Tp*gliDSgMSKP)cmK4O`acB5ThZD zk~Q)L!!=uC=N8qEO9HS9nB*6kbUemp80O>6>jCE$hAD(}cDA@1YRArL$5xBOep|U- zHNX8s_xAO;r$QDF2CIl-J96>DtnJEX{OU()vzv#6cLn{kh)I0xyBMOh0{Pc&&-# zJct|Gy9roIK{x8*3@_)L)osQ2N$nqj>j+a}QS&K9iO!WDDwwb$-?ewKray8 za4;Agh|M(NKYnzXyn;~=8tQLv#2F#nlO{BbMd$OO?MUDF1pnkY{b~f;cTRAdutu(= zzV7#Md4v2QgEjMM=TeTNaW0yNPIq1iaC>NJiRuzjRB=A}yy)H~FKN8q4R^XE%5l^sT z8mcCVd25Z%8wXdaQ!Ve5^uBhvC##Qw3f*00 z#i~RdE-DyptFq7#)RlV`B#^DO!w z6YQ5I)^t%UDX|{W_Q*=r3Vqpaxi&UImihM7_1GXmLBy9b7(dJUo;y$6fBTi)7we7K zQ=fs%8-?rA-@MAX`ju@Sr{iZ5d`F)x@_Ggxl3_hs?gSjFkGt^P!jS{WsmEmAUsX}e znOHb5s_aL2iY|AP|TN$CrY=z&0N{ew)IFbHSPq3 zz=CBP7!*!ga*rt!M+}>(4Nm9?InWnnQI_^J5~wX{XCmd5INo#i(W_kX)QQb}&6jlM zdNV$L;I{ifLsKWnNx|sq*`XU~q5h~zf)Vk z1xqoSNZuSD9nA+QYwH^<=(TZNXG7>q$_+7mlj(Bb%fZBat0#>{~pEr-P z+gC|YGof91sZAKxLBI`Ixg%RIi7Zv0BQMFy{D`7JPI#qaz-hIu~Qrq(@bnX=6GT`+~lnB5RJQV$p+J&Obct-=9K=l@STu;cGB z7RzOMkd!><0diahe?0b1#!@dk;4%ha~>!hSc}gA`Gpv+N(v_ zXcM#5+z<)XPu&QB?6^;oN@vfo~7^UB>+OvuQPkS}pff zf4!)38iX6d!ooH=UJ0eG>1^S%l^fJ3Ai`jSEPgB&+gpO{PR`>iO^o`x1Q34#00960 zq+DALf-n%gO8wL$7>$Vs@D4=?Ax0oYV!XXO`)G;~1pOqmq}^`m&g^V$q~9eF=skri zR!Sg-PQdW!>0b*r)VvB{l<`;oAi^b0b68;>MWDXDqHY1|a~;ahbEf(qpcav6|5t&=i#lZgZh2Xo|Y3Q8b-vt=|SK(CZ$@9W^In^ zLcamqI4Lkt1;ZgV&I#lf8C_oOlULgqL+v65{00C3|NrbgYgZdbvY+8sG(t8K2myX1 z4l*1I5VkfTSP*MFhSd>h0PPA%D~W46T<&kb_3GD5j|A9p)=7NgSTj>yU0vN(U0q#W z&4Cx5!PM8W(&R5lYh2OTzSb6H$KTsQv)`vAHmHZ`R3I*8$g?5QZDYbOf1MD1=?7l+ z(W;4uLh>Z33)^EeWYkazQY#qH-9!HZ2oT916&AsFOMMHIL&wn{Z5}Q@i#J%J44EX> zPcFn&^E2BEtcQG77j*t54nA-7Mqw3qB~e$WI73=?NW3~`)ZtS<>3aB)mqI2MndL`g zg~PFa4eArJJz2=-ndF47h?fH81*}}-!leKJI{Dqth#mN#eZ3~)ORdRyp;&+xtk~6C zFjB~TK$g-ZO0x}i@q`i{ub>rZjHcmE)y`}KTQ;JOQU3AG5YYqwRD(}QsRPOw` z11Lwmex4J>zy}I}&b3=n?*b(5vVEo;Aoxzf&{Xhay9Fk700o9etK4O?bIu@PWJPCn zM?BM;&%U|>w!C3sr$Yc|Z4Odil-0_h*OTB@lhTG2QJ?s%qqJ5$f8vY)atd@oa8R7Q{bj>rgm(An;B_t_TI zisKRiGPE~Ph?qeXQm=%LXb%OJFX>lfW6mh*jNDwtoj%252&QKyipNj)Np%D28!NbfeUX5sr@qgIO`m;ETYeJI^8PksR_y$`FngZyRVE*^AbBIX1}A1bsi#PHo7A&O}Mo8q={MUF8lj5RcZ-> zmk*L4)D2j8oCG26QfN^e-YWRjTkXb#$KNF|^0Vm3&zCK6L#4l^SoC|tVfz#)L%+3_ z{+O)rau}V@O?_SuQSj?=vr(Fuun+mJvr$+~Xr}v3CB+*dsf%L!W?ub9D`WcsxZ+H0 z@RT_1-WGy#r9rku|oChc&{Fp zM4p)U^Ylu11Al!+OX^xsDzp!8&;CkK>8-2J3g`jr5gI*duvIhh!`U+ldpbmTP54V)$4D%F?xD z+QXtnmHE_NT+B?n;XD$Iw@NbNcF?Lir7uF~i{r;hy%$kkp2w%7nPO%?O`VSWQWKhyNLCMZCE7OPB(sEF^zB?C()-ZZP$WgE= z{5SgCN6Ex#o9Q}lj`WpSE^S*od;67I5^<{o%j?vCqZ&~C*@?0PGyQO`S@+ z>EA#frF2jA3`M)nfdkaSwDQo?(*zbIe`+uH459j}0S$^{4lV`E}U!FaE z_Vlm(-{0i^w;8o`Jsd2Zw!2F(VRh8v$LZ-=G+`5oz9%L3PTu8~z_RkwPXG=7{|Tn1 zD^&+&8GTNvZUt5bE%l~3vT2v~y=wgd#yoT{@~&x61YMl9b%kHun}_IHk1T zqpJ>*1%~Qw1zR&us|`G)chzTF=!6oUq=zOE4Nv%dIHtc@Y#F ztgjLLf0~1#`p?H)7MFV}i)l7gcC%csyxu!_55M+yH>x#QNH#Wiz}~7Hsw`h>Y#_EO z00RaBF_*ezIxdF?cBfzv(eO;~VhuRScR&`T9?pD$Mt!%06-p*D-YTn!3t<>r& zd$hk_IZ#=!^zfg0wY~#iHx4T0pBqf6{5Ev(v!?&BB4G4Wu+VQoMZcvI0k3UQ8_@Fr z?8Nhuq%6G@QnpoS87m%|0qM zQsuaoyyy)iB~lN4p2N>qr#;l~lu>;8(N(kGr&Y%qx!rOcLIDKRW(Q0aMSe54b3Lcl z)>Y;;ERd??!l7m}iz@Yc&4;r>Ti-@zYODG*kJg71uTVf zeb0eRR$Q$G0sC=4gm`^W-hUH--VCs^RzKL=u@L8R2ry-K%XJHoY{L=gj@O`_EKGtO z`v=v300b_YEmUF%*u^>k>9Jewo+n1{RlMZx-d1(H3LKA*$drzWf$fL*Qmbs%(Z#u0 zKPsd6Tj=EQDIdNGgC@8|E}bA~V)WwJt%PCQaaa(CdKCt65IWhX)mj>C3d2IMhskaz z*J0Sb-`#LV)M1jhFknD3-zOmdo!YH&$P_9CjG=IbenhiOBdizaHhzwy;b~{LT-!pq zd2h$+K^Srq)(qA1>q_IGQa?Jdtl8NP!;=(mS7?9>=G_#`VI6n)It-o^!e8EoA%CeH z>^0t2x3H&B`^P_$rt=95fCCrhUP`l5 zHO6L2C#36*zaNE5{QYRJ?n74Ig&`~Nz%A1%(=sH50x?Q0&cn39 z2#cw}%yyX4A2G#IPGMPjXa7xkqf&P$*iR98-gvNJdnsUhhjkb3u$(IA`#Y6)BnOpu zRtU<~6iPuYygu4HIe@SulX;e@!ny;M#-+ z^oEohr}Bw*MSI;Lm)U5y+PiJsU6WGSiVQIg21qU|9uTCE;Ip_sCBuOqWdxlO8T<+d z(>aqNFKqRZsh&TbLiJa=dU%E79S0^J0O3AgIVnx!mR_qpP&xY49zelX9$kvmU7O7= z?)=fdpT|)wl5IgZ&QO!cZwLtRjCa&*5kkb4HzUb!ERc}NwwAKz84B5eaxhw!+WwNJchz&dl-Q`LgK|!Iw=KFa74vW#ydBR${&Fi1&lzx z6|j})7~S(*ZQk?+sFo`*Bumiaro7iP!P2H@5@i!z6D;q0S>iZieG|msdPoxG(>f=N zDbzU$oQd8E;_`Y&|%&MuW=Z;pra*(HG+F2U0*OfU8YeqWM8^f_xjy7Ve zgIS-*vwZUB5@L@pH7QK-fnuy6mpCPtx{9vQy>|MUGKBYawy?|Vi%3ORedx(1^sPGO zYnIayYV~9cJ;6UXvmF@@{gA+oQ;XjZQ`h;$)`#8W| zAe*mGFyu6sM=ht?yX4-Mwi79iztzv!;P2vgP(Ush4_dD zqEmEzUA@S=$H3y1y7k~mJ`Nk5{0(5ns@Z<%B*O&AGLUccE#s|zy{WK7V3 zxGCpQ9oA46s!VRhA?@O_?sFo*l-ldc&4i=R{YV$TYK}NSEM8}B4u&25-R$E3m-S=# zFCLimU-3b}DLT)(uwZ+nqha=hU)ua`ZvuJ$lhc&i9?bwfwigyj06b0{s#MJv8wJKz1Qrhz*vO-$V@;eZ7!28$ff8OK)ri+2YqKLOw)SQ5LD71>{oUOfG)Ae%%`&K*Cs>K16?D}jeCS#pT)jQ z(ejQ{^w#AtwawRrZfktiWO~p2pzlDzzD_5>^s~PKd{T0Bc0ene3X_`oixlaE{&3Bg ziCv-_K;3cIlGGzy@HaEj6+vL%BsY2WX5vDS)v?Bbi3n}GuzxWILJ%K zVbf^Rrzq<9LUa7G#Oh|5b|)+1dn{Cvni&8}@YmJPJk|!yk7lSDMWn+EPD%meSeNkZ zVn@e6Baff+;`v>azMs=5l2O@DzTfO`_3+jwr)>p zGu8A}rkIz&MvAyr7@yx)3^o=hbCKjU&xg zkaw=<>=c&6-t)Vd0wX9-CKaLqOFjhK8z53U*R;wx+T3a!p<~+_0oc3d38iA{akJHG zxPED4d1fghUdSuND51EE#9IonaArg$e&u9CN8=mHh$c34WEx6t|1k}n8rM>qbnn(e z?g7_g2)C~@zI}{*V*5I#eLJ{s@zC~-?MZG?YESx>(Ii2{Gf&M<|FU@+;Z1U$Txx2Q z0+^U5lddGsp%>HCq>}}}#gmjsEo8DsXaJaegEW&^*KtWxP{D z)vpKthGD=5Oz`dokBPZNgEX~;z45V1TomB7LWC&lTh89OPsLPRsB_hOw*75al&ji;xAGa7m~ zr*PEKMxoI2xWc`;k-cN$C!nExs*~)NQXU$QZxv)i+dH%mYgn zaKT#`L)RAkrSi&2p17f={e1^ncRVIF)sTqzoV)V5osMm8_(fzVB$sp`@gabQ>*Oc= z)G1OLeKies^7t60sRNcdu9`yAGdw&p<~kvAy>fs6T6$)+K0UlXRk5+;J9c<JpYbaS=V znzQR@PaCe$VSTIMy=ZV_R!oaWAXNvZA@|)dzD+hB>GfTavW1pUI;KJ@*PsmQ*>v1a z0SZA$D-dg;SOjM0UY( z4zQ$38kF~5UyH1i_)gvq+T{Dz2#ducyGQ8OIGUXHXlhzFAep>}0*|O=@Y-p*?g(ci zytL_h)Wf)FK1zNeN1X6{)z%(ec3;`5);TOBh6$dk-Qfr~tyBc7>y&d-e39GY;JQoq z;Yid>9NBF99G7xx^G*4njzOY_jW?l6XW2H3!G%!@s2gBiFE?~F(s4$IN*!ks7|zpB zfLPWWSUK2?xC25ZWf$a52zJZw8bo-bTHC6;Q)GC$^^=K-6B=Gywn96Xfep=h_2l^v zcxUQL={{6rTz`FqX@BR^&b8ec*FHuoGpMNjtH1nTc96JFq>PI++psd znn8u#z&)G~Cm*1>D4;iHP_QqVPqooi+437b$J878#ljl#%4qsQ@8bvgw4?;BSQYR| z<1DC^f;xVD9*xc}8%T&ZOSyC(cW+B+0|=xI^K}3xMwf%$^~EJTBI`*IQh6WX#|6Az z`GGmYoTNe@0!+Ujo22p-W;x^(B=$rA*RczyJavHWNiY|uN~6{YeS(j7WMgF#A0NWO zCm(+N;l)^vagf2Chu2t+39jFaZ)__}>*HD<1+F>Lr?%xFA%i_cF7*sXIDbFcd}d`6 z3Hh&(P2$L3viSwF8ROs|OEz86WRQ^!c;|zjj##F0O3R-tKd>A~;8UMXWO%km(N*4g zK5q}$JY6xojGAY#OhrJI8}MQOM)cpJjkbM7X2_6Bx1b^RyEEIY`bH$q{xA~>x<4@U@r3;^M z4JqpHz}ZibBZ0kh?e)}w+44cB;6LhPUcaH_ZW=`A(Ex9CZ((knHgBR}n0FsHS>VM; zbSFor*gX^Y!X6>*yufsN(_F!%D5**xTMd ztkg55KrD`I`^4t=0EkQO;`)uez0I34o?F?WX?*#T>GH~z5U(q%dgJ+8RLEG7Up;J zhUb<)t&m5YHGclj;22M8Q%t(`{Q1-8rO8_wfx-cVF*X`E+AA<;^(=T_KOiqLX(#i) z!bi`f+|Lu3?ur79a!UDp8{EP_kzem2O!?!v>YPuw^hF)Yj+f(Zisxmr-{s<3_}J|B zx-$Dt0;P@faj>`kw0fuh^e1953LMW)(vvtC=Sg%-(1x|dGnurn(ww~2Gm{ksEU@U6 z7t0W{Bi;Rc06ht=jM#OF#b>P7GVW30HyoadeZ}}o&g=gN00960>|M!D!!Qs%^A|y) zq7ebXtrBPW1};6Yq*Bz1(v%1g;@|Nsj%VyiltLvU)LRwVV|(n{v%F{1y!h{dcXMo_ z9cKLU0D(e|Q-qpf(oWQS7Pu)m>IE^-&sfPZ z7cKS1r;3ygii^rC70mExa4-UDaAzk2YaI|fsb_%{yCIOBsNkPrcJ9WA*>RH`ZUkt# z7nE({n~@&i@v8OGt^Nk1OM&kP_k&0a)&Ga~>Hqx5NpRn1aX-i4D^Qn4gX-y?$peO9 zR}4X?F8?9Y$2>^YHoK3!qqt|mJYM?}fmD}gqk_11oDU3t#X$*4eG}`aCOzxy;T0LRO42|9V6_%dnX^!13Y|jPBPK(S2Jm)HD*kae&-Rt+TT!lFit?({f?mR?D zEe{Av=fWKW8j2qR5OAbsC?y&6ksH_6L;_ehM^P@aGeIv!3oI_PHm*?WCU8A zIIKv}MPNoTD8XqQ@F?(T!|URFruYJ31R}JqP%C)R36rkqwXC-_GXZhXF~QUrIk8ea z4e!eT_yzy~|Nqn-+fG|Y(68_nTL&r|pEN!u5Gka&RH9WS+DJ{MJ^(_dSo9EsBW%-F zj{EK1x$W%j*yd7{`T;O!J>H#}ot>R)FTjQ7@+oIVlV9n)F#b=mTzo!aa<7A--}SWqq1&zWpNg`tq}VKw z7-P#2vXy-Y)4~9NKK6|>7?0+j4GXSLs{L5Gca4B^5jb`y(zLO=D|Ro!-Ye9@bv%%U zJ3v#^`U~efzJ|UyhX=#s;_zS!KPJc6N6%|ci+!m5hO#(a?G>6 zD-!UGJ^FR7Vd)apZNR(Q%I^qMqMKE9pFqfJsVRv=kOqh+NU6b@FIJ(+)8ENKaup&^ zve-HNa%MLAR_}am^&BhRC>T=!N%|JP1t&A7Jwc@>$&ET23l!3_Gs~ zx1#o3#rrzR%H%a?u}#fQRV7jkIsv-SkYdrZ>BarQ+wlNuc{nkOyBm_&uej&q`N&-% z$c}M2x{1@~__G*VQb`}HK9;P#1yEei)-Q@P_}~tMC&398+$CsmcL|W-?j8sb+yaCk zfeOS+DNi)7!<`9)lW?sTtp#YDgmo zaJ=q#dCWLDOepB7oq7dkc-7Tek;FNIAGC%bbZcHKI#34pgEr!d8wQU>MrV+CdB6d!%AG2E618Fx)W(-dEu(T!M zee&ZKe|7xv?_|)rsJw6e9Nk$TZ#XQTIw?(mtcaVx`*D|U*2d||k4tX+MW-3o@lQ39 zD+}RTozAijM>4upb5jPX11V1mhLOk{9y}*YJ=yB!KlY;H;~?tXzHzsqKN7t04tCaQ z9%#!;*_PV$fubK%*29y9-m#v;6%nMU_G6g~Y<|ot6)USMGGubKIQ!oHtel2eSkv2& zuQVL8DTbB6jR1c|6z`lXw3@%8kC5n7-T(87Dl$UHI+K+98*R6|J%6UfGf3u2av;Ln zE88D@1QMU;-#2yXCieJm!4G?tsr72pn4pGDu90->Xmt#?atQnm#!a7IGC>w(jKukI zA?7BjDl*700ne&WfD!F&eHi@kWu`(-ApKh)7saN|fU@ralN2c><5!@`Pud>E(i8A!^hH5 zOZ$qJ+t;K}2Ry8r1oS7|tk^Ob#3;BlT-9>nrF*a&RyV(0@F?XWxBD$2dLS9wrms4T zZ+D6=r6@wMD7D{$wQ3>ExtTJ?hD#qS-t;Ys=9;>0u!#rq7F%ii@bODD+(W_4`HlAl z6Tw0?`*Tt6`LBXl=m`6J653>@2cqW%m*|MK9qG7>ANw4G2lg{g4i(bcpzxCCj+Yi+ z`@nrh>(rRkIIEDs?Ud5YqGv+V-Z6!%?D7Oy6`O-}E9qd#rou>`kc@4K^u6AT{a@9y zs5m5({ygX%B0IYw-y1L~p^hHmg3wu`zC%hnKDVYdm#>BsH=Mh=YC#;HSp~TxLtBYQ zN5;s1bGyVG?xZ=k!(4+0O#-Xq`idleg+1q|g`;rN?QCXtL(K7FI7iA;Iz7UW6ilcfHe`mM zh3Pa`hVP|Gzh{-Ew*@ic=)wr@`xERp3Rwp$N~*G7jWaha4gVM=Cm!}1lA{s~N3_#* zAS9yCo$MouMMdPDu$b^VEQ0FKa9VMa6;#?=d<+-kY9)R7-QVtQ$1U8tv3K0z zw6)jUeRbZ^PD8S8MN7r4mogCV|HfybJu%IndH;a#rO0U5+o8N4wq0^QK&Ne~PL1jvg$J z`tJo$n83Y#tUOg^cf30i30Q($JMcX;>)QiQa8_!&8y{T!8Z^q&zxrjIgf(#^+Wdh0 zwEm*BbI9XAX(uy^*+do4Fe$$%So^+NMQWhnP|7AdhwnZ4L$(vTp= z{L-uZsjTYT6%!vT5}$)pjL~<*M*(MoEG2%7w<8+feO*@tN4leW(yP9Qb=(e=Mq=1S z6lJ{e9<_>Zm5AOJP6dY%g&Gol`FWBQCQRgSvMNjDFL6K2k$!_ua6$X2^XnVwOeKh5x7KdWe@#RVL6G;Hfe12tp8vYZWfqM;_W28y2do2mju37>ql}v0Xz}T)0#EP^P(2_PVik%BLgk^UXPJ7x-e!>XbI#V;=@J~?SLhDXlM_NgH$a;JNX4+yvTj-LB1Pp>l@7vb?&ue+LKW=LUA0+=P#GGo1nhWYs;X_}Y<@w3;0ch$aL z88R4!KF;3bj?X5|7aT$864M0o)J1=Y#Mh8NwSH;53Zrd*NB9y$7oIgRqkY+y@|~)( z&Bq8bboIOurWInnv~O4*&%~$N?`g9AR2723jWx~pEqE{K%R@y3KfXSBNyiyjuY$!m z@xy+OxT76T-%-rL^fj)eEUvgV?<-BA%B^_D=JO0EF6#@Ey_5+m2%EkN1Zze&{Njc~ zGPl(wTJ)2LBN0_1W99zn>$Coi$X<82OCnr&ou73cs#2cDn{+~semf>xFG-VVmF4R= z_BbDhpUcPt_wNn%(f2*5$uZVwcv1u_a0hG{)VMfZa=8rsp_h*Qj>P zf6Ak7eaxB8wEDLt3JFUif3mw3+tkG}>(E7>Zq3h(#dh~KyHM-;_+Omg=dZ{f*W;y5DL?wkD_GbQ}Y#PrSVKC@;#= zOzrODhpYIu#5uS8relp&2OHLc$iY4YYtcjbzqLCu5<`)+FZ~l7Eze(Me^7qug0wd@ zj$_?N{{8YA)AVcU3aiANL+$K)S2EU%ms#6eN7>A0U+Ue<`q*FDmkpFU_ZYOrd&t&A zn!TOXKMSg^ge>3+e|269-5~qk>hX5@I()zeZu|3uG`9So{d>ZyAmRLMc+Cjnvy5YM zaIn^>#(+bs|KsKI)m`hty?@VL>!Mx2j+=Mg!-vg)#wiiY{l_Jn3{rZP@n+g?&(+K{Ws^xRrUh&TUh1D+;Wb&H7G9f z$cXiv9CYA(AIMrFwy?7As(%?k-IO)y@$`HNLd+fssR^D5n&iv0H?zQpko$hd;l8Ov zitdmm$)#P8!6lbqbR^=<8zbmsh>$Xf6P5&7SiD1EiY_9I-Jrp&eG@E$m6u>D)~-jH zWY&(P#X{2YG3>V^)j>FJmV&Hg%%^bEEmn1%B`&gIeZV2?q5mue>_7;n)TjnH?%sIl zlNeG?*Np;{r6E52qkFil!OeKT1=(BslOMuke|#ECXj8<)xc*^E<=?4?N9P*?p<@Ab0j^tvm%=3heK1=6$F<=R?BO4S6}9Zec$#)OYTL zU^c0W(*A50P&y8XLg|q7XXxpsT0c+>=l$65JgtV+rhUDZmc^hsqUlj--5dKSnTd;t z^M-jqY;oQqT2B?6;(Mh;6X)cn17!|-b}`r5Ep}(pIE;7v;GrX=^orn&u0)W zV;?k`4^R9Fp3YdvMTv&29&bM1#&niwHs!~HYjkM74v{859In7$`iX^TM(uh!)-kzJ z>m-jf?zO}>0*Qsv*naqHRGRHV$nS#ui@cRee<;4YrG&64!wH@dseP-9{t+Q@Q@zB6 zy{8@Qgi$gOq>Cy|-}bAI88!NktkG^#W+7D*!fbN8GY4skPHE&HKdNjPgc{4XB}g9VMl&XiTFB(UOGB?zeumw5iOBQsuwZ@Q;-`me^wP>3 zg`chG`gG>j&0hv*r#L*HZh&syWjfX7D?Y;aoDn=lK}X3reD5;eBTPf3kosx3%bYS#we7H!0x@s1{jR;h}FAw>-(+xUKRYeHZ~DOmjl{LX4em#0aO1#|KqXUT;eJ;^jziNP$%`iu^j1CB zyZ+MHp(CjJJEVKbo%YeMc*&pYlTrS&*5Z9fka}B06KMe)#R?oMe;Yiu;|=1|5MOMz z#}_9+8T(Rrf>?KQ=kT6pAYTzIPn^?tRVI&q@XU!GJkaxc#79Tnh>4utss&)ht(^`#^t~MLb6Whn-j5}ugXNQmxLc5YTI`P z-&T`h#isbX`+NO;=i({szuv}T{!*qE z7jX+IwpC)F%HNlEh$4R1O=vfhqUXA8OoFi+N_Gx(Uh1ti@l7_YQF2R@4ghgGi*G6t zP5lqactd}}ON@l)p~MD~I#P?`Rf4$i^&-$Dl7;tWeJbsG@n|zay0PEUw?4Ri7j|hzoot`yTpf43#8MIg zPv<$4GWvtMA()c-ABT;U{Zk$kNH!)MX^%gX`sG5H(;{}gWE2nLZz7_E@u({*WY_3K zuH<~X`o8EZU`gEJ2FCd#!{sk~@hL|ixWU8idOXzO)A>}v1zzYQLGp`J978X_fpK5f zT+A$vRp2D<@B-sfZX)8F$MHD01Pe3;I4V601p!DeVq)Pg=iAnI5O+gH!+Po_p|`dl z>WUv2ceDoq+4TE>$JLj1A^8Ca;PF(r(2G*uh&X@1gS9ZdiG>v#9Hew!rLAwMKo6gT ztBMv5@?O34IsUj3oJ0eLnB3^2QdnGyUSxdw36d@VBz#u_}jmqp1W>GGvreZCDI zv@!*1a$S7}mtxUFnmGRe#i{hjcrW6>I4Z!WdTBaI`Xk`5Q12xtS1U3kpBf&ttDT`3 z=sHeCz*$+nm^3s;B=!gK456<<%3gkr*@Q}s5N;@hN|nuoDq&KuUr4Sr83=-$hP8%Q zLeKVnX!YbDwB190&!a~V9aaaA^K+f9)I>J;aosiYz-pu4n{fFqfPw1QIV5Sj3xLB~ z^5gCvgfzVu%5uvrT_y*|J)nunDF6-r2&ADzt~3h>2Nh!Y4akR{JF%ICTgxmnCs$D}9$oRB z5nv%pj6p`L5lA+48Ib?-l!asx-DV&Q4nX6JrU7mX0^IoFSgN>~-lcJ5JP$0T-Yozh zmRAdTK)M)E1G+&E$gHBM5g;;!$XQw74Uw7F0P_5&^F7b zwyENX+8l7cW32o^oG#4w{*G;>cd5z@C+B;3gI&kak^(PwIVJ$7*iwo(j!smKEyt`g zhC*Wqv}JqoA|!eY2}03;$FcET+9G@?gzKfU95Z(!XjcJF!h4|6TH=lnE>3GYhgeKc z_k$6 z4jfo7ZA9$(XqwpWEwP6pI(H`;0r(9DpSzpTJ01;Crs1}#owUgX zFC+_b&>iLN1d%#XyLnl4`E||7JzG$x;D8tq#BWfg48gmI zx$F^ty*T!JgP&1@nPczZE6(0hgU!V+gv}z+ZvG-yoYeKAO6h~QAGnt*mZpvob6Fzx z5zV}`uA60NJD{&bAVgcEMu#n#6c@d7D2<}Ko!}P88EV(#@Ou79Gvb};V~4A$p@h<5N?&MH)Btt=0?i3UM z?K*Hvw168d?iQsZ-XBAy!0~CZ+ft_D{AZ&58AV74m)ECG@pPeW5srze_MoqdUjl## z(BQ;CfmQ;2f3^3W5m6(IB;q^^+VULjLjpVMaf4|UV+j$^x2-_WGMBF(Rgx$@5(!bg zS#VYP`J}~G7l`1)&Y#XQAyCVR4OChsYB)B~GGvF0vU4y1n^@wf%_uR%@*5YhrUBBP zsqm`{0+OmFh={Dr^!@XfJ?ESEIBB<_-}YplcqGV@5DoKye$++LL9qWka{>pcBL4nk zT&#kY1tR=A3u!BW%SMQmux-diMnBr<$}RWB8p|3cIs+5cM9BfQay?u=J{;pWGB-d* zYeZ3U;X`xhBe0}vamgE#R0Ct~jKYpjBQ*V5D<&=dAbUt_HtWr&`qYP`!qSaB%VH%O zsTy(HjV}Vx&xE+Y|A352<|XM71wNA)x)!CY8hruj=w=iZJ7zn(9TN-G*}SJIHi;wu z(Ser1tr4a@rj4PwO6WLByA0Mv+&1|hJAqkJf5(sYvtNRT!qhk1whqPHDCc8I(969s z)pGb(VRVAF)4y(cM1N&hs=T(%&K> zA&wk=cncSQ|Dx^WK@lffl}6=K4Y6rVv^-m28XJ5Dd}$$7ivzIN>iPqhZ8h0}o#hGv ze5V=c?D97k!!~=L*bq|SL_7xymWwR1bPB8sOSDKX!hZLJNr7Pmc3CJe2ui$s(dgQ8gsWSd6W)3JY(GaR=5p6 z=}TcE`&abi^i})7pTG@z`=M4-E-&^HG(Jmjcx_4LS6N?fp}g4mQj5kXHg|Abi&nda zBZVGL`kmCk!ND7g!&tGmB+!Vg|!JT%DWbajln^U1R z?(=7dBBF%97>;X>&T9qlNt zU@FuJiv9!C)TcRE`m>tCP33=2&Hl`PYX{{T*@cnBSks-vSR~uDKTOnUlb&59ULvIc z$GH57tw-YMW+1(IVO2=sek@p`MQx7s2$SIy2ol zkHeA7{@_b;C$!Nyww%3%*PG$^h|4|IzqGPZYzAo?ft6xQ2vmpLqT7yMAj(RG~ zndx4Fw8*DdS{t1jq(ik)*j_*|zi1>IbbfV2$NRpM48N!-dEXZ&lTw34I^JIiRQ>r} zBf&qqSOmb&y1yj&t-CEUKATq2M46)5vCRJrcy z@9pfCPCU+eS7rZ)A}-!r4wku%PN9m8;RJyKHdEw%lDm!JVj#Gpr9A)^_X~uJe4vcN z^uyLCBE6%yV&S^z*Uxmr^mCT3>EKrp`IIy2mB%sC3Z(UM7CgZJ82c|S19d?{J7WEB0y{TK;kWq%uc-8_$@_oLEk!7FM5(Lw&l zs1E+^ySbiQV)S(=`O}zBE>9uKzoF1*(bG#L=x5-Ywh z79zLdoNZ6A8r*F2SAe%Id;h?g}~3jK)VpeNSBOl+f2I9@lp$!^ifs2jAZS z@`(vr*KQ=d+KV;PsdfGtQR?XQ{BxpI3#vFRpD1Hdh?Y3U4w&4j+c;6mA60ys1IC+H zVxHD`lu4sbJb^}5JzKrSw|mp!qLMp9FXVyaNhh`e+$c<6GcCOGIe)rk6}70w;YQr{ zkla5`Z(qcPRn2bEx=h-(RJOtbT^R42eM&`f z-c@SLf>(qFpkvasIHI6YW+`&K6He#6j z@M8b8@q5rh4V7`*3-^>`;y>cuMafMF%a(Qwt12QYMjHI$PMxJG@9Gcu>)VEP&19D6^TbeDG+`$LQ zxA0px+-pprxW?%LjG-J9g(wEsOhf}9X(Fp>1VjjS`+d((k$$AGmc-@&7s zJFmT}pli2H%F!qL)cmU-hyRMJPlhZ2d3aq;;wynxl*XWi$l07t1tz&(yALPKt$}o&QMOi2q z1cQeo^#Q1ntQ@L~Xeiu6?zsP4QjEK4G7{{iTv`k$Eaeryzp_;c?Q6e&cFO5q|aBqRV5NqjkMkDTN<5k-7l;`qr)Lnbz^| zvReTcwM{PLZQ(yW#@3l8nEk&sUen%5W$S?zDa4Uhol-_zRaNMcql-10NPK)%nK-$5keY140AOfrXCM4)caK zMURFq4V{$^{B_9cKSU*Tj`@rZFejT-_VCXULzaSb7jSOA+(Hm*#DIyv;SpD6vDlR7 zlGjMAs7=~j#5+YuG|qa`piXWwo{M-X3*iqBF+E0s%# z2NC}eX}?UAMy72+>lc_IEe<-k`?p4lI9L@&(atWVmp6{eWYvkgC}xr zSR+a*=R1=hL*bppR9!^&W`AS6+dxwlC-)AT#Schn*W|> zz%dX66EPKCV+Pmt5m)gJAG)9)tn)GHqFU>sDAI>yPe*K8uHv~M^(7~lo ztHGo!@iO4Lg;cplM9?b#u0#DJ?(50{XpHr*K9!0J)K|D4%gI~d3)!2F_U$`nm-k!j z+jcR^?;GH^na_m_iv^a8r@cfw#}2)H)XVssG*ix1LTg0$etT8k8a);?Q>>k;+}t(n zF&>FhH@&T27+imJ7H~-&#u*h7I^Rn781?nsIvFao_Sf6`wqbcfVOJ4J13r|W1cP4G z{Bbsm)2_jg0#}s83|L1Wpaz0y-i^snN`Mn1g-Fj|6?)?byn2&%gO21y7_1$JN7Wbk z+NhfVboK+yNOQpC{I$hKdGE{bwz9YpArW8@x*&CAU8J}aG3fO&_}4F|4T%nNSvLA6 zr;S1}#|?*|l|JNGZlBiaz!V=KZ6i)BL0|bzX4uC6ly2aUhX=+|=A+u@oKyVbGGRvi zpNX=mM^Tkrug;?@WYt5H@=)7s7^uRhnLNsr%CDI>8VzdB z_~*d;HLb*l=N~^=B)H|rm4ul5;o+82i2P?Xyr%2G-k4NAf#AnsZ?tm(igB zB~V|#;G{RGgq@%V*64=%pVm1r8`W6#-JLVDcwHXpqVsP_5ila4tgrdKRm*2Tk(RA? zk*yq>p!cZ-|yuR z`KfmHh5Ah`+!`bJnOF88s+H0sEr6)!P_4+1bp?rDKY&3=P1c8j{x0w8e=LOPAeyZm z?S}<%I;kMQ|5=O@TT#D+l8~%kF@nDv22+!)^0wm)J!Y)*hBeUM1XWnzL+jpXJJcl3 zI&W4{^8_3?)V#>qYBM>PJXsHqb^-Y>Kzes?P1#K}MD4JVM3V7AeYSr~UV*{V_qtWG z&k-V`#NbBnbzQi*SG50@%whSo`%hDVCXe(FGXQQ$P=cs!&E)9kMMfb_`!Fi-o7N*#6ZdZo)o(-i?QQrQh`ik)DxJY{FW|Z)P?WLPUu|T zLy*|}g?2hD1GMyC`eBKmO{zhV`p<=PF;F#1crB47;)IqjZa)WaXz$uSPe?6Gfp}2` zpKbGk{oOXIB&0#h6!baEzcF=glc~`IKE>9zr?MDc-dpQtxPyle{)mCehC7#{S3b0(!;6o7vkQM?OEMZCC|hHk`=owM?4MkRu<_;IZG@mm`y zx7K3~BSE+7%4-1eIE}wyGf&K6*)KveBoniYYRN9A$sf-b98%P3e(odh$D- zp>rkgyqxQX<^1(QAVbIf3U2=fBf(XKbFWK+&J1Q-B7=1OM%cO_(BNS>(Rl zKr2l;3{j{R>jqas&^$yX-S?`t-Il^oBMCZxtBNH2cI{T)%he;> zXFCSxztbH(=HG31FY;Y~U#H6OnRGJFIBcpr9(Ffch&|Om^*wOUU4P)sU~nS$J^6Ib zuOvgU{)*QJ?KEk4L`-Pgs`C|9NG!f~zd9fJ$ms@9{PJr~t)9~?&6YU!*ewX% z^j&XlL0&h#ciEs@S~Rn1YV02O#Nxl{IBVvMdUh(3!4U7cJdE4p*;>lw+0;`S5_^z+ z`Zlbh{sw#f-HP5LJ>_F5ujqRJ$Nh-WIv4ubH+&f;r{8!-_;QWs4-C3zE;(_HLisv|}B4R2F$LQWhh8BsMsKGYdeEZK_zW_aaIWf<_+eD5oKn*Kk zedKGmQS^0o@F1IXE_5fu&tCAz@?NWQ4)+FdX3m$ME+(ejLeA6v$Q?iqyXiFjLpv(f z$`&xFb{AIiChFUJzq*9Pif;qG%`g1nvu{bJH#W~JVxdb4+Xs%-3yM9pv0J-mJJ1Pq z#sy9+*nt2eH-VtWd?^&`H~`mS?Wp){m?CM8 zrYG&87_c}uxZSvtWZ-^ZZSk<0S`yqY)2v7+RtA zb}GWiJ$T3h{plmlHBzZe4Q2cN_*< zH3Mtw{{AyQ?eNlO`7)YsH zxShB%P$S}L&E@JXf>!2BhNN9~3GdDi6JegYTVWl9snnerhrqQ`LMZLY?@T_- zhl|Xv{>s5|uY3PLvjE%ektbQZ z`8Brxy;vmLw6&8xvh_on$eS5Qk_VsYMEeQqzmNhq?2+b}p z?uftOJaG-tf=B*}{qJ_v+)MLmUAN$vFEhv(TZO;R8`#>V^0wV>;{m!}21)sMn9j+bHCO9;ja>Jo3of z?hy;8@=5OEjgXfrx{_HpAYD)P8GHPG33ZcQHz?h%{T$<>Y5e9~-DKThig<*cZ2L!x z2=?tC4O-Q%VyFKc`VPj2ieXBslNE@DJ6_2?(3A|@EXg~=9YdluT$9OWezQgP_-LZm z#1)H(LkT#^UY1L0a1%8}Yg0x_95o@GvYGK%8GVTLJnR|Te-CwQm{$Y9@G$w9U6JcgdW^$s+zP{IDBpvUg_uo#wST7`?vuv@z$lGSdFFMgl0Y z4)R->Z(X0e0y@{{C0gcNHKl@|7SnG33N5}Jg8F|snoIL~Kct+?d450b@k%scUo`rg zd{FiU(U$k)2E58{os{Dcv z>hz|5H8yGhxC(}^oLXegvFe&Gfc9eMfkcttus}KZ-xZ00&Oi}iz%5vIyCYw5w_~sw#5VTs%0FKp^RbY|91#J)24;M{y96SMbB%}`}9q&7V z9rgPgKnM#E0^BjeJSToVvjl6D{pCz|Y*5UC*;D+NJ!7D$f2b4D3I`|URqL;Mft@Co z8=i(gIa1O-m)k#5Pwh=aBZfIL1x)|n0Fa$1m_guTV>?zG2PT5GEgjR9$l(KX(sA=w zL`X9FG85?e4it;P_2@WHj^DT-1!2T5{f+=_dvFriVY90%z;CxG`h5&Nx3qn}v#=~1 z@7SWqik#)~^{Yz&wRFcVSIs}Fb=XHCq5CT$a!&w5rj;{`zWa_3LN6UBrREw;pOA}B zA5V}4iOkU`v-9K4njnN|{ha+01bY5Fp z86K`re^!!6T{Etzz zS_?QXSrL@E*@%-0|d+i=mD6|ls08rd$2dlf#4zKPlDqH2?eWYUW`G_B6Od8uwaIEjmUY6chp;7cY7bQvIPKO(I1q5 z_mXP%?q7TUH!1rZAmHF4kTPo1;*Zs%g6D&8ttc(VSUQb(8i^(g!%{uptR9(X!;*;| z9ry!)KlkA|{H$?Z^YaWTjWO8}!LK2?wS|z>k4ic+ufU#osHI5Yq+lfuk3+ z_XJ4l%O?q=q4p3k%vN$l6DNL|)J9CYBbL-s8rsYgRFXNmeZxd2N)Cd7sCXa$BoZ$k zK>s}NV?5u@o9Klzb86~n=sNBJ7gW)cj^y?bH>mF~fWYn{+54fM0AwtS8~IG5x4F#3C>obtj)`0oE3x z%Xupb!m$C)49&Z)(-UP;0eqIFPB%uKXoHxhwbIXIUYdPUqU~x>q2kMTF>Ny6Px&Ig ze`tM!X*i0h$hUT!&a)}gls#u`-?g1CzbE6HJ!ki>OS17gI-C-WY01|yvuN_|%7v$0 z%Z;uwsIBVEg$KEi)W59Y#!Cy!pPtSb3yIF*B*bfT+xD*CP*htzt|rDfyPYh6&Ucwg zG(rWj-TLx9e7=dmY(*ZRff?AFu%HLa02Gxmx+Ma|M8_js~0D(3%l0jE)R}TXTN)DH><@&3p=i#4wIeQC27?^8n5!EWyeEvK98YA}M z;4n}s*~1fH3;F>LE#6oLAiTNdN$C;4hs*1+b)-rKCPg>Txj`=QQ|W&yoz+79b`v{F59x9aIAQ1+q5 zdV#jA9rE&r(JNr0!npK+fI#HQTniDd$b4#=wg~VgrE;hZgyRLEj=qtsEvqml0Ju=7 zM3nN|A#@vcy2YXE9V9N&h>~@WWuiE*JJJlW^>fUJPDu1SuOduN1CWy?tm-<; z`|0ULCqm@}KD~^{F7)w1ntZ>@Gk@9fSJQjgz4@!ReEA&Pi>z_GUl_%2`8v+>J`v+i z(0#3xE1xT)i_oEpm+GTKS$`J0Vza_C?{>m{^7&A}lgxA2-SpMAjHf?R5)WXFu>IXN zbOn>E*{U&EWybCo^Nnk>l@IY7S|L&XTfjlt#>D04!!>R?KwyU{(WuJM)gI<|DXehj zo%Vx};b`oJ?mo|aa)~xj7m^h{^KQn3X`N@D=gHM?9$G*V}t&5rf+7Zg9BINM7qtVHt6MdR(7!yxzMK!^iuA zlVnA)dJDqeyb^n(;uN}V?v=87B}UxSS0_By&3aZRteQkl@f$VRZu555vFBRMF?@Ud z>26&vKG_<&Fc9T;ci`6uIBcQK6dht!J^ZH-ol$`XCyv>vFIMd^AJy37gt9r;143HVwWxSUz(ZW2SI$||A~%$0x*K#* zB;wl@|D&t6?S>o4Py2`=CZ+BHCSZasgm#E$>jLC$C@QKp2t~ZSPI3$sK9j6~6avw; z$HnaEePjifxg7zhqf$K1iw})#b*e)%SUk?#0}aL0^bxs(T#?u7w(_Tv5eIYm7bPPj zptZ1DWb{*t1u&5d3FdCv9f#~5Bz-5+KY-lm-VEK~ ziDG7>8NXH>bQy%uu#TpP2Pa#PLQGEq=Ev?gcrDOlo`ZVpIGu+9$Z6XrOuRvr8@08= z9WTqcI+G(z;BzzhEnQi`dzbwX@rpq%In{&LKz(XawFC- z@$%LpPW2)2gyE=7JsXH>Yp?$XuhbVvzD(a;^;6p_yKy2_I#TP_mHezwA~%_QBL!zC ztu5np`~fDNk{_(2y6+4~=~J>#7`UlL?&ra$51h^0JH(u_XZjKT@gDk{TI7%)D5P+6 z6zM2&jG+`d#1f1Li%Y)T&Ib7Sjnvc1$^+xaDDZ1z5TsYe`F?WGQ^C$^_B0#$LZ3*| zIPO94n;DJc=+7SC$9m$bwrJ9P^>xwJW7y=Q$@fkD_C6m<6PhF%7I$WtIxTmr0D8Xc zXOor0ZY=N|cwak+?^c3#VFLqggVtCMLVPQMP~S(4*C*W)_mkx;Ov>2FSRk@x98mrM zR%^K*m%m6hgc;bSzZ(Fo2B6byHnL|)8P@|6i>b=F<^G|8XT@mno7&gk5_gI8_^}&}II0lrSWD0>K z`O?_TZDPm|vKh)cu_4bgmz{uvrWxfbjhOQu_a z&tNW7Lr^*gP%wQ}02tb@O#Dd!bk`#o)*yGhly$s+16+iGY-*aXQ0!C!Hn zevJwT?;HB)96b7?0?(FF5!n$20s!7$We%|)VAY3tL$l*+1o-jLxU)teD~_RE`}2lp zwE56QT)c9aQrsC1O+Iu27cb?Xl7p*FFsjK=e490RTY_}3;ZvDgwLL)Yn$k^<6zI96Lo&}Q?{ z;Ww#|qT&OEKZDi$iGgGoMT18vqEjb?L@81Lr?Aj@8T#0e=+Kp8t~ zc`Pg=24_cupom;?(AqD8guWR@V08oSPhWB!Z-(WR01IFU^p>+FckR;|$~B3U4a%%tz6y&&YXlq_ zrp9#bpM&~STbnk!dBNp_`bI5sh;q16^)7GL!;qX4S?S|4-q8dtp#1e7v8@cV@B}#V04MSw20_NVHiZwJWVcIi z>6uABzMWSdoRk6acvDT&n>M-g=`$I4x?%l6a-e+^$YkIo<~U*{LmVzniDeusgpw|$$TC#^mm=%qk;RoX zSIrRr>w*;FPh4Db6x|cf4|+)OUZES(BEWC03Pufd38%_WkAA>mZFw2%9*@UGhZUla zk`6DQd9S+`bcu;K?L&;8op$^6H9MHBORr1!Bw-zu-mUa) z^bN;Guuuzda zH~VZ2Bt0HtW<<}Q#CsC2Wv$Sn^C%%Pt+#-xXx;9Wxx;9vi^?iJTsrDEC2B10G2w zW#;7}M%-xk8cf|E2?75u886l|6OW>gTEaa*=1;}0-}A+tnxfdBKG)iUoH6UU)&PTJ zvYOYyj%r;FBdLFTt#2qcm|~lDec%l=NJFxgz_o9M2D`Enk_Ufa`)+7SPB$1(gWY4{m_X2w1J->UT z1Fy$G_x$&%m64>YK0_O%9g8D6xAbt?l!mpOeTzdzc%1`AcPdE{`{dna_-fz*UMI>dOAua_0W3@8LDKXe-TwaHN`x9b|t?X0z9OxY*O5nB|itKYtqW~zJu8>Dg2=J zj}3>|2W~(GQJ=YL+2&sy>u2i#=kiabbWN78BUq|zJ$mqFd4$))4~Vi(B`zaJt|{(% z%oZRmrvxs~%nX2TPy2r(J={K_Is<}I4OY*ks}oRew`Tx0{H#2BJkKuCSU|b?g(J5S zBX!s&>m2C4{yk>IQ3#PEt{yX+Y}EI`v%A&8>l`Eo`ZH<5B%H$Qc7o;}Jup4Ltv!13 zR`erAc+)QkvQFPLRV4nKop*K_Ot;!R_&YTBlpwkXrSVsA3}6Odsh`8(y`O7h!I!iS6ssDCoh1E-4FJ1 z1K=SA(Dxwh$EvelNIZ>{<2ENnq{=<&;alg=V`pv%Co&vcDNbc6jg zsUj@(df)-LjBh@t=uF!W|^F9U?yr%KS>U zx;6O5Hv79(-neSlJEh0u*Asgr%B^@34kOH{{oYWZUH03Ui$l!Pg+lL%O!<^uM+UQ615Xi zIo_|0l#m_jocWm;B#BE`EU}2rZO6W44}jfHpq9Qn;qSxB_as^O*}%eTf~fk{w90rz zZ1`<3Q8}KmDt_t;vOkmPyhnzF2iOMh?e^4 z{(+po$i-YT`7*)%k+Yg10{mSmQKvIX-=%FBQ?a&^9ok~WCZQ?CPFkFu1>9ssJB30} zhP(Ib%jM+td6m3Uo0<&003C6pExczJCVveJdeMu{nQaql{bM~V;~e0aiR@HrCxtXs zjO4;vEMvLK$6U@T{VDCsEs@4ss97V(4#jXPo}*4~vZMQwv5ys>glFZZw+{pXmBk=B zM_Y$m4r`HR!9*i{mpGb8!GdH>cZLOyg#+x(sIs1rPiy-5D%BNI;a?|a-vVIf_ZGty zY+XJbKVJ;;W-Qcu1*7!AMUwWm?Y8bTYW(X<6jVw;c9iu8Gp6Dv9StOSVFZ^ia4^r| zv7YeNi2|00U7@mJVMxdQ0r|u>RzKenU!rC?))OJ^XT%n%m<9hjhJ>-b&CIUkJ?jb6 z#|sJlo}Rt%rihG5JU4RW56?m+ENAQ|aZ*U|EeKv}27r|41sn|N87p8D^+=~Bdb57h zolyw~@ce`?NCOZn?4DVi6-kCGVk;G}|B8sm%Q)+zRdt`#U}JM(ccVPE4FXi{xbY28 zr45-}!xfzu(Ma%K;DPNA`WoInXWU;6S3qk7X;`Qpt|gM53VN=oCtOaeY`xPHn;l8_ zTuwKCCK-9B01+<@{M%QUT~a8NA~58KUC-9{GGU6Tj=#?lz#rYfcUDB0Un{k zp{of5k~WciD3>?vQkflrjhJ6eS34jJZ*ZB@U85d=Ql3+}&W_zZxg+pbHql5F?}%Yh zjGx_S)~0V{={!c_Va53)nSOSU6eEv10{RaJK<6s{>wg|u6YObP^WG~I zznxu{?Wrko`>uxOWhqB;X$_N8!UPiuXa3x{(vVjnvQ-q=A4&z*CM$RC^|#=7a>B^+%a>%39&g|OY`4xE*n72oiD5}L30T+ zPZE%LIV-GyDgIOGy}0`!onPOjMHpFC^T52>%h@GUf7%eMykD^GDc+P^**HRmKQ^~+?(tJ`crv=4- z!ejPocM^BKz?fY?G4c&=!iB4B6GH&NUL_Xxx;wEAm6s@j&dq&>D?|;vRJb1oGW|ao zGP$DzvR0I^fUIo&iw`SeW*TI^W=04B3pm+6W=2ALulc=TparpM$$o!tP$&iErqM!g z9Lq0opU%KSLJl|(*jhQ>vFBRmsd$*2$7V(QOt#0MHIsR{NfL@~XkfJpQWi!#l9GeM z>du~tHl%JIz*}EZeHY7!^c>>p0LQyCioizE`?H7xVO39nHGKfE`gSQ7rKI&8`6&P$ zY5m`mKG&NB@%{SPuO>0|I19MiPpetLc$yC_v04ZuO?pzDA9v)284qy++iU4LX&gW()>ekX zOStMz`T{c!Z*tTAzZ`%W*Un<+rAVG-$`L6$q@mmY1>PrB*lYN)jJ5Ixb@JOxR`{>OT^BM-ZNIPk@FohHF7-zu8j~Cw4G$mEwu+su zDv!UTlcT@wi?2Eoy3}K+Kir=(F2iXKG*;;Q!Z97$n~ICJ-EjQjm$Oj4jlh&6Ez7iC zueQZ4DfFXQ(74k`!!^^=zdtd+F zH|CZF;`3&!KxDgzXIK$G+IQW5_&i|u_Ch-dCJ3j~j#alV>}&s)0EzYBWtzlweFV`j z#3K{Fmq+>b#)R@bsL>s7rJvT{N-y{Q^y^Mzn+FD>+xAf>Clh&vcSDDjJ>bUogJL`1 z+C~0)yFxVe7}1>UvQzKn-*#1k_WHeH%#Af!p9c{lJ4@sWX3h|CTD+&WJKwhh^7Ck4 zvh#9a7l|~?$@e7ohXPrzCmTTz*5+V5=2W10ww+JRbyvoxG&$R&`VIaNjtkBB1KGle zZfTRIdjVWFME2=hX-VG0wHXiI${*pzFHOJ~u@QE2U4J+$g5RcaqlS8kbp&|fp||GR zD&sN1sGh7H2{{;&bwHO(M9m;!{MG(Z1WH|kTf+bbG13S-(;ff6LKgEqEdUcz>00?- zG3w&a%QP^C-3A!kD_)MHWn)5G7?*oTnv>hOyZhQz$`L(dpH;+`E*(#z7X#N}{u z2A1+Tb!ARZfQxV$PH*meC6eUh7%Y+aJSSmmQd5mw-fO|dT}f|cqOr)w6~zXkhxUPG zo8JiKXpLi}YGjUiBCem80nV%<&#iwj^WqLhX1%$sWJ$W+TqP4*OmDn@qe)Rfaczh{Xfy}|$(>wuNQGk@Yz0ZmI%y`@qU%dl~CxU)8fJidIt^+Mk zmUlHsg&I(bs6Y}Ij%-*9NR!mF?@-7C^R9kV(M-4d^_@Yn&SK&f?E>ds7`6?eQ#Vqf z)1CWdaNlbukB=$5d)F`09vvo51KlahqIv^k@*-I5I#{F#Mrb7y^CF&HYUr_eiaSSXY9lCDPm}7p$@fh%`1|xbp(k zO!__M7yY~FFm!yYAIYQ?-SDM{WH4a(Ky#gMTO8Ip-!Ac8d?aI{6+zwT z-^GBb2fgTe+X6!FdizDu55KR^;w4N9AEpsmRys0UOhP>Q^LKFIUzJ5Un*%Z^xG|>L zm9=W(iqprW6OztRnD^%kqBuo#1<@-{8-nR#>G8iryZDe4DTZYnaqJbD%`mrNgE6R=$8e4{a@l3+R*= z#6#Pe)5zzR(Qqd+>l$>2(U=zhtGLd^H&iz8(c;R-JbY@AwZ*Xq_AnSZ>2Hn=f`|M7MfhF*frru@ePd4w#bk9D-Ro3 zFe_wtGBg<@BjjcxG}&LVi`a=`OODn^lGaF(9}_ecnjEg!r3=u$VY9gaLQ|pF)@$Ba zY=FWt{Ua^rKn`|gIzMLX$NS~zBrGQiug2>vamF2SMj2Wo2tTIWSZLj8SNm;r@3^CS zBDkb#0jOgp--nVjoxUfvO`cdF1GYfUOog1(r?N|`B=r)OWxdM!!@&KiK)M8gbS=29 z8|eEYv)u-i-`6al)bq0;O z7>lnSCiUz|8yH%;FO{ekRHQm0h0l-kNA3moIiBv$ZY~B}O8~;Rk$c;{2hf)7f>3Mb z%~jsWePrYIG{=+IMaq+F$L0Ua#x3}fD6;}hX(ou)suTO?D$@K(fVFGKKV+HzM!x*g z@xR}+|AYSdU-0LSo*X2iU>Ymp)Czm^|3c>S?9HQla)bzjFU^Uy!|cuJdU6Wz3lojf z0pv4XPtji_)zkj-Wp~jmUg0N$^nW89y6JOvm^G^u=A9CwLE+hGc%nqi+?)?_>aasC zh^d~KoOcxFmlC4~;n}lzqE#$@pA7zCFx^pnzLc0a2>(8dr&7(5`^i9js3io@;QGr5 z3jdCVr$WS>%dM+RXku>>(_J8nn*^`*2hr;;z{F0Hl-DI>v$yE#`io>^V)MqrYE${* z%4ADmng7pVY`!#wMXdNZMQFYR79@-+4p)YXDNb6ODz@f77&75hKdr9M8qK@J$3sG2 z6SZ)v3OiAnDiq9Au6nm-nDhp*XeDs@RgKPG;lIpmKGs8mT<< zXvr~>$YLSFiwSitu8(=ZxvNDtD6aZ^E;+dsSv*8EnaWelZL4Oz^nI>L<%e6|e=!u& zcv87-Ijxt>=bFZ9-102WC4X&2ej6hC9~pXSJPq8oj@C;%fCga7@?3IyD-t|J^bf=A zzcc1V{@mW#6=>Xs(k$2^mP_*SGWzGhIPB+}{sJ@_6dNKetK0$h@TlPG{+%!ug*F*T0bIq4_#DA|BiIE$fA*$h2DfbMA$o7rgOAW)AD}Ht7(w zT5F+aLJv`|>pH&e>-93@CZ~wnsM9I7C5QQ`eJ|U^jhGiX_`7g2e zW$~@s8^?S%?uw6@{}WjFj{r%0>({teocRBFQ?jMg@cZ|cx#WP4yT!^l`0+z>X9a8U z$B*brwtQBYAlEMgtGi6Wg|)EGr zBGo7>Jf}XMUy^U3Df0^)_f3y_s6jT>If3(#-U49M{0Bp!@!t%rIraaiZTv?`zNMzj zG&l~dN3GW=+u)qwxJ|zcc=+Ei4xbr*&I#Fi)aIH<0O$FoD+2C)EyK9oAL^n1bW|Prq-AR z-r-%+2yDO0G*ulcSLV2^6r>dc=+;jRTzB=3!$D2!Kd##Nh|UB9EDCJv;AgrPq;58@6f;)y>|E&- z%@X}4#&N5S<-RpAO_|6JoDKbLsOlQprB}^kPR$TU!hx(6>z>kF=nZfjf8vc(FfFD7 zWx3-P?l{F2tz4Q$a{6y5U01#CX8DHH{*8PCj^WtYMxpnRn~~E@FU~jOl5=xrWhXsh zcShqbAmVh#)|(RfA<{oh`<>Eo*9KvY%Afgcfi9LtzYzb>U+jsZK~XqI;_KvU8N>b| zQM^O>eERjB__s=Nrq8PKA*ZN+Zw`wP%;)JY#=Zt5SqKmV9VCKT&AOl;pmc?^H|=*Q z9=?rp?b6Sn=z-GLQ9mF^&3Q#`&ob!6J1!sh^B80N?(dL!bC3`i53lxgQlS+r^^Lp& zJzD;CGfpCjW={xouS9!`q-dK(*ac?ZyQ@6YF_ z=XT8Ji6zDoQ4w(yV0e#O1Jd(|OAUN5NT^&pU722W>T2#L@6%t~yp?dpb{$E+cXG6E z;YPu8T(y3WzSYnlSr0zT(baTgomOWVbei<52WzuUtFuk0p@H;%7=ugD2c6VEf=d*E zL$9u;Uh;l%nuFejA(#P^|E9zbW2<4$zaH$Y0xo$q==3A39t_lUGQvTx3{XWIbmCG0 zGqBxJ+UX7PO=I80yZZecs$W9i{?dtODNChHF+J~(;nK)Ey-fMWcVB~Vy38J&W)Ifs zJ*x0^GVai=h1A;&*V}}H7P)D1UJpAp@=YIh*4togf7y0{X*+0h&kWx7CK=k^XvN zqU~GG;fq-|r0o^mtTo-Nc#tRm_U(oX3}{`!kYr&jw35-=@_ZF;XugMK*oh^5U!QHd z*&f_z4|dc^(`#J7eg#l zOB{UOy31&!M=9cp8@KKhw052t!xv1$7iuH`DB#??wTylcS>FOAl0FK%E;DQ$7HoU( zSu@;S{|7Eyk`w>I$K2!Tf=ZfX;?V`y7 zPG|{RCh~cX{O4;wV?H+E`FlJ+!N6Ny!P0xNnd#y3Dw)GN{uG};?H=Ah=JoVMxT(hp!NS0b_)FiVFkDa=g_Jf*7?&xfRW!bzOj`6O% z-XAA?!PpUcthi!55W>17LAfL$aL4Ff5@}xEIBnP1c@QHo{ry-F%KqYC8ld9@cZ@Be z?kWB^hgYZKLwz62K3$zk(uC3lXz_D2wzIQqMPT>LuYVAv{I-*x!D?yt$(tp5kmeKh z;1Yh8Q=sJ5DC+1%IzPe?Fd^)4y@0W~%@2cUN*YIWh~LG%D}@#-wpf*+kVs1m;|xX6 zbtPlawT07HZ<=^59Za#7>8bPes87wIqSYE+$f+0PG}w|iqK(sENo(A7=(?}`B=ww7 zjc~FeOEdDXvz;<DF_L}l`Z|ff2U^**aIUj;ockh+yuhF42!^W z>|xUu^Y}2&ATZS!nU)hsnkv7s-COv~Dv_bHzMwXhqolI=MaXbsJLQ(q`n~+l`OOn( zX;8vu?{RP-g_C+NA#Dqe_sIbjBy@N+aE}%m4{n2!@zaCf(?PUTJ!LA-kwtrsd_ob!Nt=T?KKK($ns0R@{|f8xiQ?%xPE7(FJ+xcKp+NZzS?n)nH#*T0+-M1$FEl1>VXZZ(EUlcA0Go|OoLaqd;tW9qBU zJhI-8#D$4`4p2Rnid3e5{O%^*P0EE)be*?FUR{?YA%shR`yEqOf|ToBiVnj_QBkL1 zbZWyyMPW&ioX|(L@sCPMJpo_Z@v-;N@*Khol{EEibqwXFm=1P}_pKR#c&u4z{BbWG zC)1j)zHeGkKN0U0o|$+!_rj;MFqk`am^R2@VbGMTWC zGSmQt4^t;XzVCAws!eIKruE+jsSw=5Ri~kD;SQL{!-K+2*=hXid(K$*npbs=WgyM0 zsg{iAyfn4-y#TFX&{t$Hu*+AZdm;wLd!k}*M}!!`TMZ15o9b>i3f2H|b=ykVx!&qQdW9@0AQ&x z3ufcmK=qCz%uWZE(P-ZGVf%6Q7v*_QiA*syDN02BvZNo|)jXni+-C^F<9F!OHc~Dm z{OdgUF2LjT?Q?`n3sxx?3a=5KGX~()D}aa^$?8aPQ2)9gTV@ndk1KzYQ)a2UXJbbe z7eQ?~tg!q)fe$H&wbx zze>IGZrMq{_W$ysn{=X+{xKV~at-4aB6^DOu#tT&b~|=?G*T}uvd8nYHZeWG{((>W z!Q%K)aQP=rLhhD-l5$pnQ9{RroK|i#3_fcDNdA&RYWt#=^-9f%a-y! zCdu9Os*u?MkE~H7kXR`4M63stsp8FUq8I%P60Vx%Xa{Enetzi{0PM=7KknWK-hN-q z$`IvpjU%_hIQL)R(|V-aXos9Bkz*((dLz5pRo%bu^N-)m${_#o^S+uRAO8PGrFWR# zbrBRMP_sPu44;~(thKFPL z;#)c}Ql9$GlyYv;8J}=c&2BPsmEb4a?m77c2F^x?W4sJ+wm+B~nBElLil+z={GJ_D zig%ZL_TUIacM+I*t_UyGd(XKSn&|BuRLV0TA|N)Ewwd+$jJ`sw{SM?iWWAm2%+t|Bao4xjiRk(E6~ zgnB8NU5j2Na@=PNjiZWuZyh?JtU>R<*t4DTmi^wU^+cCL5Pp$`H5aW7fXxK}_#dpt zPY;Cww`l;8-&P0UpZ~nbdWZb=aZkiN5|Dp&YgKMC%FinD?v7_)gxXP3^I8-{5J)H)Ef4&nj&K>#mWF`_kG4u#rD-D1K%wp%<(=351&z*>8_RY^{&HZQ1odc_< z!q_ybXR`2@VA2VxV<5>puYt?Ixf7#dzOEA^b#q}AA;bUh>9_A?=<+JU1H3nIrj%-) ze!&bCA3hzR-Y6bE5g!Z>KPq9=)Yd#zb8OsI0?b3EXJ&C)oTw9r$iFb(8-iz-W@gH0 zOOR~BtGEV$iV%zh-Z$k*6QV=RBnoQS0AG!aH>j zu%w(=-hLQ_p(5=FkzHj^zumI6TjNAW*o0{t6l)%VHaIo)Y;f*YDa*X+Va&Th8OiGD zpf@|h#kOxF_ApD5Cfe$Wlikhat}r%%a$Y2|lz8@Ww|aCMMC+ev>@h6)16?@s^J|a4 zUoF^a=}O6Gd(-nvp&-IkubTfpk;(>|kj8!Lg8rI5Vl&T*+H>rQY}~6)xQAhCJQL3- zmeb%o-5Hk)Ax~<))BS9YuS(ogEds$Q%A)4FZQ%6KEwpxcGPLttO6-Z=KbJfrjR41U z)O-Kr&eV;+L(sEH30)A`aTt)_coa?2`9yJrAvw(??eJt}EqI=~AcC(~O9pwU{$anl zQV$e9*P&p8jAz2>AP->HF~je_knDjQ_Sic!%XP@b+_nAT^;A!^<=sziFI{g1T_O?i z;XFXi@S6srz-a=gg)2W!IqDr0?y08BsW%>H=jyh&PS-*CF?YSw-{OGCm=k4>NaZu% z+fiR(H0UxWJcn7S=J1p~(5(u2@Mp%8`)>>@Yh6AvFIDHw?4R6ug=nYoqg=~`B0H(J zky&d%K{~?J*I;??YSX7?{$C}h#xwk<^kOOkaxh(1b8D|JK26;xyOnjw1s?tBk+VkV?H}BESgd$P^dBC`qog%%*a35McE_ZP$1PQeccX|k> z4|fjSSGQn{40zmMT-NC>?XCX)A}E+Sd|V!!bSx5N+j*JFawj))=wc8Qe79N$F5DD6 z2)YX%p-pmIGUz$gz!ZLkSgWL5t56$u`X00M5WCKqD9`n)W9!V< zE;%qfA$(Y@KFak~G|kdp6)f_h@l4X2Ad>dPFx{>W(CLW&FRlYvZxAJYDh(4RD3OnOgjljUPJAY;gxvp%fQ7pC{Hp@`_vA&Ls+e&#AIdR7K zV^~Oi=ry0d65^hWmt!4#=&}?s^7+n%#rH-#FB`rr_B5cB%Rx7y+DeVsXo8S{gOY)W zD;QRra$RORxmrcla3RN+hV^9B5F6jkybTFeh;s+FhlJ4eg|iW^$BR4+w70&i!5Yo@ z-sY3x&>;Ze3jpLH@C9x7;(6bE*+Sq8|62haHr1C*;BRh6i2ol&_jh+gRNTBHU$zes z4G2AkYW_3;G^45&YbG$n7hu=n<=`X{5wn# zB|H4sgyT;s_TZv(PYuFm(Krwz&4Z^#>cZ?8gm`N>m4eFyMf(=Sc;+-ZA>TlnBGv-T zteATj%eS$gT?8r4D&~yeld`zhaOCV6o)#60|KdLOhAYEK*@C~(%&o(Bc&>~yxtCo$nazu8QTVHLYymzh4x>YfBa(vuGW1#S{NhW1- zeBy6Ejes<*xDr-WiCWm6bqBKDr6(-?cg3L|2ulXVybUC9iKPKQJa&%7!5^8Jen|(< zeP-BYeP1VnVFG`JkkT^5Uv7Ti_VY`c6Ap())R5gl-bsB-vM4|AWtCNar~LY3+sr_N zgLlZyuUL2j8l5&m5ggaKOs4wI?5M(kN4 zA-f)rZ@uGU)`0W<;VSln;cwy=( z5S$YBUyvu~h8ejH??JT!%56hfgYQqKolR35iC@?8+cB0Zr=_E?-JncVJ8V$|%dZuD zw_#eT?NCx(F;=*CXdFOYcK32T;FNWPPpJ*zQ`U*{RH7 z6S~-i&Oy9rRhoXh7#+%}9aVvZW+aGVyV4-yFQS3RFYpQXUcTt282F}0ig@}1CjqyV zVOb7I8aJUY`Vb|NXC7W-lRnKqLFCH^S6(#6a7H>YRS2h!M#0WXPv{H3;yM*G^M+3y zuMzXOtY}2_fk=f(X4)tqUbmM!n&TUTIVa~Gv=LaqY7(%byclGPG~_?iS$VRloc{v z#A`{os$1H?;}S**S@I=;<+F)9yImK&rj|DT<>VFakWH3tD`5kA&fFN#ta-7R;dM*I zoV7t1UhYc#a~`Xc$uXL3ST!3K|x*y66cPAZ=&D@cnN{kc8sj@+Kmcq zebF&RSB|`I?ExHnjk`9qO(ULyRiUP!tXCL#zqg;%=(xG9rfI>P8yT zj=sSP5q_`x3vwX!B5$Ot^flLO&rgjvT}f6NL88^{uzn-DW(@G6V}4G*SbXFSr@?Ox zIl?9!Il^F_mG3Lb-e?0e1vJlp>us89)Y(TCt`=cJv_(b%Z@tb$;yfmK5wDW}EnbCc z)YA<8MI?pq3Pu+W7K!LAcA}y|91G^4ABs6X8&a(|CTn{+7W#b@9A@nz^7`RCQ*Sxd^E!X%jAOM zhOg{I`2zmdrvA%1Fdufk;Cq&rO=3`pehc`=^{vd6%^6mRHgbGVKqGO1x2E*BWRdYl zXLvwmco6LMhaVymoX{t{X@OgiGxkmJ3TXcQ(imUP%-_+hqC@t{W2t2O*kG~%mf-=S zsoTT3^I_JGphm#I>=xG~>8xq|xO5?_{qGmxfD9d@{WmzUwE?cx#CQDFPt@{)p!js< z#T^z>CvB|kB+P_uYJQs^%R&#rc$wZx*;nesJX_c59eBT+;j~8g>!BJs!N$;;W^2KS z-&QKz&t1w}4Z2#wOZMWak%L(J=uBG!dlc^(uZ857Y-NsX>&siOc9YVl6QQO57W)UJXD47b# zSx=m#m(pkyajx7ycpwMCU>Czcv+ah$03(>8xh~vNxgDhseFHm#U;Rj1CE0{u6ytzu1_a0%*0amljVsquY^PtbARz7u?FPL71P#VfiXM701jqlr(;QhcaS>9UBsv62HRQNVP8~EV%;Mjw+5S2O$?x6{coRkr{ah1?r16jr zDk z@fNkzgUp*)kcE29u0rq&OnI($d%L426yd5kAqm!0O!Mh_{`twvW^#P()_@lzpBD=8 zvb#NBP~DeABZr*5eAm$yCbdBRJNm_%5$lobx)Cchn(2qJq)Fabp`+EDbcS1JE=iTM zR|vs*$31&|9bzjdFXMUNtZQxNh@L~1tT~n%1t*eWSxlQ;w05w#aZ}j?qu`XATnLhu zX(y7!f$T@}tqTo^<#aDH+(vY$V{p;rAmuttzFYljIbhA4?$G&8Z^ne3EGM2^JPVZw zr2K|5+m}k$)vT$}Ekq;?F+|hs=k=O$JI<UO?P`>1m!p0vZV==G;BH-8+Q@Z%_o#8TTdyyQomt zt}EYN#Z+KIe|{$>E`1HDSXV&ohw27xWu>*dcZ0TZNrE?EU2jd=s&7q*S7e1#?5-g0 zv>RVN*;k8h^)Z%+k4b9nn%wWN(VPl577|d$+NkgTD*U+JfIIejcB~{>`1>FpNhvJ? zn-lDOTzirqsPuN?7*jR#EoUqiELLiNND+c8l37PxFb3rAEuH2C#0PW+K>=L($X!C< zPJTmtEPp_Dmd4{0aP77Q1XCH)p*zLo*S0z+f1N0A3g=XIHXD9;lggE3x#0b$|2S|f zSA=6j1*Y$ln&TX($GS6sx%ZK^DtxL`i29U0{(Z~KY(u$aX35RFZzTIv)W2OhinxMn zmk~CX`rV>p*43e7DwJQPV+Y<1hY4s0mKjl7TIGl$IO@!WykBcCH%NjpJ{?`5oo)27E%89&t6%CgYPs_MZQ)BlwY^ba*V8v>U-M!>Ouz`IU69wSLZ`mhLDB$OMdc2QWtXH zW(V5Z?6O_~!d=G)72Z4^uD)GyesypC0ZE|D6uCpxE=Cv`d|16$CS$bF;|rr!0FrNm z>hYl8D$+I%i&Lj~{b$XL2w-7wV3+`~_y|$OkiF`~qnUZqD^~fdCXbK=`Ai(upKOCL zO$RMUE{WJIpk=W+SHoq!QCv}?*EaRAjsa>9F)jOuMYrUh(`>JgSM?qwIP&*{f9nNH z3pI0OSVqcun^Ok}I?l<4%p->*7yy3HDfD>qU$w@Rc3ScZQ; zokr-*W5STX{0y1i(;hB(qF{$iOSTP(yi{68B>}Os-!X(#f8ze|QWJ7eL2)#Qi<0a9 zDH_hce2@mT_U7CM)mQltC`PqEWxcXDdsLej)l6MT9Z0^a`_dlt{2f|V3J1BO#2s&CsnC_X3Tv2 z!@QrFQ`)w3s2S$hG!|*J{1l{mizr!z&fp_n`v$9;(xv$0e=23q-G&$RZh)2vr0LMD zx+vRhkPQOEoB^vWq;*qsO^-sma=*t%N~*cw#j1GuN+z9>MO?zLbZDR}B@pGJgrr1G zgn-k|gv$df=vR#iWwu$Hc-8J97yBe5zZ#2=ksA}Ko|t{PEEL}sCE^*;ob7RimSLQ$ zAF?mJZ@Tt${lsDdRr}z_WpPI;WT^XvQv~H~*?#cXgz~#S)@8Q)&Im0B((Ip$2=Lwm zF&qM=We2*NP$8yR^>{~wiSrEH1bSyQi&m&*B9Y%)mrT7pD&=kiFozK;Wn*;HQ z;&$b;Kq}-T%=*wb<#qVxJF!v}rMPBA`p)wdT8=tATBSRmAx2W}+*lun@2%znm*1ZG z=(6Egw)m)_jBH!*x3i#>gWtS;&kAQA$N0ksVZ?LeYpQFK4sJ#xQ#k7ucwV#gDTs{* z(qX{QsMo<1#kdHi|54T?kld`%M-$&-iDwK2f69$&o8GQd-~zvltex*W}i1s8s}@1w z94KkX`q^^~0W^G)tup(m#xtg6mK*NBVSeT${T=?}xTt~!TpX~Y46meNqx_qnUeC3E zhH1Qe3W`$}=b$Jgo{H-HLduB3d&J{qr_TG)=L)kQHXdrSp#4(h=GyzM|4PsY)6OvR z#MufwqZBj&D2!RNUMQ(}e3+*2_7DtIyFNipc0b!t2x2jx85+!ij1j6bSbvJ`E#LdK z##b23SnG(HpPhSM7)TDVf}sY=3DMtVcDv@Ge`j)eaz7jw(mkV$xOCHEDa?{n8B%qdc5t=n>Q+zM~ z&Z;&L7LnUPVFtX^((u2Tba-8sy+-}fy}&0)Z1UMk@bJuqk96xsUVxcR^y1I1=0E=I1yeXj(N^ujU_W< z-_akD!ce7)bRuCWltSyOe&%EtwsdVLe269!LFeVN=Ys&qSovvOZqiI+Zcl6h%EW_CPrJW>e%Cuq?VbcfG6p;yyB8d%Hlh_Of<-X+gJ1FADeYp{g z&(R5t&jg9kU!?UrIQgm}wh|g42+Q+TePO`U|A%+Qh72;{gd!OXx^ayd`08;QBO3g5 zfk~$}Nnf8p78T|pgzaE1;>Ea8;cqhVth}I*h-vsRpIlp_L-(iO5|k?aGwb>6Q^*Ug zt3{9Wbb`~vYM}%^-Y|dvf)69Z5&wxOp@ItlVtMGM({cV5rFWyAgd4ad(GHH)VS_jR zmxG<-aAl3=r1V2K6b-O|)y%`ucKkwk1=HkCoQ--{KP6N!2Jt>aEJhWT)YZWp@G4az z)=NxdE7+B|?EQXFQ9?X8`&Z;E#)Ouiju19K*cAfGwLSX!+g-UmZ^kDQpKgf&sp4&f zpRQ6!jvaK}baxvW*Rky@V}C%~!hJAeg8v_mM=vg{ifxRCq8T>$+G8!-ulr!>UH3E@ zJ&TQg+RmEF2G{`r5`7?H0(VMlB;PpY_9=9vlPR~{#sJ{3uQBbvYX=9{IF$VXtL*#K zM^$`3@u--Os#L^`qxcvG#v}QF0%q-WSUhZ&VfT$mpz6Tx;6khjJ_ZdHPm?M58yAx) z7_rv$JC~!VA%h7oJ`w_F99M4HN^>07B_veEet$9P6FATm8~xQu*^arqi1wf(uXXM= z2LV|00;G^oE$1dvugLN+3t1fg+}T+2fipyxU3~jKg{X%MS$ADQMk=01fj>N*F)tHo zjyv<9V2OY^9-`1`3NW&{01)q#iC>(jgA%~ecX5;*qC29mb9FY`!0AKH0^d2%{Ot;_ z*WLz9{l_ne``pG!?Kg)h$I|3dB^27|Z5y7$i; z8R8Kyd>pgmYtW!WtAJ!e+{Nbzn+BZplAwja*cHCnM1v%iVTg!C<)lJ0)CFqDhKghq z;k;eB`jT3W6<)vAm+rgpfz#7ElY}iRO>mG>gra+XgZdWE1STGi#*IcylX}+k;4G1e zM;JbkdH-}vjc>4$JtL7X5t=qyMnedPs%rsD{+{`vj=I~>O$uUmXb$s#REaTyZ=4Tr z28zuxGHKQr)s-98ljf+Z4dKK)IK6>6`!7f^<7OqeA?XcB(yCAh>IEeZ;)mp}F-@ooJh|XBJO?i+@3SBzS@Jwxzu%nk{Wts# z)FY-+ynI9}%*!dwk(FErCkb2}fHS6H(i7{T(7Y0CSOy}ho)~^uOB>%9U3~xe`KpTr zT8@RZ6IzZXXfk#oRZv!#hHo@}Hv*aI4dOrkv9ehLPaA_3Cv;qk-@#==*Ug%ZO{T`F zm0dwI(~x+c8USc#G}3?yUaYU*F%kaW4*eQ ztY+sQa$~$cW3_0i^LUPt%Jr&vjtL4%c;P*>8ow(PUUQ>M@D;1J9*_QP6q(2uGrv7( z1gR#V9=3;if8x_D9A+}7k6Moo$s58&6xVE!3DrfE+?QMZ+%?HTR+%+G3ng5G4o&Y4N&EwTF=01fM~*qREtPGj-|! zz<$dGq&4xQ`&^*g2hw^L=&sG9NKv8_tHcXyzDenK-cy$~JeJSwj&ef=JdE9xo5uiO zPO8TjxeJ%KZDjK|zwfUV!rG@8*FRv)VBTvW>dEq`mjh5vjBwi^``LT(entm=(#9%_ z>O#9+A^Jo3V$Jw9K43U8LH=;=t_UYof~h*opT2H`9P38>skl6tb_G6^Su@>z1)j)d zP)Z*Sw&bR>C7)zG`)J%K;FYkjExihrPtcN;|J5` z{QlDj~b-mda%mD0r_j0mN86uDVID znwl`)U-pRv`P<($et5lVum6iL{lBelkTre_CZhOXK&$mrPbe^cA?*b5>?;N@lsFyt z@Oynzt)HGluz9FU!VaDBA6Ab3Svg(~@k9CC+L)QvxnpH{ScZ?dAfY~dI3|jFadBn1 zkkCZ54Ov+lp*X-blyNX?yj|$3t2p8AzH5|`_)&GSpbLaFt^R37MiU_u&Ck%Wlqqfs z9ODD1m>Jx8ox`3jiPkwC!`pZi{H@TtL^OVFeg(7c$BS0D43?C>6s4rzVH`L%O)dXl zJGOVRSDw)+zXlF%9b*YJ!0MG%j%!i7n`c^c-6Ut)u|ECga72}67=n?>Iw8!UxB^3+ zqVwc;X<~Hf-b2~+$Y4Ee8lNLqo8(X}EX8>(ERiutzb^;ewq7iNqhosph7K0K5gUSg z_oplE-n_5IlZBdkNWhAKqxbK2C-r~Z@PyypO&_R)pCSpQ74%>52%;4vhVWv-BvvM1 zRzYzq5n9t`x7~Uc}@ot{IrC84ao2^Q&ma-UBc`y6ln_o`wU5n20#KO zTxOWk=z%p8r*_#YCQv8E7Z7-2+hB@;du%l=^1B%Q3}L3<7VzhHL$9TGZ+LbPK;1ss zQ_qp*6w%Y1Q_|BINNFe?Oikcmy)vUA&>k7n-tDaqZJLv9(HEq8WR*UIq zdK&#Gq7facOkfEdD3(X$8T?kmdUQ}M-#WJTbU<7KHULys7Pj7#$M(SO^4)4N+zNBP zdWGnKA%XX`%h9L$W%HNL>7?v$rz4!xNkDz4C*8G0uzHX^N1u8y55~LNPItym3&fj6 zun2k;4ey}~icp^pTgE_hv%%``y>NhmPZ4{65983fFFLq zIzBeHYn?70noN5kJ{o4lqXO+?$yz;>>B#*RZyzOqIq-$f`NJ^-7dim-2`v$0{CT~C z9xG<1(c%=Gv^PIw!KK(Ra6La)kc#)@%cux?B{P{V3*zZp&bz;|_D&5~B?RaD^Z)eI zH`_iH1X?gJ z#B&!AoFC#@jQwwXk-2%npKiqrHyqwn@?@u42+L`Y=GS5rL#s2crC32AhvzkezaTOk z5P9rHP(I%|rch;2EX?uNcVbwlP(Ez@h+={-)DCbaZCZPuuT@?w|x>0^WT_>>uG>mY0bhOY4;7zwHwZluoW z#w|?=NM}-n4r{BK;IZ5be76*ZbNL1r`YAXReuA-&Q`0(CJ;C~>+eQ!f zet3N=Lzo8niQooK*kdRfxgDPZ4w^!jbP7gB{?t!-lR;ey4rfiTF!halT|A-U>kGuQ znfvk$P7bHmsj<5<_q&))v*>EN98mn2XvuiOP0!Uk&v?Q~2OIqJQ`;D-H@CNZ_v-Vx z{bR0sAPf0>Am}``52udhrazF;fq)}GVFb#GvkR@W^=&-0QX&d}G*dfJdagqahwIN) zN_$!2ea(VqteKurRIZ()@J{=_AIuxS2=~rwOpe$Uk3q}MS>6ZY>-z31cH^Mx8`^yw zlu_<6l57j9-Oh;8I>E1m{YMT!s5FMrpFcXEu_i=%f-nwEG~$f?B`7m{Y}X;k!R>0J zkQ#+*Llhb*_{917nAc!%FM)J1oJHI{{FUz0RyS@j)c_)MX5Z0;2N6*{~Jz z0dX@b=q`csTJ%n#q2Afv+EP0U9b-X-149)FLGzD2+{gf}_BCE7-P8XAf&duk1XuDR zcB1b{Ejf$xgRqjRsZSe==n1xbZ`5&F))*Tx`yxY%7$_&fDGkurZ$|ox6C)vCxY?a~ zvHJl$q(=P!QVs-TrG$(WRvLXddSfNjsuWhs7*#9x;tIQDj$57?KXL*3QT+N4e~bok z@ox!6ig&B4310~O2Vn zI;mk9*qqD24k*FTn>n*=-(KWKulfiq1LNyI=OFBYhSE%+n*xOq85T!lG4{Jo9Cty6aPhxNuDJjlIm(r%fo7Nt`0+bl;)Y za~DfVei@pvY#uOnJgwcPZ2qf3l1xLfv-~3Cm^~k{B5_j9QHhYx2-vZ7vSLj*a)xkA z_)s+i)=zM}SDi;cp&Kl{jC-s#*nKzP&an8gPL8~b+Aqpz+lHw5PBmGiAh+*!$+;BI zVJewcv5$C(VJeAJp#Pht<+(n!VdB!Zv4Q!Jk;LbObjDq1a*~+ju3gcPdZUU_q;+#> zSugB;=l`?K;r9%UwjJzxxvtgF_2zi>0vH}xuR z8O~Nb_k?S+`SA6dMZJZBw-+htNNj>^86@iqJ6WPrUx&#{T-ZD{4TO<6k{I@}c0Ag% zhmn;?qOYIW4G8%qk0_9vwO9(Xk^s>)=9AhT$hpoMODT$}52(aFj!O5sTz#n%Q7=4{ zfik`{H+#O;&>M?mZ}wMfZsUXUDx7a73Qpy}ZVqYHD1z7=JN#DL zcy3I(;Wk zs>aP`0$QVNsi>ndWN|h_bt4_{kwP0rQa*HXy<+~27uSW zqYx&omL%PTnX@z7-*H))j#@R>7;)@g|In`wmlxkp`eUzla&mq|!EI*#B00!5E-Kz~ z2RHLgK0au1ctKyPP+NyuTU|YOT#;WJm4!-)r_AXVjTF_JVs322Z$KI zg9zH&JO*YgA1ub-8=HrvQ**xdk#7lP&s%rdU{Mz)NL~3xfffRSB(Y~yTe%BPqF2U- z^k7l;CmUG{GNS+D!cJ?`46D+L@I%tphhZ2Tsjx!$7O=!VKra(98k*Wr4|iez${(1& z!PN1bMdf7<)H*5*lt%vTiv3rA$fyh!;Myayl}kzL+9-nfQ;^2J z6ih;h2rSh2eC7Qg*dBf{M{lmqb3tavCq1Bgl=cdP2r^cl&jTBFvFwkjC0br<0~ouU zSx+84ScStI#ZLq5JBs%o*kb8gw@3tOo{|riyrShIG;!=_C%jeQ@^&PzXk*E$FAlRr zs)JW(Vr6Mg5wbZ^cm*rc4<8DFR&k85x8jnD-h@(>?v>{xH&wOTxUEt>k#&T0GUTd?k;ONAR3ZDUY$oj|-QKnC#A<7O=?^Q04^=uXOB^ z?yiwT-(||O5X3Mwzz`3M2_(u&Q6zDRvR`l)*A1mmcZ&(cVC8v!-@1g8Wg4N7$NZl1 zMN}Wpi=REl_`oHiasYsjtqlv6zA&x7VI&MKc+EC|S=y(jVXUZXrX;m{_?ul4@Qs|^Y-Z?j=XA2pmgy2(EP(1R?^2x+tI5k4+hA+F{3t&uw zQc;D4->kC=v50I;-RMqK2?~Kx%uR5*Go{?p3gV?}P}L`z1ciEHEo->d46lpSR${|z zs26IN%?%BWQeHhZO>EvwCwc^hJhYE&QVLb?Y!aoIm&~Xu#Pb!Xh;WU*5FCvixJs|$T4?)P&kFSQ>vY4{aSAXU4+ zIkAM*eUZxNGh87(RffJI6)iZ)z%7uF38>cP^v0DMNWg^)zzDi0gU$ks-owy~00ftz zp;|Gqmo|3|+X$cNC$u7O#9o6i!-6n%BJ*$$oRYNa>;O*tM9P?2DerP+$^%(A9hEGvGMiSf3 zeX!+m@S8}|}Mv5qa;aCQACcXL8{^iUD zv-Zg%`qMy? zE_RoLpYzF%#Sw@`U}NW^$~{rU?N0$Es&A*3t?*!bYkT&6sN@=1@0?L?Q->9V5w<|0 z2Q9d!l(2SFZBKTnc+!Pb$ax~TrueM+cZhrsx3s69HA2}q&~yjKp0o|vbO)JF1Bj}#yOJIfA^4KRL$U}R!N(HgK*{!#E?E9RL3@jtJ0JA*zXFfv%Z$fFpVx7II2 z7{j&4?QaQ~@a3v++H+hLu^tktjmt_6r^$=QQcN7SXq>k5oz~16QJ*FX#Hb*rn(z{h z1%c`{lrmbi5qAR}e4K_yo(FMOTjL+mq)Q%g>Z%J@BJ({?Z?T!{#y~DBhHdWQ|3#j) z%Qip{B}ELWmGqDq0P@B?iS(;&;{2IDj(KmQGRxztC4yws9shS3Ag*cU+|Vz3?WAmT z)Z`}At)h1lhUU7!PfOmm*0K75q*_CJYcq>;4Ip=|i|&WVlkkTp0vqEDLwIw?9TpUe zRTHSE)nuJ@iFc>wcLE#5bAj|XQiQ=kQZ)7-awX+)$bXzE2~R$1TmsCtDCjmS4;t(!C7^WxmseSq&W%$E6EA18kLJnf<>+0(wDUCnyx z#pU<=pu5{|-+kOoTLJ(r_1LqJ8BGqYdSTg5i+ul31HIt8D&%#w*7R|gxe}0BDd2Z4 z$1unts)5=UOsb`1?YcT%Evr?S=96;d7k# zBY$&gpU7jhz0%O#TE0iR-~iWynIgOQh@4~wUExy2hAI6HS#8(;AZ_9E4PgwrcDH&D z{AE-4A8j#|w&)*ZSl0p}3?%x(2~6zq&DYYB_?CFL@|E&keUXfYtI=~|`-ssy!q=oqEqSY7zaF;~@}j6o## z(d3v&nIgZ?)eD#ZMCOaum!ZFYJ{>z@Uk*+BtYWknB)ly?a`xeS-%oOl#&Q|4t^Omd zH6e}EL``o|_m{lzHBygr-JK* zpu(|4h-x-F7eoriqO#K#lx^Wu!R>b#=L@<*jF2u5bEP&T)Ma6_WNY#o^X+ANncvCa z%D-1>)pc!8$i}PU@s=Z;wj>v&Rf&w)XVzAeOMmW=jkm{{BBHB25>gHjqo&nK`yvE+lG5y;hUAR;YAt7}S;@`Zyk1MeJ*$e!2v)TEz*O z@+$dx6GP_yD(HEWsD5Ln$3GQhaxb&eVCmj0lRI7~^mN;>H7|hyv8H56a+u%D{W6Dt zs7ZO%N0nf3%XBy?w_?dJJSkUGq^~R7F4;TcT)HpvI6f*-;Ma&J^6w8TBZ8(+l4-x& zFBMxLiA}`ymy+#XuC*gn6S)_DVS431kuiFT&o7ZyV3I(`_p$ZU2ATTYv+c0$1jbo# zK<(cLJg53*zR51(44{Iy?Y|G4i`VDgw2C^#&*lP!%MywU{c|S7r|GQ9X!)Ci?aUqx zMcrF>RRm|Yf=eNyn83OjWWljIilZK*W~6Q#8;N?~v7ZN)o+z!hFQ3pY#y&k)euC-B zK>X1;8yyNS2Yjaz)YTx+0T^NfDt-i1+G9gdKQt&GF zTs>4$=+$5}DKW_54-Ko#-&Cl2+ffb|cmnc^j#{4flCsaq@a0^(&g64o4EEk2tYx(F zuH*5)%{Uju#1KD>(*r;xpCo`Um;p@`;qDW?e{RoLAJwd_js0FF6v zH|fCdEaJQY?qoSJWdgyLQ^3FcB-7y+?AZ`?<8HV34F)AN(|`+hA+N`E=J{_5T^HqU_|J*u){cyr>J~{rX_;F^}-IdR$b$ z9}F=H@C``pX=F=zfB#UZK+0*-ID2BT!uGpJdJpzFycAEOuzbn#BjKBt32AyT8+aEs zeV3Zv?rD9Fe(Bm495$?7z%k?S<(fMijCj3rWM50bp-`k4O+BFGJsfdik1cAu^Tf6v zNlNVX`fbV*E`7VA&^u~c8>}ARl?f^^?Htq*I0^UHwS*+L=T36|d0T~4y0rW@Wl8(u z%&PX}3U-VY=SLi~0KniiLbDVT@|L2Y58p|y#+fM;*v4%{_P!54SaR)sF)7+v_<#~> zSC$T55{t)Ha}6fmv`p+<5sUv!*l33a2zp=u+H><{JY&Dl@Sn_z+bGQx4o85VB?-D9 zVy2=aC?W6A$A&;+A#uH9qmnk^#k$M};&5rh7(`xcZd-IfeeUN`9+F&h%~9Z;8Ku*a zljPygqDxD**aQEiz@#^wpaw}pnvTcD<|&(tHkFa@SVc?9E5BR;*j<13ep4Zh5+L?fZ!uJ@54&8HD!Dk z3~1~Ng-*xp|04*zUgwHVXLUUDvcx_pphB695TU@CYAeASD`+fJpt0~tozuRp#z|1H zNW%a)Wtc_~u2=Nt*qGzHpuNC|eI$A=pAVSn`W;S|i*c>f5h4?m;%`e2Z*ETc6pn$a zpEKGK9-bQ?`9^H*9IrHz9T-5PdqIJ?Wb|C@$#Ju1=WrcjvUgAUr@Bgy|db1Ya*n9wmk z|7w##RCtZfeU2vUiFk@aJA}51-?pI_yfrgho)vbDt4f^UYma-(aJ7gvn_7MFe*XW> z=Jfsykitr}V2Vkl&Y$LdI2s>WR?PLz1~BhX1nO7(aq}KwpJJcU{5x5)3xd~a_4tvSJsjzfyd+T4;u?hMPe=?mAzQjUVSIBvjOZ1Q*Z zvq&gMK{HuWI<9ybI)#KGTe$i*Mpyd0mT<6keD-!OKvz9i413~fuq zi5@(+mrp<|3A6ZL=Al<;s|?u#CkfgHk!(R6X`ugtX0+{p!;aT4+u7)ePh)GuAc9?o zfVyi&<|ztvB0~=HSk7*L*-07Vx#Yd58Nw@fUNfMI19wgS@9V1#*OYARzkxs-Kq7wW z-3%`U)^Z|wQ=FKA$1VM%TO6C}{=|Y{PTr&t`KE_~JOF<6+BSZKdn1A`$Y-&(TZWRL zi|g$DAHTOAr@NHl%{vB}#$!Y$@`E2%j{UvFW{!P~;-=yH^Z!hU0NKWwg`|kTYl~1N z<2c;gLGR}tfF=I}r1s5RzgKA!QCQRw_H2c}F~xCR*R3%&g(JnPctBr6Y0|nl6E|t} z>KMP-YoW2^DWP%Ez5ejRfzFuWvLED!HxU>L2fLpeDg|+mpVH_S$3{$4V}ffz#PU_g z{%};OE?d!R1tqQ`YzbC{uu+Kv?J;kgPF0HpF#XP`=8W@hTQ%@hXD>b~Cf(0d<(io? zH{lYI4;$lolFWs&C5fTMs=ik$1=&x+$+Y7yKNKRVhB=H00Ky{*M9&vA=v;=U_0gNj zomJQhN730cosGVSlb@fDmU8vm5*Lgv*tKauLDw`xZPq0*UyT}TR17N|0bw2GeiC!5 z4DN-cTIJ;EvO;|s;Iw1pw$S4pzi@g|i|;V_``cU0(#`kAHGL7yTHT)y#J#?NAJ@uG ze=47ge57~jcuTW81hHA@lf3o1^9Ij8e|Ft$d%`_reT~IJdzBSW^drM_<@rQ?<4S~= z2gq@$oOj(XJc`XiNMAVbQ38?o#byn|*7grJLf{)MyR0b@9&{k8t!Xmu%-3W%((8S7 zOqG1=@7E%k)ZP;tcZ_ZtF`EAHnH7X_anM(j1N}2R(y%VXbw&#^SBA_7WbM{7BLVj9 z&}iT7!u=I3WSi+^>U8p!XsO55>v1USe&qcYxXt;lj#&*|5%UNXYo^T^SNGRE4%IJ= zU{QW~7{mDEu0T@yQkH`;H`$|8ux(U9Iq~*~6fhk&+o?G*D`rNb2w`$#${caz=d4_{ z@&&WIq`LC^opw@db|)*y=?$`qZ%Fn&RPpj0%^}DO^}0puXAiXGoexRQ^$jKi96%eq z?$rQN`MI?yBlM*W0(Rn?P$Jtf6u1!y)R7cvrjh+aXgqY0BGPOjDU1)aGE4o<#keoC zm~C=2yH$2^45c6)5IfSnoLGXC;p3g;oq<@Q4a9AvG{?`krJjwKE4|A0o9z~@l=?YP z%!Xqlg_U+)>Ot%!hyY~n^V`sa53g9$SySssV*04P=X%JDH+GOt^bgYTH6k`oPCT^f1wskJfgPz`FvvX!Bci<*i?)ioEwB4ap$RcI}@n|Wv`j16yDZWD*;276l!GIUQKU&KmCj=d!dL+eU3loDt zRFjiD_jMZjSWvnwG8d_g9>n;}?Dux)Leb@7*uEkn_{edfOZ2QkiQKvrbBf{JZC! zXF;NsP*5H9xSbu11EsvO9VI|Ye4H z0rIC72=cCLYoW6MmXvN@StpqGb3*JM^PM*^K2SM-mb1a>xy@gMI2EhJZ!8mksE>m- zOO*WPJ23@e}0Ss>}amd zJ@^<6nMf1aExJnVsn(wJ%917yJ?H^_dKbgbxo_0Vv@#8+Uhf}X+lfXChjqWqD=prf z`3m>i{2#d$YJ`?&vNb{`bz6hgf_+B_g`#|)WR}d- zZZCRh{X3}Ygah6kANTO5Z@jf@&`;YwBzRIY4g92^`t%a7US_H#{ax##j-3S=se<6o zseyGe(qy_4s<1>P*j%9O&?dHIO-7w=& z1-9)GidTQ)*=|h4^#8zmq^5IISJt{pPG08GZKEU!aKKBYV^}#jdOKMN{JJ$FfAF!iwz5uHwCRhNuh8u zG{s~3sRMgomV$DHyhe#h=)Bb}sp~jZvhpBmNNQG&dh9->^TeXINaG@DAu&0aZ3>O5 z{>aZ>+2G(*C%~)0sH1t7Bvw?or5G$2tUD0!p-;MY7kI+pQX&kWB8*alj48Qq$ej__ zGsJRY9Ll+{wGt8KrmCKRX^IV8X4$4cac~(~{Z+_MBhuRcMh)7e+N6|W4AW;-YW-NK za|x45t^t$sUMQHuA1}J5W%Jfr)Myg7m8eE6>Y7;#6!&f_vY1Cy^|B*dh_p>Vo`Ii4 z!s>Cd(;|cCbGYNO>)a+-&TeEL3>6pnvlYmi?}YW&yc^y#vk+6Q(9|{_3vD#;e6+2; zzQ5jsX+H$Z@X9KU72h~)d41Nk^4>7CTqc~u3QCG_{c7FJk>EWg=Tu!c$fRJ%Dg=%z zIlV8Y`b+D?vMf5J>kQueLU%1^LA5=gxgSWR8tTvwy!bI`6E7YW(?EIwSKDH$>6VP; zzUFOHUVZH?F)2@&h4t1RbP@JniHqlNgq9Y&!$|hiSd_u(4;=zv7`lM4F)XL? zzj`m+V{jh_iFh>U$GEP2cWg8+h#@6AgiR6b0~ieb?(?EPp`SzI(0cdR*)x+lo6WUz zoq3S(<`eMNzGdQ~qyhRtOCLnwrvn|fPa~+Mg+K^Eo)Z3gk_78@- z$hHiD!S5;XcY&K!#KOHVSTjZEM=m-$-;Y7S?-{mZ(nRFnnketN@K@`zrQ>o8cxA$$ zdFUo16{3ZiVk|~N+JI?9r-;LG=~iK`6~?T>s}QO6+ek8@9_F2u{hJ-!->oN>$s@-IbUsQ3@DTj~CQ3$|SSrQBUd67K3A;dr)`{BXvuS7yscczzi*! z>M6pRLMoKZ<751jkWy-- zs*#NIA9hi8H<#R8i)uF46@6IIVyLKE*1*?`wQq_*FZ47+DP~v~g*N(aGaFoY%;a`R zU-b}OzYE2p6XuX@J~AK=MCDtw{{21uI7ZUPEfa|&-zl~_$#o^r#JyZ-Y-bfh)0FgoFia;wwYHx1ZRizX3@yY8lKyEhmtkPyOpNNbRws!EnQevP9mZ-a~0Y%;q z-%*fOH5YbinZO7oU6xFFO8Lo|pz(JFnEm3tqu`(6#EPjl#jEF^)Q7*A#4DZ4Brvwa zN{W>}u^hHh0RETNTf0%*H<%vZ5{JF6*1fv&R}VQyaMGghF2;^D0QbgXyfcqv!*nkI z^i0h>(%Lg5@(uYg7^<>(S?YWPu1?)c{VT9f21l{r3rLU7U(-y6@W<$l5g(hkF@A(TG5-b_ddi6x%D<(2D=cUcG{<^AU zZ?R#x<(mrdWqa4xF_AmkL)zynj?_n)V43PeH&hiwkk_XUg_FaZg6U|fR%s~R_a45x zAKQEL81Km|DtJ`en8uJuyn^Ifvpuv&x}0 ztri%&j*n(I#?uZ3zi{ z496*mWXP3c#EVQi&KnZcZub&M#RI!>dKN%CgoL6WZk#Pb+3V=zFHMG7u+JUDW`{gA22l^TBnMQ)$pE zh&8T7(JJO@D@9cq(W5wsJDl*rRBJ8lR$7OzP!VahXDSeNor9;DUl|ds4yt?Lx--#D zQ!jE%@3JbU_MnvLD+Ddc!r4p&l3WpE=0)0e_tu)p{{+8D8|WS8h}T-zx_?%QjZ9Xf zrr1ujUWua&E%Ax?&`ULsE+^(}a^zLVbWf#g)>jO;{yfvxD@Hv%VN9NR<7<%BN_zB; z!_>&{w)GB~%@<0|C~8=bS^L!;bC1z6oHJx=AANjMV_aF;BzwBEpD$TVd?qmkHcJSU z_4)0>9NV-eb6f20O)*2ZC1j~3)P;6}y1X1w?<5^a{N0;EMU)QP*t4IS-=if}$q_Ph zP5e?I(SWt)xV6D$P9V1Kmp)JSy%NQr#?^#|>Y!{PUQO2n#6+f}^uW|o9*Eeo9HHZ~ z>|d{x04&m!*gTivz3->hq8L$56F=+_IvFyKO?7hOr*3`EO=*s;bEd(=>~#o*q^;(% z{2?kVKecsh&HuzFutj#dnZR&}BdM3XNfIbe5lBXInUOk^C2ehSJjkxeoATCG6R%f< zQZh$0r{Cw~Sl=W2RB<&z3+K!5Nlt<-at69UEkdN7bgw0|FWC@}a^1@|BK2v{1%CHT zpkITwQ$D`k#V6k_!F)YkA)YUEf%9a1b(GJbSr;CQ<~A}W^kJS!X3D>fk&OSI3M>Rc z4bi$TfmKLEp(?DRBzq|B`et|n6Onyj;xvo%*rVCKlc6zfl&BbsOt;~rS(s@9RZZ@NMpM~RMsRT{z=h%}*=9_`_tmHxrL1ZPPBP-JRQF!Y6mKCF zsm_modBnSD!F`;sFlCgmzxekxC8LXr2pmCrW1byT%u(EP0DfR-MAII$E+}FfKhYxD z2YsEZBIlk<8Meb5;Y~F<+to-FQG2W|n0GS}yMuK~#gCb)$7T0qw2xKm4nMY2SJ!e3 zM5S9L0qI+8Ont$Y*W0C|VmjOxQroAz@Kr>OGiEWAQW+!<(YF}TN4cA3rgMZo>}|qq z?f*g}Nb35&)>Hb|l)F0seLUt9Weyp%93yxvY}6(6gl-phIL`HL&$Lv+4(+@(m??Jg z&>6F9E*4C_E=i(MTNz7L=ovpa2ME_tH(FRuKgv7?UIaF0Ep}Ed%G_3lK zzf4JY4URv2Me&?l2*loRG1Z<8>h>Q!_D|PdgCZ(1w*k7cl0Hv<~?B>ne`PK&sLct*EVxN z$12YBmLSVneO3I>GIeLgb;Z9*xLW&PO}mR&gNL{476$L84FuR7n-&)YgzKH{IZrSp zE#-jshv7rJA6LH%?kEUFHa35mJUs1&Uk&H$59MQC@pONP)@cv^z26Ss>Ooo0{wgbr zuPpCbIZ)ljyQx}_S6{)-TE9t~{%F05);u2O`S_y_@{yU6@ra$=vUB(taPSTBujpaX zt}Gyl5>USBSe#u6{D#w$W9aw%eptcF_on;q?c(h0;_>j1^6koz`*VHw?RsY6HtV?C zadp~uz540N|G*R>cgvvjWhcPp_Vs@MbaC1F{YtrZYRkY7`%1(JlVuk02E<}GaI_vUnXH|$G zb^8Og!{mtSF2MBArs0$6J3rZ3Wk1U@aPqV4*{|cCym6Z}dRY2%=QeS-WbhmvTZVo=LZXcj9*D7@$%+yVM>@{@|Sxg^QE?(EJPkO{}e&X4G z{m)O}oXFO3P4>Dw)u@iD9m5(th%AV5`HVM@i3VPk_~JonaV(wd2V3*uFr8f1mp?~` zf7K0zT+)$x0{J>e14jes!||vEU8?-chf!ggt+o1JZ0lb8k4!v9yqC?pG|^4{9={ui zKegZFQeIn|(cvyfejmzkf^T?YiVbSx;-srhvO%JJ(VwF?aF!!irZ`4^57r!9aVJyb z^cn3eDN}rB2q%NIfF}6$4ig~xJbn7&6v6iTyYUSD{u~PX#G5>};Gc)xzsX%z4RI*MSTi<{x z)ra%y7g4e}=B=y=1xyGdl_a5M$5~!YC#>g$0wzy?@|Lh3dnWaOx3KIg9UV8Ir61sK zTHRhM2woZHoM2{kGm^*(51OKw6owMi$l)??q=E}0m(0Jg*10JdM$EeT3+BklLOb!8 zL39YXHx4F5l~){jJ;= zwyHpowG~|6=;K{(d*#nl8X~tsw_K<9Oqh)~4;`Oab!1B^+Dz(tX;>MK_V&w433LtK z8TS+skoxobhti8Zp0UV?{y+vtVAt_e8;NLXRGQwFn)V2lwuZA_xkVG5N=1nH|D18-kmL^ zXRRkBM*pI(Dg2%8&8I1etgGzshpkzt%T;esbo`B9SAyc(U3Vk)o>b?E>yy|lvDzhF zDw7h1U?EDFMDMiT@;1tFlqrdAGeAKr5gZ!_vEqU{Fy~Ds+&PxMdjvKq_;j`*=M>1b zlq+*dBY)ZTF}Ny*DFl4`Ry**F6v*!!y}S)tapQoC6GaD+~J)i)|hvreiTDhCdX;Y52v0kF!f!e>^v$s zb)oC`KzXV}5Ts1_Cv$izKTPP8M4>LYYQ(CRp*B!Llgatv{5H!AI&v>BHnLi%-$eTA zPEb}qxJnNsRg1a->(m6B1A|1<4YOJ(#HG6**V{!XA`k^TD*oM53wjWC>@>BH$%bC9W4W{kKt$>{(2aA?>Yq=Nq&O|b|Zzl4y-I3 zn^ZkaJKmmu4ERfFsO~d&)nkA1_V>%y^IG7o`}q^We#iCeiE}$ZJvJNv`4Q&KGD6}m zs_IuH@+LwfY$0F9qikZ&E!Zr{((^5CpmgP=nO zTPm;Lq_JSLfHuX!{iPIE7-&~7wA{Y=J}?7ZD42vpB&0(sCQv=v!UI@l?k?3GKxR*L91 z2uiwq7AV;y(RMJo&NUw*_6#_S{e^^jrfLV z?o<7==k+||PAL$Yss2Br-T_8*XlolD+qUhQGq!Epwr$%wW7{}m+qP}n-`soOKY!9R zD`}c;bv51V!3Km7!`QSZmld{wvX36n6KENIKvQ(vI&J;BeTu&gAz%$s9W`^G9}yuS zI-$JgwCgGMYwo*buP(%;L~o9|N9(qMNpI`kxcc+*xN~Ak1Z-y2q!_nBfX)|c%{1$c zT3|S*QGZn?V5zs{f|-UkJi1PSx+&=#))6@*U9IP@>?!F2jBODfH!3S zAOI+Na^5Ew=H3uNa^c&F*R@v(d9IW@Z#YVK1#+!ZzY<!hjaN@5>-O*`;`xCQKLgM0=ERy(>sDfNR%_h-Q$8LAnQUSv~R~+_62dgZ}{-U9J;iW|t?X zOmN^P=r0dTbMd`S`iF2u7%41;lMm7LT$HkcP>2{I2M+ibU?Ci`atw=_jN;Ozj0?Ka zXGRjuE4Z%4z{f0+%cO=3^mM1aLID(mVAU(ZToN0PQG#T;#feQ_5xVs;fZN zSQ}anqs&GD>ioeJSpIz4aF~LKhs7f(*&ahg;=nNXfPbm#M*oKGEmR$)iX}Y(m2!Om zRc1K*sTuj~($sz}52KMD}ckgr*{_uH2eeAVQK_mONV{uB?$j5jLXI7@bZ+-0qY;*PMSo~{Iu zKE`}%JDA$XMnQv*-8o(FZ)yam`Ma&5HPzHnBT|^_EOiA6$1TA4NHdqY#YAv2AkFzJ zpyfUm9ypZ=fRXm^#Z~(!6PMu$G{*8 z#=2YOu7-RmhbEO(^#!0nb*Y0)m-d1bsM8+tRaI33kLD_++JcLn_iHv1IGz4`edWHj z`NbK{WPtNWsW2>TxYV>zp&2eL+p}fQz7m@oN*0?zXRz4<1$go;1~bSwM#mUsI!cey zkBFX+B$N&rqcpg*04Fx}~vZ)iFivZeae z0q9K3ElH}b_-(&hueBo^`RsK)DIXW25$ht)_#Ec6Zgk8z#r}lNz~N?lKbSSsgNEka>1{`E7X`Me_hCu3N1vb=G6Z2e||NTIRc zI%A2qJMVd>QtlqM3@fpp@XmcJcAQZhVH~koMq|=w-9HTi&41}KYJrE77b6R9QJet% zAZ`9q8$7s#tDs0*G*ebC3R*6mN=NigZFY^?WlkffxlYCcEjmf-GKbo#tH;!E8ENdx z$F_eSDJaY8)O+K!K?3`EwT=TKkIAa}(^ji-Ya0d#8+8pWw6fr6T=Iy%%z4L|J@(l` zSsS6wSqg$3saL|$svLm{FI8G}L2$rOBkiM*L+R0@Pb5RwXx3z59}ggeb{n=X^L-U{ z0X9(ACy%Zs8Xb3Hc7{u!aqlWZ4^;a}giThi*1bKuvPm~1dI#-L-Mq-LTMTIKL>GL^R+$|rOTe`^ z)pLRw2ocXWZ^*&ssXR8Y`B3d6(@H`99uiP z>tLP2F;cmNbXXAZzquvyZZKeMS#t%T*@Xyk~Bx z9=HDNIv%3%*Ka7w^i@=%mQM4006Vz9rws@t!36`^o8`bQio}Z1<3^ok-v8|B;&|+* z1U|_{CD8s=2#M5vv5z5VnNlG)+T&LfjyXrB+1)~XMZIq~OL~v2INdXH@TI4Pr`Y|Z z2IL)q_>sw#8aAif@HHoN9Zb#$Z6!XB-or)$klvSL*WlO@cPR*=PA{_8vNOp=3M~ zQwP4fN*#^+3}oPRN+3m0lKk&+t5i=Bg+rz>xfi1<3{N_HQ1No+z1W?JWFGR*=5%|U z-!!d$MqShFJn1L-Awgd@>-orKb3_)g;7JKh5Q!iXKm_{fS=0A`bW_u7EEN!J#+t*K zQ5tu##BKNTB>YW`A`ZW>%vTWOL5!vbMOkesL}y1Y`nv(4^-2KcP-HkV+v4UOS8sRy z)gQ5-JE}rQ7S&qel){`Kx)iY}Vp#m@KVM72mG(EXH`e^_H%wE%|lSNl`vQ4B5 zDZi;qE*&!#3FD8{dje zwDWFiG&=Q&XvHAzKU11PvVqP-3Dhw|vmD-k_6>z5Iu!^A--7 zu=bz~4wz?lu*-xW2ViC$17Rc(Ri{Dg8XrTb&nCeP-1cY$q`_X{Md(#9A}f~o*oZQ$ zoBb=-0_kCP|E+Z^LVzDhxSK%CE5T$qfhZ-O22U3OC&gPQkAJ~6?7vJ;kQf{V2lMZ-M|4f2Ivd{gQ&tCbDYr?p-)%Wc!4-Y;;5fktTz}Sk|ct^AY&w>*GR@{ zHrz{e@kA`TifnQ!Q!ef@KqC+2K?ffK58525-PANNy2@Z7KU@^d{92k4%-qX;><25C z>qdsFnq_+ojRDtaNUZuR1y2B|^`#MkWM7`__q@03yucu0w-4C-yAL3I*RD$9FfI!^ zU68)pS9jq1k1~)sX1%nj{5&J)FRnlD@4f)L8EkBjU2eBmqIEvc#@6tHkPvsvHBr4| zZlK(J5ClPAFwcKhXY~E#R&#maFCTuj+Kl<4M@suK@VmiLg#iq7US+CSW6n`4qKUbn z*u3qb%apdx@}?X02)!4NyA2;XN-R5bFr$j64zHW=SBqOqd{{NK+@a%OkGMsaFZPuk1sR5_fj*MZ5p4Qq4~D~rtcz?>*hL!tDG4z!3Hz@Z20jAeupZ0usAEsC zz-^-K<3QlYVsSx&Mt%c4pjc?&GJF9P{Ty zYU}5OGVK$e+N&(kpXY9#c$_#MIC(lP?}Pn3)vMG)$&Xjo|MH)&s}^5JHNMQF!-|(r zKKXn6PopsY&z3O$N6`tvJuv4Sj+mprdnMwi5fSgL6xGL)gJpO8SA*}YVWi1dp52Y- zR?F2eE$K(z?O->CCqpzIiWR%X)SmaxN(TG~Qt~M3Fmh<;cK}g;#G>*-(isNCLZTiK z*QFe2`AL*R*l*=dTx#Y8VLyT8{yskUhENuCCb=myo5Q+7%8zpmz3D8W_0Ewi#XDRg z=jC%{ZmRG-*E3rrX3pqU<*8?W%%Tlv?q@rBLgTw7ZT<(TG;6VsGYQXX8D2svC<}O)JNBZmcRQDd%AHdw`*|K1*lYn&k$D9hP6gUBev!i5s$T{zap>N`)&g71A z&S;W*;wg|ZQBNRt`JAn}ayTLU)8CFL;B1Y8>LMAVkN==o>g3f7h2?WJu7azom%HoS zDtb|9YrL3DV=u1w=a*LtxkKIr5%jrn2}3ZB6UGd(i026qjvlJm-YZmC&f=htq@O)y z;GmA|=b2yTH>J8@)Xuh(hpTeYlN(1Pexjm)g-cV6nt{I(d*rbISuy6wraSp1AiR>G z4ifG>7NWxhR(0K9K^cAwBriCV!Bb~vi-M9 z(@W{9X=JG^>kbCjR2~V83G`FHM#z7Ctp6)(Rk1_Ci|uqt)249&*WSoxgJ=cueNvT< zKzTAQ7!SOeY)%VkG#D|V&cE5!0gJ6U>lN#QTTsqVul}?G@vrl%j3`!eb_pBnsp}N4 z=Gb2EvNfwG>cN#KcWAd^B7<(q_^LG7^OB%yTUau>C0A7!3kOmufDAj$)o32h&~1lb z@dlLRsOSgqfX%;kSQBrtg@0hw4OC_1{*HM@K`2eQs*;Ky`yj%y(Ngo|22qi&`D-;g zA?s?&vgxSfdSVnf3jU|iE;}vtXCj?9o6hY$Zi~`+^Z zqT#OGjlZA-bkya_R>s>ffXl-svZTo+zPGDT9;Q`xr_w`cX1GN`{ee0sQQBJb1GGo$ z;`NP7ie{8FASw86)~S@bgAsU(TLVK)xLGmr^UOmwrZMA5Mvq-`%BmCcz}y1ONlawX3zf(11O#n|}7!R?|dd$=1J~ z4VV6?qrKhz>S1EcSm^Y7u6EU!qO1g|VVXyz&0<1cU1P1Y?wejQ5vlf3I;zun;>9g| zuoB<}qi~6Q$r`OAd>h8grRutBf2;@cBO3MAVSLR4W4S>#&h>7qWDmb8D_E$H! zU@u)2i}k#kxIx{LDFsHnq8z7rx~tXo2(4nz@keE|h>6(Iw_{6@9vmjGi}|ZT3aP=Q z!;;3=+ttrKS{K`7pr+@Y(LXKDigejIpuhQPBK_x1=J>~_{4;Jn8vKp-wyC$A|Jnu^ zO>7LKBg#X5IRpPh7gL2*s7hypL_l7o(RCF=y}i}lDLB{Uox5;G@9ZIqmwuGQT`-sQ z-8;qu0a)_YresjL-@Pn^;(*kpn0LB$%|7W3&XOO5xzkQ8SAq z%4GCB+=pNlofL6NgNcu-;)1w|IPnbpA_g$ecVF}2M26O* zC>H#*hrcug>U~Irp%Ks9i@=kdRUM=y19>SY)f~~|8zign{pN=0C{((oC6Jt}?W|w>V zB!9GpH%mI8)0vKijvzEBLNQaL_Ubv66@6xh^;M47yv-+W?!%!ZC zAJD<-%)`xw*FfX?)yd+!L|7dq&lHd1W!({MYD;=~+72Z{6Te#91(HU*eUZ;1IXMcC zyM2+b1t|)9v9RxsPoCxu!?3misU6dUsv6XB{WEOYz`Bb^xb;`7ZBbW8gFeyIEUwGp z2|5@8UF1eUjv2)_?98D%Tv;04?*=hmYJuiu7XzAA-<}(Ih{y(S-Umc(I7FlKkbKfw zgvrMOk^|pr7wbrckT2-@4jHz5|0$w&r5$yh*~8;8dl$s%0~uF<5u0%$iyFF&s3&3) z8g2kU165a!L^{i`3A6lNVk;k@^vPm6ju@4&Q%Y{1p5AsZcRX7!sFuL$2cGW50}#56 zX}bkxj+p*T(Ncc+)x%TcUo`u!DP`zUkLOVPD+GueWfMDL2@HaX{P1x&7+4vOFboPG zca;*WKUKqm5iH>fXW_3dK%NLp=M^JA?{?pW58AbQ(qNPB!C!k8YtU}|R%{GlKGnA= zsz}q8yUZik6r6y**S|b86_XT1`(miOmYR$yn1>Fqv8SID!jq%!*ti0?HmtE-5PBOO z5IuDQ-tltixBE6Jt?Y61$U4?Nnh(qsNX01?%DpovmpPFs(nTkXe3MrO+7mCq61$L$yf1v%3g7l;63cQ|dZX zJ@iW%qtZvR#XRq44ijfAAE8!VQXt*`>X@Cvv`_cCX4j96Q*;6-Y55%GFeRtsdQLmZ zXnRxQm{k$cJ}Z*;^&RqWIB^Cc5FZ(RDVof8lg;#J_-#!7o3Lm7LF$L`8BAxg;;Ny~ zoS1QFl77;>9$$RSj%^V?U#kJ+i+Vpvtq8&UhV9@OSl!)rlLS2NN9O$V)S+Eok9cmm zcAaD(4$9`%v3{Z&HIanU%RxMCib$PWNBFQFtV{FPqS>(Oq;we592ph0L}x08|9Bsj zapjD5@vjxKX>VeVS>$n8TnxPY&)K8(OFc)3-;YJ037oQ1acdIU0R~vNe_8R2Qdb=W z*^0v)5W`e}iSbk!5q@YGETdNG#A1qL`Bs(OV^`vnPNnKfrssk6y7hN5Az;r`YEHJC z9?^=m@9W~HyD7%W!pezD4UFi=6qi!19*5mlz&E@|QUiRmC~WSUZsi%DV~#uf^Ij2+LrHdCfOyG?ajBS% zu)-q;)22`1O|&q0L1kq{hlY&l2FA^3=+uj%8pdz_O!RvU?h(A_2~*8)&^t6u-HVGR zGHE9of}=dY)cU$z0(>OHL@=02m!~vm@PlJAEjxkVKtME--ul4vZdYGfJ6LSANo@Hg-v*9Ty$3 zmYv)fyx9p^&K%74j`UFq$zbYn<(OT2sDLz^#>vUR6_-OXKhae!`t9sr0DuHJs_oqF z{p>hjz>=830bLoNSlYc+eC^ljl6=rpUV zcGtYWIiKzjlEV=lUGQ!b0x`IL{)T!Ne+~wK`|sbo0xeV=UEOnp3z)PIP;HEmxrrh8Y#R8v;&m z_)4fnnD>S#)MrxnjtfQ*xxbuKK)SF)?5B-V0{I;P3y$Kjy|{CJ$U-l!kV;sqHtJt0 zDSg3@bvK(*etWRPpSM)j0Jdauq(?@6DL=LzArB5v^7s%n2Zh|_N7g_D&S2|gGZcGn z_%vig#zc1_hM6}aNRI=)kEC7`pe(TKBEC*X%!~w^sQ}L~V@FYkX@V07>3FBSq^uU= zuxJU8q7U56Nf8h^FW*w?={FRx;{n4f-H(CW^{YVOaRMqi(XY8XvREi0G<`7MnyCi7 z5G4XATqfXq9|oDws(A9{hKif+g7as7W*`zUMO*bz_&J)OJ6fn+iYlMtu z3vG(x0Y2&Dyc!@!0S39|&LqT4HNk09FRyus*+m1Ed4k^P0x)lyk%abBp=eKB(&SAx z6*jucB+4;b77rS~c?k^{=QFnOwSw?cst`vUmN{#%4-Oc>HM^6Bp|`Fuc2DOr>1cDK zxu~j6I$}Jfr3@G+Kv`zpeWcY<_|HZdCR^IKJWI#caHd-i-VrB#8A3fb(MmVzJr%Oj ztmVhouCxEOkNN+xjK6=nCcqd4M@%In%QOl{O$z5n-BGJk9%QadDwM zM`XtKKmnPTYzD8K926j3dGSatpZ^5Hs{rH*F9CV!&}Bf({YO!umYYo*{$p; z{{;9(E(Ncw?k-rt&iTSwFZmjCE%t5QG@`*0#9llw_#@J=G5@&QVCq4n*QW&n`Ql2o zQM39{_yI=K>LuL)|I!3US4Nax9~P7<+f-NzX8Ww$C@?9OAR z!hX{w!IaUlHa4Sstyjf2Khg-l!qk~+8_Bu3^=I9M7H*@J1eTj}!@mcDktDM{oMh3t zO$s4~fg@Eu=9+Szij|xN3auOaLHqb-IACU-zuCvJQ{(2`s2nKN{ye%~45?zUr5a9c z>G^{rqo>aL08(b-e<~S~&pZd|isxO@!4dH~zz)I>^o2nos zV9W+e;8f(DlpS81~z=I4KXQ$>yd&VCt zT+Q+5j?gaEESYaAo^ehE;mGBLINc7QJ|d&k1qXCo;GO3UMO*NTAH<$d z0t&)AaxY^L9761c6Y7#gA;$CB4kWTF(oj{&b5mc6@R24<)-$-5Z##Dms^Ol;Ky-i4 z+Epnl=c*QH2`_emxTxn7EczoPtKXcO6fwd`P6AM&4V)qyki};D2pOdB&%=s=BVN3q z%-#r8WtKJFLNj`>=4Oo|t%VOA2oUix9fo5;E>**-wWlZ3myky5U>a$Tucjbp%v&f0 zL@q59@2B-2P!vQ1x)h{OBXRAw|AmDicOLfF#h+hUTU4drgUXiRvzLeo!kq{Vo$}FPD zainx^Z;dF`hQfTb)1PDdggRQ-N&d8K#;ArHTuyt^dMZ9M*fFEN5I(uJbMXu+>URGlN-o3Hx80_%+Wc<7Z^&(2m??&7 zMrZ`6rychM8;K+SdZ~dfh6BD6d89C0?xuxffb*O@F@llCl`tNVMW05UO56}}OE50f zg5;6xfW~zE_PB-)OtF>Y<$UO#Pm&B;X{r>HkgVQ**22hfl)p$st8JSI2-qmrk;fCx$I1R8$e^CJ1H?b9UL&>0Am%HG)d2w0wJ-JH~$#&i`$_}Rzy*)E4Q^t z4?m>jBa7dCHVnfTT2w?+c(Z6@p#(x{%|K8Q8~9IODgRZbP*y!1eAm_}hA&MrFjYWh zX__;2tqi|>rZ`ni`?aeYHBMdMg=+?7$jgq z0lPOWZ735;7arLCVkX2^Kvzm$EgTAt95%z0nqKM7r+%n=Uw*PdkwdZv%Tu!EEzMR??GYk&z8AqEDTsg5Dt##ySItE88&R5NE0 zAX&33l+%d%xw}4Nl~ByL)f@JYM(!Ydh`s7KnOs6%zD#_;S5@2VK@*a6ESlV(;qfr zW7BBJoC8*o@lBLje~7az%W_88!$=%J#CcZ|LH`!|SbF*{Dj zj;I-akKE~Si{XEtO$Mqu(xe8}+D{&*mYlBQ{I*L{17K!Ruf9+UpH7!PnWS|s+eg_p ztSkpp)~qX%y|fU~a{+E`YFGgzn~stjqneyWr& zC;QQuCUcA8?tgkb>J_d9$j;fYIozo0+}9X$FI8kOfYOz$dWYIAL7~I7sBOrD1bCPL zKAvxxASx_TccLvxDDsfz=Bpxqx<16@PkBnnBsZtbiybbUMr&FGk81BJP(?B^FctRB|+Eb~QOzHeg&j4nzG?s)I6_K9&kp2$RG7cQuQb zg(E7#FFFK#@vmt1zp(?s^{Vxg@;8yKioaeia)-R7SHWL>sji=ci6U4UUsgkT1<<&g ziKOnp_l||GXJHvwh(3{NXR8rEPG-_cpLpvOtxw_lXK%mlsef?H?Icep(W#V1$%68I zAkaJ{<6}}{RWhM@)Xz+-knGAxKGt&su`=yZD$5b0W94h&sbVIlYB^(^C;4qS>CPBn6@NYD#%e> zAFR%cl#k+@2Vx9!>4v8u-dz~a6WW5VLB?1ITf&BWCe0{IJ^87nO&)Jf8Ii+#u8bcB zy|1`GK0*=AQB-?{n@rpsSWGXhqkk|*aREJ^->R>v%bH0!=N)_n>{82@pWD9$R{D;( zwPb3QaV@Q!tGIvlGM1*o&a)Zp_g$-!;az9ztYG>*PcZm2{V&X1aU|o|D!EoGW|5j2 zj9$3D&a!g+ePi45&lz0oSNd0BWN zOSl}qks-T2x)E6QIlAC&AdbturV-9Q+*FC?0KY#3SyFJ(g(h+4om8!hwP8+H=N?y@ z7SOl89;}lJ$u)ZIf&a;cAoqMwV9}i{J~4juCuH@bNGjFNR=&5uoXtInIx)6T>sa&d z!YO8`{jMWTw!?x5(-Qo^=gyi6L2^{K>x^7~Iu&t;E~i2dW96F14gdF0BhH62Uno_~ z@0!nD(T_+adj7G+cdcR{>xG)OBL)dQuI~d6(6g>XhZQkdxUK-eI~U^EL{V z%M)$a<~`Q3>Y5@Jdbx%xe@lL3teA5!iDC_$HEaEG41k1sB~QXs zaV<6<9pZgSsk(P!A!aLxL!z_9iy8qE+)%7~lZ7$}18_>6ur%Su4M){KMWna}pMU-tiwAiqd zM$VBpbxCSx$GKVen>*l~*A7=mRYe2XxlSFqEP~*-HpZfsP!iMan6rw{AcFM-2H)UJ z$~!iqTO=iazJKsq?IWYC%JGwHMc$E~RckzoCIt6B&tj^GpCy_yH6>PZEWKvgE`JT6 z_oOuyf~!Vt>!fr{&XMcQxqI+@eC%fU(RI1`n3Cn|JOom9qX-vI!>Phg)(^Wee>&0m zk#Hli%;L@qDO#Z*MP4wTa{ASL&WCO1a6o$1EU-~&5qgj5I5f}TvVD7z1soH|*)pJN zPgS`TP5W(w{7i%gjz=ocokHK8W_Ws2e-(ZO880URmM3^Cf&Ca0XKnHvF5p=elAuz8 zR0{lr+;!HgcXlt>-jFi37r=7Wwk)l_hweuf;7ux^((A225rlHD>L?BD*7iqD=CB}` zhHjCZHfkANoI^im&L@KKB_T3sDby+;H4NSCq|px^G^rfs!p@|1v+aWCwHl^D_#gh1 zeJ3_m5d7_(A`926M(7>jAs}8kHFRz&&%Yg$Sv`~4h+`@9my4Fb%?w5>lTw10-oy!n zMAY^$!C}=fPh6d5Xp0RB@!FO|hAsE7;-!os^w##*jBWunzb1P-ct_ww?P?8^)5lLh z_U~z^x54LgOF#|uok*KcysFi2UpMrg=(O0u(|t!?w2L22-%k?Xkbu)(-VL-^^tfm* zMUz>hCm7aY^krc#Zl^-fQxC>bXadaTo31HIx0_uzip;6B>K3iT@acTp;ZZZ$Mt(={ z$$~>d(927U!*v;kc5yL2J9v7lW1kIPT2csZ9v zW%z|$)VKLsSMMQmF6|!Dm00PkI-6GE>~ZIk9$_)lUyoWQfk`i!S&ZU>>i9xKm~vNq zO=MfC$TTyZ)n#H^iQ1WHU(;(!(F|KiX3<89uscnUzdYa+?)vhlBSi%p7T=W>E2Lw3 z*_@lx$$2d$ybcOs#;dKq-;*_Vw(ft0{M^D4(F26i><_BP(7kX8`9gRxmnN|x(A}aS zqw2W?-)a@^tOP-wiSsJDO%F=GX9}bl-U^mj_9@Y4NL!+IiMTZpwBZcyAbv_GYgKW#XbFGuiUP%vJQf*g*8O&ppKIt;wH(g7*(R?^MktQC~ zo{axOdAxbEqrL)(m*|z82gPA`3U`(^0C{Aqr{E7WnN$M-qk3D3na^lgie;c{BA zQcSVNXV}|-epLFn9c@o-6qj`|$|SXNM{X9ACRl|zz8X?*0m#4+qT`cM8Qr62FleqU zfqbX5!Yu+>D1{yLy=lWEGs!~(*?~9!qw|p?ujCXUGN#ia83<)fm9Rx8pj@lOQ*@J^ zAyqcaV|ZcEc2FkF2Sn9_cx3ZulGhKtZWf0^NLB48a}iHso=jm>W)DAX)ss2mJ}ysH z6Oh{dE2w&CTxp31twq0OFU=&=X4rklm3(O=i1%c9Z}JrWvgpF}ne#}RE@+xd?xLUT z`0ghowPh!U3#6Kkar9J`B2#KKb|6^Ygpzot_uOK8-xRtLVhlM}HI!beoZ~-ybcr&M z#H(%fJQ5Ol3*Sdz+P-5HJ!PScW%4XaAdbS+Jv28AMe&eVtwF)j`5c0hP+YyatM@+C zpTN)9)Pozd_5=nzqQ~5D4p_D4Px3$&2!$M1Sq(ky-Ge1!z9KpZ0<%-G<`GL=GZp5` zJ$bQR`;qkIzN!uRTD#}~9kb@@2RaWFuu!JF6$a5t?&y^HaFkFp5U1bdWO8Q6;sxgYV}_Eh!0aJKoR9XF1cqxpY|pU(4@}T=wj>Roe3mSX zsAF99tT-vg!XXD4z&d%@U!_2G0Yv#FUEoAhe zbSIoIndqzkOW^y8dwxe?YkM1Qhx6vBgJX8wUDb0)HwJ7H5Ugk7Vg zJpA~iGH$?xO7{3-P2KdW-h4_l9W7~Pr84TRfownO?T7)HKCJMK%UHd5LZf}%PZPH^ zLn%kTY{5s}4#r?}f!I(>gUNz5i~wKrFGwn6sx|`sYfoV-L+kqX2pkgT+uHnj!B1O6vFB#za?Xl?0^h7&7$B!!EGkzXpJ*U|jZWJkdQY?ZGPj-Zm8ZVE?U)@L zfIo{E@(b|gNGxsI(&Pk~esS=l-}9or!b9?j+dkMz&ksc zCCTv#qJ$U&kKavHII?H9Cj^m;@peBD(*y9M;wHuQ~2HX1A|y?QCppZF@Czyr^f1xTv(^s*_4j&(VWEUmt=> zzl@88#0qLBX^m`o_JBG}R^1uxwMF;2afBXvF@q<9=hHkelj@L+*%xo9CUSeHli-tK zmYH*E=m>ZNr-xmfSr#gm>+d^zc2tpMmj%?&B77{%`7d8piyG+ayRZ-aViph1lxbt{ z3SU266)JYYg=6jQM7)T5v)&Vyp1;iiPm~bH~(op|og@dsF`Q0cs|q zkj!dLcs3#3IcJSFTPMmcOgR4onyJ?r=x6%Ir92IWpl}aWY{edrYUP}w3{6%et8XLtUp^{7ocB#?fB}gQ59Fz=$5NC zI5v8m+x9c&Qxsw-@=lRC24pnWHl$->&O`J>U(SO6bR^~@F>UIj9H-Gw9~Ii%H9X|~ zC2ueh?8@@Fr23+QDN{$=qdv48l?UmtR9RD~uhR|JdRwPZqyz$t#jW2V0VWA-Gb z)Van?;fh?}7VFGbSnc5p$Y#aZ9(ZS%ABEE;4}-J6meH=jx!t0|9S( z{K#q%Yve4R#nJ;vqEV70h~WN229hDnu$iYIsP6U}n;Nqk(oxCfb;>AsP;@~*My2kH zyCSZgt}^^Eg2w@Di0R};pP z&)>ui(_RD@Q}%^woNU#^a8g{0v?ATAtj_hAX$6U`G-Jh;mjK2ZW8y0 zw>|W!BMS(+u_Ox$_saB};TH70c*B41}Sm|SitNl#X;8%Ig=B7xc%IA@wP zJaB{9ssKW^1z%AYZ|RSTe48_OY;iA)h?h+&bZ1@yzU4o@zv@PmP?wIBmyDt@4;Fli zLHv7L5x>~;bSI=S=(#m^oU;^@3WZ~8dcy#N&pZSa8eFTMksLM3%YRS~tUZcwzz2kd z6%<-)ZNWg*{)5d@Lr@$--Gz2ep##Ut`XMgi@o;Gh9N@VMuV!_Ag-zdx4Q`~}?>)VL zK2~m%O)vDI$GCscnIK_&gPMNuAN)c@0`ZxC)M|59W_EIHCV!T&?Jnpa{P@hj?Q9Hb zv=32c@6RZ*rcwjZZ|madLh@AQs>`;E1Vo3oN>gwjgTgqU0Jx9I2K| z@OWQqoJi$-2T_76d{$~RCVKW`DotyDWfMA&tCGeu7d(rrR5s4wfvmadE8?2ZNqxpO zU9x5X4+_}V9r>cLe*XcMW|+8V1l<9ZR!3L!kAo?|1u}#Hefn-J>$^ba-%g}dcnm`8 zhnF60-|g|X@2VPvVBc>S5kFEP^L<(%u|YSc(lX!IICP=;H6GEkMupfT$_a=J z3tknJUC!zR$Fg8Ex~9QvqY6DZWBp9{ynaAORd%)EwEe_({;jwKNv+uUkYC3x*zAGi z>`1+Hb>Hk^;P2qVd|gM;e1ic1{QO*I?;!;e!1(Kx@$mq8CT|nUk7s|Mf9(*JPjcc2 zix*wzy4_B-ar~3Or66gJ*G$aHps{fhr7DOU2Ix&fnljo9rz3+-oGY0G{Abq)XJQqo zcQs$tXsu47z*5e>8h?Yq z&jdMc^lV3v=c0oa7?U{{#J&KL3hQwCQZ|)qfud{9h=$~(MWd@`Su0+7|MPBP6U9Hc z`Io{(tnmTKB^I+cVv`HH(od?xYeRAeUhB-uoErCmu)kc_y2=ybd&LtPx{Lb1#0@N{ zvHxitVwI4N0yK|=X?WSBAN&0uk7A=965!XWyEj`~XjXF551HDgN*dG7zw$nCPon(_ zC6!)}4kOgyKgYLipFXlWJWwd#fZL0<>x;JFR-;0%Jr=j7jZZsn(7>zkDXkVpYB248 zpL)5*2>ToKGyK#r)<-Gx+dIz1jZP6&B;gcm*L*Sj_)F0Quh)+0bZL^w5%j zb4}cqqq`G3LgqF&TO&@P;{fxg{aXSE%0c(h+X~f9%aMO3;ClG60w%D;9(qTm#tYxj z{@38m{~L+o#4oi*$rRS`bnIO!#9+Uj861qzy)D?loCdMtOM|tItjI93$O4MUbGHBV z<>2*~+ZK`-H4yfnQBp5}8K|>Jhewn4D*N@SE*-ON8K@FgqmJgr-B72G0hig^o`1D$BWaYB z`Ihi9YHS)v=6^FBy5~12_rKx9 z#m2Y`h54jdMvyEnH2Tj%`h7jIw*SBAa%;kJfFCAg5B;1-7RmyzH-Mj#(0K2~FVWRV z2t8Ey5;Nvl3slf|&#LNx*g{q2=)syQ*M;SznvGIP`NTV*4>4N)t$-kqS?hdeD5OuH z!NgFX0fS}>&W^&}wEs7R0o!nVe>8cv*zw)^#LkQ4CxQnH>f3Ek5<*(KgiNd}U>Z2j z_)H1i2KljqUi`_xSp*anaBHjy#Qdut73X(Y51m2!_) zUG1T%brW~znW?MVllB+oDJg8gnnI5?hpcM>dE$)Br%!*rWgBkgbtm7q(K&yAS3zQ3srf)PbA41y_9kHyL_MX?K`J!+Yc zzcFfC#+tt%|CiZi{MV)Xw}_m0t(G~c6eY}=V+V%xTDOl(bT+nCt4ZDV3h>||ow$vyMT^LzhT?}z*K z?p3S0PxtAn?p?J}yQ=nHp|n&(9%IO#SD4M0Bn)N^^#21Z!&uCq5D-3q=s^JbQXFp- zlRi+KEJzn;jkP4u0wk!YKg5~?eOOg@(cEiI%iH?5 zkd1%&o!&9|vQt@s1Wd4DVYFk($0xm$Wo{fDvElW3x8O84u^AmhrCP-T16+mnN%C?; z6|UN%0e!Rhdr9k@nys|<^VySQo2_VZ41m>A>(|a#FBxr+j=cI9?!G~+w59wSW|#m$ z{L8%_!duSxc4iVoY+oz#xP7rY*-`&xYyXI^|C}$I?ky1o$=h+Uu;KpU-+z-2EISEM z2Wo!oVJ<-aDmD>mlwE@jg-rY#o#=hWx413l^!q_l+N5x6$CE4H@QjNz)&5i_Vo>|& zSxBAu2hleh{Cnbt7!TA{qL4&e&Me5Rd-jogby@ts_+ewY?7|5#cq(a6bfEs{(sCPu zRa@4aPGYy_e^7|^@lSU>%hGk||AOR4|0~616;z=pJq^p;@Ay~B`X|P{S$Z9nzKjyw z^CsRBqQS}rO+z~nC;+DK$?>fb8U6znH%Q<|hs{9mQouNFe00N>fT#5J^D!&DHB?Q+ zP#FFE!{>Vc0UoPm<3`c3)U6e~0g&uWX5^yFnZ=~B8)c(1??Ug; zw}A?8@=Vp^-$$q`V_K|wLvz)*1w%r74&z75lMrU&#W67 z7z|Y3&->(lW9#UmTq{>a-RptRNs)((RyBl*Lu3;BuuF$X3VY3__@DF_OPl@g$REsZxjP@VV# zrlb24G0=Tl=C~x;q4sY$2^`s%f>ofi4Q&KJK*0G~(X`gjqUS?Q91t|vZ1D9EiE*Q1 z2o2DKEPX++QG&q;h>BqtxeI&lw!=H$psj_s>PUxvqEAJon9Sl5Q2ukD{1Y^;BNu+V z$tZ}L*~wScc@pRpL^dj9Baadn-BeF1`r!tDQwa&w-wMXJqi+EXFsgZf$bJ(9p*`w( zQJ>-IFZ){f+x`2QWUWDR$k;|WWqAYwjR$PCtY+W|3PB*m3#J>UYg=aA-wBObvMF&H($&{~?A7cpwHS@ZPfY+D~I= z2{6Gv`0pV;U?hmknA_h5USA;PH0unOJNy8IzN0OCkRp6gTZ6TD8ZtEJYy_1=@c;GO zkR62VwRL41B4u}tYP=8w05bm}wLe${>ZO;IQTg~}Bu_JDgrM$%Tvwt*!qKK-?kGdH zs}j>$2s6NPK^&|_9I2D?J&rxL{-Xl^Nm|PTrq#Jeel~KMGfU<@5FL7~%g*j|a9U4_ zXrhW}_u1Q^c@#K?rjXVKoWEt+<2yzPw5#BwAHb;}c92?Fn|Wc`B;@S8uhZMbZ)Yug z_RT)Gig6FQ_q$F2s_o}z{--TA01JS#ev7>?e1jfN*56fbOaDlT{h$9F@OS+2CJ4NY zjsjWZ#F+;aW_diqhI0`P6>a`LhqJ&|ZlkhR+N@|(uqxIRZHfEO1>Ex((&ixfNSvK? z4E$1elKN>Pyz_4WvGZ>;;@}7VD-brMVFVP=AOOBr;3Z5a&V5NuiPdk$yuFOP#pT-Q zk7MoD0}NUd4M^I8=OM>aaxnNRQmZQ%zabt?US#uG@H-206RbNqGOn$&Ce2kDkNNM^ z3lp$lHw(|ujb-}ylqJV5G{NcqJK_MeTMW|WbW#8*NT@Vb84Ezl z0h(*A4lu9)1M4js{3tk9!BK1nmizjA@XRLJ*$d$1wJwV&1{%XUKMW`q8l>+veEqm3 z{^jwt|MpS~X~GaeTXST5foH8fZRc6RDcCQ>@_n zdmV7=zmoJNgLc|INaUFagyD^I*r*<1#OO#j6Ynlwad^=xe#h;S#ahnhD+l|K-pr&o zDZ6zt^}9Le^^|7DadpbXR!rzd_nIr=;Xw1JSKF)mE~X;t?$xXC{v_Rw`+QEgk=Lk> zW8b}F1j0y@E9hO$vtvmRw0tO`&X3oWkGtEY& z5KWiM40lWlwkDMg-Uuz5aleWH-pDoB2z62PKOdcax*CWZyvLC(_?rzWN1cdoD{T6o zGXE(#beqEB-#SM2&X*N-IkLUMwwkw)y}D5P{yWnCoFlOQ(}HJY9WhxIWN&${x}#bD zRTN&&Kh$xy-UkC{Grt{mDaQ>n5lKtr4bRV(BQ~z(GO!kJvuA-4x%Jpxj+oQfzrE|; zc~3Z{-M#|%zt?8>$^R&Z3wXmvjX^+Xf;nEWK~<{RJYD#2%?SAas{-~vZ&aE64bP7^>%*Ry&L&5lXVsbP2u~jIKMKnC;&E}ThrfCTz99i^me?N+ zae=2i&1-VG*f)A-zQ^>d`3vShxWM@j3IE?7;nIQ6RvBS{hya#=mT(OyL$IcY&z{zo zUd*3&X=JrS34;{xQ5(0b77MLTx$B0>pJ4${NT}F&-Z&+h8Y;I%UgPHiPxmP>@&)0d>9?S<8oPOGgtF$VTfsinVW;z zxeSLK;<7lb7PXn~TobY3MN+M(22dX}kGGGJhzRy@F!u0see~g~9acdNu?6%98Hyz0 z(si@Kab*g15MXTq9X5r|ClG6s!3Ac4QU74aU4{AIcj75`|Ceq4RjvW316;V`Tfk7|5G@Ixyps`a7+ssL zaqKL5AQvx-)I0yMR`1}?B$#G~oW=+ls738e#@5^i87SBKPZ#^E2``Qs!hF??60CzJ#Ee|6^n zA_YJJYfym@?Vl5-=D7f2$}=DLM_?a5-8B3Z3gd)ARyx}tLIx6m0_sz+JIXo32gU+p zz}2_cmz!Z9oRZ-bV1QGv-2(zpUStTC3!|}k$Qiluzr5Y^GhyKBulLT4=|6k`a$B8B zLR_3^6rl*J>$Ad5JE%gqFa4Z5RvxY7^)>?m&~q1wD4oRf5Y6s<>dv$YQ9p`3eyP^M zbZY(i(5VPzK#&E9=}>;yZ1$z;S=BQ4N`vp<1LzkALy?pFAa#H&k~b z8<&vx-&gv3<2$b}va{!3RP4~C-SL^uRmlJ}?Eit&5ZdTbz?K@9o(IPh9wT7D-G`W} z`7Jh{W&?zpxvlXs!f8i#_%dOBbN~aRKikLy2B0d8X+=ezB_fY_t|)cf#v8YoLq8dnf$Wb2mlqK%KGp~F>@f-lpC zI8QdH^h=_H2s9Nf+2E-#<@<%~wy9ZNkm1*J3*TS32PSajz69Cf538$qhQXX zFdiI&3p|ADNjGmAUUbRcu{|rL+2tq)VCk~~qWThH6(3;C4EAT>{5Oloh`2&Vg8MJ1 z40ilI70aGAb*jGdEa-Zhw7`D4zjT@ba4)P9Beo`a)ZL~SWQ<9I&8kW8cpS_AEg(nM>iJmcxyQfeDg6Vbtdv+M7l1Qk~uES%$h z$}Lk&+rO%$r3fA>CZvaT>Jb__rqcUIz>Q^hj8>~Cy<|FAgO?gRd>jHqj26+pWlU&W zbg`wi%z4-_*%jRfcHxd`Lj;^vJbL6Cttv$=z{3267p0H4 z<^fYWf>y6mR}a37EW8x6fsv0depMjP`T#ox#6u0cWB|UK%XN^$&mY?#|a^rZH>`%o6-9I8NL0rZvaFzbnh25k-l`a?&8le2c;Gu zBF+hC11^pKrlS8Z$}m{gRik~G=62aKdOJwciQgrl=Fr8i*v#3hRIQn|7p?YS6F2^c zgOT_u{L#1n|I@7A442I{BcZG7pD_hMi_G#?#u>#3y`}exa8YK5r6b0YeUO@v#l0|7yeo`05=7PbK}7O`ks~TDq>i#?aZzkDwQ`sKYe_=xKYBL1Y;D%IE?i_ zvWNH2)2^=H{4t&%*5cN-hx|)7?krjFze=~izJ;Go(381UtEE3FU{14pnZV4~@#^VN ztkv+L3ajI&2d14)6rR#UbTc;o);DeanCdv3_Tj^X-2Dol@@8iz|LC*1k4yHy>id8A z=c}jw^K_HfM_r@1B~3GX@WI{b=C%d^XN2$1u|*-4#&)XX3tcvE-RIBM_4KCInMsr4 zzOy9((+wNC@2ELNIiB3AofT@XRMU^;Nhh0A1yat3E4PQSg9Vqz4c68m&;UKr0(8Td@oNfdEehX>pn)Di2Ol6u)!CT{qY=6cu7x|ojIZd5!{SC6TQnq}f(w!Tf>gXoHI5=o zd2sc#P8AR2gyGxxGD2?Vt$5jq?)$3)u)*=OIb`Z%uut3lE2tuxFZgKfIIFcU@T4Tb zjlts)mc)DQg6;iQ!pEdq&-~H7$Za9@$!_E3c}vXH>U}i_?`d}S9gfN1x3Qm-t9cbX z_#N(WY06{6@pteh?(z3_$fk%=T3;C%ZAtoVq?|#~;SGqHd*~9Ajr7b5l;x_RY1*3i zQU#*#}8T!W|?Vts8VuJXP4%--ws_(_)Mee;^M)%E1maKU2a!m1y8OvJnCG0}Z*NvRy^E?x+ z5IM-zdJ~xfeuu^SW_iP~|lfS%caWYQ4cW_j0{@Et71LLf(D;}Z1D z{04S)h=B@Wt2dDtUP@$l{|3jrnbBt*TRbR~ijj;Q5$lh}&n2ofJEE>E`GX+R-?ZdA zmk&GgK$(z`+s{E%Z6WnBA`7=MtuW-Eu)KPBS7eFn!ku)~r;XbpMi2*zk;Lfg!b(4P z37CDNn^c@yIJ$sJT-JnU%KHk1sQvX-3E_I!+junRooHM`^X3pS9A+72WpdOqb#pU?R@1qOh?9?4|03ItI){S;pJe9W{UW^^4|Mgq@8ATqiCIsYQQo! zXR1tlmO`*Yj_YMH{4pIHvy@;Jxn)rUf5_B4G6KZVmoA@{1$XaNo6Hl?{*0GnAY8i^ z^#X~Y_VASa0O%hwU@SebdN$!FZ5%VlD2>)OL}9Dx6q>}~W%P0+@e_fG!jbk-$}e~F zau8kY_b#5_-2g6}+UsV@GUY5Zsd#2bMK>b`iKpkH7j6@pg=-S8TAAenVv|S_gx49o>_2g~y=mEC| z<}y+O#f!Hu_ET+YRrLCX)PmrV=k%An{90APi$%w*^^)ErjL~>&uWi76X1V^m3fgC1 zX>h+74f`tw^43olgU;Wo&Gd`j(m+*tba!F;_dS#HE@OH?5LqM~d~*)`)2B+tEsZCjDbDM?RZwD;Bjt`3 z1-F-Q2ht(IeM$BEmtOm>oT%*8c78=Ukd+6>3vZpuYI5(Nm9{kDa{gkF9l;N-F5)Zu zs!O5J5k6L!JBE*QkaQ6aV_^G?jQJBG^5;`6MpHqlU>@9WkLvGd#8BkXh;z<&Z7}<2 z=(ylnV3!o-hmDTtj%tZUnv)0WM&o642M@W}Cr+5+3dytQBo7fk0V?M@G%_E5DB@F1gR?EPw?) zkx%8BD5oc``ddOxT@(dv-N>#R1|Eib5iR=6g-*q#p!DtzhqZ&U#$z%_V!3w{^#JQ! za*Ja5T>p`NAb}R_u5KIaBe9w8%uY;18wryK>J`Wu{OO{G+cgnKr`8uru!1mWz;ftY zhBji?8EVIi_JkAjok=t1k)o*ZU*UMO@GfBI1@Bj*sGmR2kR)muMN-M?Q>V6A5)B}w zRaW(?DGN_`NrU4d1a!MpXbon&lyOK!k(02frSrb~cCiokEuublD6@#huScCttCUfg zG6kQgmU~E@SM8|5oCjMiCd94l#StN0hixkC&vf`T6_m^K#C@NH@L*%F4_?A4c z&GMx^FxJxBZ#5Bc60#^`JDJI2NM|s?V_t;EH-w}Hsap`uZlD$66O&bhL35NRdQWmm@q{bpaAwHtSO8Z(LEF7qD^6D(NcJr=|HW>%pFGu=y| zmj;SEuV}ZSIE%C3-89%3eY*Q@6welD+O=TY838eWEz1O?*zJSKm%Wq^Owpe=(}?@k zx(zBCk(AT>QN5K6oKOX@d+diKoh~;7z&8?vauO{=8r3&8pW`irg}B zaqO6|woNH3itVp0$HZS>;!ameNfxf_2VO|`xt@fTH{Bm)D@u%RIG*BinieXo(&)n3 z=MyK0#}N8pwGC&s8vQB=RuS%__e~N6ezAtUZb#E91?BK&dZlqS|1*-8(n<-v&tb~@ zg@nzpW(09Dy&ZVRF5moTG9?N3-e|OOfFgF%9M!$)B*kh*DEYflYvZQ7=;%#c9TRvc zTkF+6?n32&q5z4UTaBaPRpILyUXw0v?Vy|vq-$56t-kFiJyTzn&t*((oQ5Cmh)Tgz zvDa7ZinZH02_}6bS3i^a{A(@Jv9ViYL;6^MgSi+tB~Q+3KAv&5VjPeJM%2XlwW6kv z53!P9(^O9q=8&ns?7PM5N+LS$l1^qd3rsyX7(a;WZa0nZo^t>5RIH|FvTAb?;A!z( z!OnF`Ncoxmbt*EYZ+?20d-`Uql_(RPCOLh+XS}r$(GuO!KA5_1ZmB&2Q>*BiM8?QI z>kcICMng)n^4)VPewqm~X^eOSEa+mw3k}u_lZ0my_gX zaD_$Oq#m405$HkJM+lc}{5hJd)*#hb^NCvzolfb_5GmhDZ$_p!5_7J&LXxOlFGx7M zmv6&hUso`ynnK)<_+gZ0GV7m^-{5t+A0A(XmY%NZ3)!Czp??dI5QpbgH1&CAZzZ;R zaVWo7wLo=|jFA?KO{X7{48PmvJ`;H}c0stC@{65~^)9A$9lAL7Mq(hcq-Bop;=uNO zjSgN<-EKpllYY7ag`rX*;5j-M7NI`l7$glwZh(U_v3z}d^wtqFw|O=Cn%aZ|Pk4}l z47W4J>}l$YoeXVfcEdow{AH4~WmF8TwW4k#QnvnkU$qOf>D6vR#~^1po)h#N5(X z$zouow0csFZ4%*asY!v9e7f4W-d}eJww`mWcs>`h6XmqSu zczN`3ubGCu(;#ossoSk~orN4V*9v>l$o_0|+6jT~SOo(^0e$ih(gZbyt+uI}Tld2j z&Or9_aS4k**R8e9))4;QqQM>c>hBu8Io*=aekXqbcEcgOVs&F>2mcd0v|GszGZ74J zM}|u<1h>>Na}U@Vf+$<+mkrHDRm_Tw;J{Bw#A{xyRVT9s;7}TyF6ps!kE%<2=kAGW zcRN@jE=>ZhwZ3SC_0m(_5#04|`10Z~fvRtn7< z_=-4lR;KZpnJC~)m#fXl*G@{As_VYWO%lG`|^ z1yzE}jO+j*pHzs-+>WDkF^rat^3mTAb41hc{h|^$-Mwo)SAhbG7YPBxT&#Dr zF(QOEhG@&(j>k2hxIOAFOL3wx<36A(708*P%Ria~sWvFT^@u6~Ovb++3O{^?R~Js( zCQ*O$gGco1(zJfI6+)_wNJdS_JA|cwdJ>~HXMQY4azDQ-i4oB;pjKw3-|1DHdke7< z@(0Syhji!{*tT^S>@N8A#!f6e#H61{}dCxJX;-YYQiK1z3lC38^i zA=@0V?@#NNN3Y*o;|_(KLCHxoCMd@=6#SO-eWl$E-_a^Q15aXD9X)D+HZ+9k>c&cl z8?>XNDKaAb4IVjxR@vWiQUrg#e<&+I=^kO8^^7@(>5K#G4>2!8LFY)h!C|3Rqdsk0F$fn~zqc2=xnp=4M1~_icL(B>j3yEwZK8x_m^2KG>@d_5 zCs0v~-76;hKu+PxitY4GiM~BjsYDkNnVaMmyQUkDQwx8S`Z7)mjq;JjqQJ`qCZtnG zF^_a0Dk&-bhE&KfrYwa!llkcJR9x`#H2k7R*TZXhJF-PFJE^X8rZ)}2ouUe7mJji! z0sHDWGu>>q`g7WF^PSm}LqCO?gX5_5hbYIah$851&1g@={f9{IiFCZiP0Upoja?;D zA&=*{cG+z?Rrb9{#X>pvc=ASP=DoGAqdd-q2LZCDbe?j&PCgNn366o*gs^y#MvUiO zo8a#vo4Vj%Q2Hw?3f0Y=86?%kGUnfC=jedYwpRyo5E*)$?9Coq9k}{FN5ti0+80#! zm#Qj51<$o-o-P#3XHEyWqkJd|m;^mMbk*LT-Bt7aZHo!LZ!@(wlW4a47=g@9tynY+V70GK7f!t z@63zWSZ7vmrW>uT}GH`aGMz?vs199lD%%uAeUbSSr}5VD_9MnK5lZ z4XOr>@GIaLr}jKzj1?|~!6RJhag3wIG+Iek>@l}RAdUi}?n0HE`bB>0cJm?69Muc@ zQ);FEZk60Bu>H@1UVvQ_&k7*pzw2%23Fh{G$+M;AjxCmpAacfQDLqFBXVzba=xf-Q z3Hyqjyg*`pyXA^VAUc|`XJ`?RK*{C0yLaJ6659!hh!Aji*S|K$bcF)U4)36tj6m_| zq=Z;e@y?LVBUGD??2VZfH&J9w`&fX#&_z z9sN$`xEtOPUCHlulUedrW&jDyp+S9DVNSl}WECZ>g}4y58p#kcW8-(nkI-0y?Pjvb zLac!+hU}rkJGQK(P$bN29^HvOk{P?-i;&VS#yercbkW=0$k}^1b4v8Nw{G^z zF_xqs)!-42=ESRXmT1iVv{E!*nO*g72Kx;cUDpE+Ixw6m$=C7+wQ0r=g>MXLSLz#9^jK@Wotx zDg!#KJA38+OVgXictk)|y+CAbfC|HJ$VxV{9pZ=@fbLO>Q*bX61{}#JC6-O&VgM7# zlX?_x`t+IA*G!sN*C2~7hldBfifyo^1Ci1ym}vZU)QAw+LRydl^92EqNWxvelaZsC zPXa*~IPI<6Ix zO1>!b+-Ki!E_PY#ghEEc=!2Z1X~JX?tjj1+lYwmsjK{1LllM4PDhOILRbSsMeLR_G zQ6UNz0vsJ$2n4j8uYa+bjypV}5Q^y(6@3Jpsyy*Md=o7c88qZsrr)Hzp(YV7iy-rN zh@5e5_J?0tbL{TN5pgYhD2+-2>98uA9P3Wo9&MexEp;LJVNv66MIQqbQ)V3vS33TB z??#ryt?gCh5=m1eN{$UNW{wGcFfNBsP*U4F?Tb{}@5e!AA$Ct*Dg|wjvTLIW1qDJZ zv|x!CQ0EwicV9lR=|7=-`>(Ui>oJCX{MF0d(we+ zzf20O^v+%ki#cVM+6|i2EAki@Cpb*YW!$uedm4h32KV|wPD3?9&1d6!;k|8sy195v zTMK|j&?l#cP9r#MifZ}xS=&hSBs8) zH7YUZ%qbAJgwtDqj76uln5Amu#1W(2*+l0G7oHiu<+~{RR z$llBZD_rn`ugo(p4TXCGi80S7cZ?Zu23mtqMAu+WB}Gv^AiyJ$CMhk=+h~N)*sWFH zU?`5}rx$wVRj{gL4yQu2u4s=B@R!7r3iK~C;TrEOBo%!#TKIZa=nfWj%K%D$i&d2i z!1ArEr)YI}a!%^$ObZN)^!kv|ks|Derme!jTCr5%h!HMqJ5Y^Wm@D$io$DP1G71?h zK@*`OkQ#Y3FlzD6aWvK%GXG+Q_&(5g{F<c;=UAY`%d)c=TyO&v-^FQ z%LJY)us|!iT`BQIIedl{D}g0nCKE%70z`1*Dn1`(y=SV zfHLG1?$P62N+@d+C0Hxu8G` zN}(6tBwKDm<6;AuQHXx%1jdu> z3Q@;0rENoEZ&!`3TPQDt!jrLtwRwO&@K?mZYP(_w)h zG!jmGJ?8xedP-y9`ULmYX)D$H6kc?M3xl6W^hEdx=)ZbAqK?$2s*b zyos{W`SZ;;++~nXKGY7GrPo(+Xlcy!rKMs+Jk1s7)8X-IMB26c`941k$a!-j7doB% z7CA^YzQRWoaP7BN$VvuM#pnS1MIyu4RSI7HOuctaZEY@n*O^ie@;2&h4HLpqot*)7 zPT8+=*pbR>t(yk{Bq2U%DKsH z_d|GX(~EHap`SXfdQJqekofIs-z^;>)-;x-o4yPa`(@0BO5z8m#$|Pl;Sqrmc->!k zo!)n}P!Rc%B~_>1s=A1sE}m~h+SC$v_l%W#T{x#BNRD_94F}zka1HZ`FGotA7$LNh z!F~Ky#yWLvz+s&osU+X5jf#s%R?fWaGN?y-Xvnx(hjjS>CRz)+IGH42LnqIhh{W^gt*e?!t zLebhGFH@*39dr@nY)l57cCN+bHBec=EPHhJYcAf(oHlPGbtclM>xH>0qE&S|%*&~2 z%}o22ZR(Y+2}4OvqIKPeP5h$LXVG?A6_P2f;h7U$Z$?`0A*ngS$tWHlPvMbIAfa(| zw)nehup&WGJc&-CFn%OA-!{VD*~0c%9NuXE7*Oeqns8j4?T%YW0Kousw1IH|=86iq z|2Hv*{D);qySq?Vtq=KFK)AQ1^KgCYa0(kc!!tF zX+3)Np`yD$2+ooE<+LF~xkk z6uJMKM5M!qtqPr!`d7!;Qr|oc+DVz+U>|Y%QxAz!BAv>vV$0`Iwg$N{hT(;;U;2Ta zc7y9jT@Gw}SDiUWVzvf7K_vUXFnU>9bAg4laYqLM< zQzHvF(MFBwoIeYjuLfO5veJfcde_3zex^Y)C~*+pF7AqGqdB z#VYKwLUED(Nct7mPNb$R=XG}&uJUrGqp!p)mZ#& zCx{Ke>jfxqs6aAk;mUgU=*~!9ntIx>K*OJTNFnm0!nGlozJn!M3Q@tVWMaBNjB`pR zaTYb(gXQ|j7;e*nY-GSXbAyFj8;O}TP6?bMdCc)!U&s)jPE)_N1@OT$WAtr8krLDC zUZ1_h_?`XKH9R~0#sf)SIe935?%ALhuKg>MoamZjxxZAjh`s#u1-q5hn{`i+iB*XP zo!tk=z9Afr67DPR(b2Qs^DQ|gb|?SK>}dUYRSIUOM_0vya#C4@)`DuPvRfdZGGem7 zVq5Zy-PgcAsDreu=&j)fXy4}ruz~6ea8Xz+boGl1l9iz=tTj$yo87vC*~^iEzEP{O zsDbcsv4OoMyANZkm70~WM~#Fe4TnF!TfKO_d>OrEo&X~gJeKK@Pq%o4oNRpEGh407 zIUem$AK2TeQ`WFUl$U2eQ(2(uof=W~kY{8_MSt^3WbdTy>l18V8~cq|-;o-k_$u|* z3g!uF9Q$n{how2o88okXPIH0rKFg8KvRfzy*&Rq};rMdphDzJ3ZMQbqEaive)#tsT zoaN%OdvO>hvn~>?QIN$>S49 zM^s^lAYe3Y!H{Bz>dznrIq+f&WkWH*l_J(bJ}x)hFU~eM! zw(#-6>H~Y8yYGI_IQ=H~T_CqRmJD6H_>OwH%C-&RZE=;13wC1Q>VSq`xbLrmKjgrg z)?Zb9M*FtayK`aFzw3}1M>+mosC|o-9Bn&|IW5gP-}2X~!3|oCi@h09Yhq7MH8WRR z@+m_p2h`0_CcR?o93IPt3>9_)Oh`;*O4}&SO<8BVGj#@Of==)ocq_SWlmGltq$|q; zp8G6aqJ3|U<1Bj3<(Spn>q`Y}wx~J}MVj<1y6N0FwU)GskC+qPXhSc0eetR>upVn> zM@RXpi0Z_h<64+wYcajIy@WNw2fM&-Yq~mz2o2TTk}ps5y>&^2C3GI#Pt!K=JXGEw z?SgLES_WoTYgLXR6F$aZiZ`p5L-eaIUYR0VcO;DQebzU@CZddkFWA$BNth38NHUaI ze&LUCNF&q`Sen~a@ulGd44QR=h!`kF*PpL)beddrMxUn6SB9VR{M+skRBDVL(Sm9^ zKxsdqExfriCM!6x+(#V}v%cFRqoJ^nGCF)PplC(l%c{1($_<*QwiuNPFuh|}suU#> z=9NldWiW$QQ-rp1QY(~S9mftk{*;Dp4US46wdJ*f>89opA-&Ehj^cQt>+(~Ljz-#ca7gu*e*#~ zHF(+);?#9MR`}`_k2hi?UVR?6Hs;Z?zi7V^a%?NSWP>GFS7lQ`Pu%sz8v`9fNB0YQ zbmb9nRp|GV?OL@$O-Ym0NZ}*aK_a1Ao*GK5fk#V`ul*Wz%F;AU+{TxzMTd_+(M#)F zYIO>7aq0+$XP)v-3uG9I7Ngk>Bl#oJaZ1!tZ${L%+`_*4*#@KOpfmr56!`jj0V3Y9 z?r4{*aRABj5%9>sk@>A!R7n;=?*3uwNrBEZ7q(dSqJI~N5aB-gyJKh6fgc}>pqpZ^ z+xW`F=#!GavgLOak>9B$Y?>Y_*4jTA9AG6d$Nhy6s$36CKq32fN7(HkN`%|Mw8()F zdZP#vzi(KF&qBp&8hpWg9jkcR)$W6;yaB5V(0RKLIB1*rL1n%=nG)pKV8|n&zoxsi(~wJ zD|3>s9R>0|NrM}DzwPT-ClL~yvpdlF9e;3RHU2z*Rzt<+&Gg|ALXH6QrW>RCWPV6d z6v?R`)$m%l5m*y{jcmb>5oHPw4Lv=*p3>prh*5DSY#Ys;VfZ{HdNPF+VgpDg7Uv!ls1m&;J-)o#h9{$0 z4uoUl>UEO6|AiIg2+TV5qX@eTN(N?<7AC9@Sy>ux@`akh3e^T@Vhif_&Ry44oN|y^ zh!{4qgX%mszj_0lt0<^0EN;udQk6k{NEh9sU|kg)I%)HDaMea4Rv9D7 zc9+fnGdL~GJ(8HbPnhTZ!Z{lUfr*PPW{GVb8kxx}UjlY`G;rk+L0BqC_AA`cP+DS=b%`UbArjOwWIO_GU|STZhg^JLh9O+v77ggCmacG1RrlfJc~N3- z8B4JCl?m_bj)qWRyGcn9GnSq!2f2R`aq|xHZ5xv^n!kWeZod(Meb0>lyUvC4lzM<7 zo~-9bFG}UROhyT>FAp1Rx)*%n3K0Fp5bbsj_5B%1rv@Dvcuh*!^Ql1!8O1!L05L^pgWwMpnQPZ1l$(MjCDewNSU68;FEjWdc9<}3#-(-+Fm=%i58BPe&0Zes!hU=041VpPI2K0SqG1E)oQA z8IQ-aY=u0{H{0$fi9X)j50%$czxh?YpV5R%dp?S@@`G}|x|~W@PfYcmPJ+*bIII!n z5jNNlGL{TF+v0J|K}!M~p%RXff=Bb`7&N%+vqRsZlHObrl~vm;${gYeS8877GBIq0 z%EF;0bn4v+3chc&6X{8JyM~A?wCfY-QVk20e3SQ`+VQQB&KO9+F}4?md_|^ec&lIo z`awE04GJB2px!dyJ6$8!(^uRu5}s3AE>v9yZA7YBcerOr?_olG>72)IIz96XdXA>8 zFE3K_5{M6S;|)jWx4-z;HA>TZ&8hrf7TxvARKG-N3Kht7t4e3E=7P8bXw-i^`z}MY zcMqjQooa_|Xmv z&CzfRX7%yqJKw@kLuCBR#g>W=3KFcpH>zegHcBJhdaN_s(_zQ_ZQtngN{0d4+s@nF zub?k`S79tF&?wP|wp)xHFQ*N@nf57Oh*G@XRE+1XO@Tks@PxfFrN7^IbQySZqCtZF zG?)8mq8qDR(T1#}0@)yJZM{L&e9s$1!^}K}QBoNP#{$NeqVU*$K@L5wb;<=6M}!0G zPdttKvPLWEh}6`QakBzstR4sZUIO7Ib-zgBu^B$=Y0(}`9j?I11j#A~90t5j%Bk_i zKQ$vIV%NS5*fmJuNh>t~ZyZkn#kXwQx-)`u+Wi=z;nC#Yu8I(f1@3<13-%YS#?sXE zWb(e5oAORE>LP{Q-r~L+i3v`IFM<5ZrC}4tyTu?g*`OcIig;6)lv`kv(Cy9H^gH^pFW27x^l2<2>}DK1n**>Y3=lcslnvA&yR)dE!Y^yj&iMH& zx|Q<=>%5Z*Re#9uCTmgBpTz9Q;EL1R*D85q5q1rp*`PK_pcSF`sufr%01Y?FO0;12 zLC(8}uov6op&WWp+<(>PeJx{}@SJA;j5q$YvM}{=O;2_S4$Hugj>AVv*6a_avNvOA zg&%y!i8pnIqT?z9F1VFr9j~zv@|us^uVf z%C((Yw^r4yQ9ZPPvX_lbiL=%Wm#;-W!(q>h-P){3?=_ckMd$CEXeLy|l#>AGNK^B& z+|A5<6^@1DWxHFRK^2w<>^p8}xcfDuEIbXz%Y3&!<0y3dIj=$q&&g-0{u>kp;!c{%c7^Z9>RI;SYXnYLZGZQHhOP209@+qP}nwr$&( zwyizi|L(ISt8$RFQjhDte)&)QM95{F;+rJ=7KZ3cJonqAbum=FEsIMFpLJQ;*&Baf z#2UeO3OsjXsKG&2Ze#IwRy@+Bjzt?Dao4(PhhKfm?V)&HXHQK>YRaFD6w1|b>{M?6 zhzF4v$hHBOoM#vG@!68N0*0m%qb2XCwy6KHJ#pRQqhX~}j($OG6|1&p_0^-owC zB{YUJL>?F90cxBo>tD7!!Zdc>0&+yy!eVxP$H7py!4WoX1C0+_2W*@|&c|IskKeea zj5qo~8mH3(yiWhAJjvea1#^_1o9(xLWY5Q4-Xm<|<*agyQc!b5c8unXU~#lTsAoeg$=;Uzr{|B;yX zH5-2UE#^GG`lMy_dxtiB`HWqMd-Ph|cm=l~clZ&X_WdPlJ^G4pe)-NwKl%zu|Mn$C z)6yC@u$*lwU%L!TM^RyB@L}Dl%heU3sSlY1BYTtln^kYF@+|2t@0<`L#D}44l>29n z3Wg8H6Pnkg-nF1|OLfX>xjTQ8SJY0Y(5&lrs>qE~*ZqU2Z(Po@DJ4vW*sJP-cc-7$ zr*Dpi^LMf6-SW3Wwaj(d=B9_s2A7}CSg)PNW7BpUm-jh0NNR;Ihs(KGNG&)|0#k?F&N*X?5_Y% z5L-hB2VWj{ls*nF)d4h{r4Q^t-X58Cfw7 z*9?Hx0I{TptCmqHL1^#Bq6jrfH1}1kV+|R82>!nS!#~*lCIgD^nOb|5azd(VL=N%^gf_oF%TDV?o@G3raby*X+vrl^&lJ%;GF>>3rmGN7SVK)q&vt(`Kh{u-y4uw{*Q zvS+SV2rtWzDk~_vvC$qKwS152NwD2`r3pfowSUTE^&sn!;cX1W+KpDoLJjhU$^DxK z_CeaHoO(zP7Q6{<|3d$|mg3P*wdDsZuC3iayraQ_BWGOUSa2rhob<7Cm(Is{{7le@ z_8OIWt4Aye&jp~7_euv~+>}L^EqJGE1%~w-s zchapoZA4SRTNP9L5oC__6u$Bjj=YoV(bH_PnhG>}yhzgfFAp~6S^Tu!29w|EJ^Qy* zH5>~WnRn}JmZfiSvl-JJAIF>a*%Oy@azdIaONyH$0Z~s@E#ioHkP2An`FTG?NagCZ zXut?D%IE#OI#sLk{*r(PeFH5c4;I|N4kG;k#K$c5KudJ`%bP6jz5_%6GvQoF5Cr)s zGdWiw{nY?1Kv>n{O}hOy^KU|RH5Lr>K_Z$XnUO&9fgq7x{ZW84nO#v{0+WD4`3{QN z#G|O?XiNPOfnQG61Is$);zsd20>_N@BO+9x;agz#EVT)L!VT5dYDD@QPDcZz3IdSm z7;jGL~<+` zr1#5P7Y+@$r5M9m&NGmdPPX5m3}DL?Lv3Q!yW$&n#Hppb8zxJ^w@|ET)nc#2aVd^$ z8KZ|Ln5#^GsDx3E#wDkDmIE`IP06@&yoG2^%)t%2Vy)zpY*1o~r>u!zt@rQ6)_$%z4`AiB$@!qaAqcYZ(3|B%+924ZYT9dM1wy2+q=AUhb zrBzjnQCiiq>$O9Foby_};*_>|>q^FF>{7^b&09UMu!ro@z%PzcAn8KGt~G7Ur{P-F zzvxTcJ9(ge>0Up9`{jfMZJilHFXw%J@0fGUjZfJ&4WJ~P-=xu~fMBZ50@Gb5X$qN^ z>77ZGL98I9*G5T6*&n1W!hWCtGIc8DE}gxejulGoVcL^TYm9Z?YW2M3(t$9?p}jRQ}ISD(lSH4l=;>o>98{XGr|(|6Tx!u+A4V4!DXn$A}dN z=W~eOy?kbaB;;WExqheh;UT%jUPUe|#WI|alY-&BBu-IYD7G@0$8rKQs8ydi_pWs| z@Egu54L4HvG_SngT-w^PItdwTbM1++N06oXPs`u=$8a${3fp@<*L`Ld)mygoKn; z4CM&(;4F#;C5ZN)YGt*Ko?W2;f}bltsD#YC?s6JmOOKecb%!uZ;CGU?5RW8ug-X!o z?uqB#x2Y?-x504FvRuGFFo*tmdWS!JA0gEs zd@ONktwmQf`I!v&Wu=S7)sQ(P7(A1m?wmC-dEm}%7M>l`wbTU0Dii|7Ly~}jX>G(N zxPf3QxEOv2j=YRz!qSTqbSf8(iWyYW=@4nbDAsMe>$R&tWRUu+7OssJWkY1Qu0W5$ zouC`NsTdV-K-Fhj3f7OvwfOvY9qz1O`GdTwE#D19N;VT0*plZPL(n3~$l#EMe7 zEvreYx2>&r!j^u`4B@JoyPUk!Mf0-UT%M2o4EP+qrF&4UK9374E>q`Q%-d-2oq}s! z`1a@^l8;9kWKQT8v-_AX*wU_VFi0R>cx(B?LwpV zgqNjatzPgKAaMDe*i`Enkj|}r<8+g-+)#=yN{rE2hlT~M@7_3oWp=Mdqww#W8Izpv zf=rybE&ga zN>&|JnIa06)^mZPYtqeB(OJZ{cJ#0FODF=SsCI8cD#fJ9ik)0=;EM#0HA|T~%T%@9d2{Ef!1QIKB2WKjAo!X`4PMl8+=n za%z6aGh%*uN~g@#W*&7Pu6vkngDtHyCNDXaYTY-u-D9{VN`<4mc3JOPL$l_}DW+!i zdH~p{cQLd&>izb4@I4pT^WLZG&G5O4>`aw{YuR0`zzuQ_aE3YrLQ~ zt=IDPx?4Kfz}HY=A2_!=@7H5iL1vLhmH5*yI6m*?8}J&)XS1?kM@)twafFIzNB9Ds z@d!X<(KwhyE0P|b4US;bq*ToxF<2RNelGadts+1GRH)LQtv2BkYSD=#>H{l=y*HUQ z$fECDFbSwNs#Kj$>@U9Q?7J{>tRA1=i2PM70-eCJ5T!NCj3Gg@_W`FxK6!&WJ5>Rw zLta&3e@T!yO3kw?zydkoAeN($$fGSX3ld&@4;9Cb_@Cd2PLuebND#=LX>!&;@Gt); zXh^O_@tJ0+04UYPiG!9aFJ2Pb-oLDYGVm}WPKyZMEF~IcD{^0*f z#S-oNB|iYl#P>UMJ8t+>i3t#U)*D44vjODNDU3i^4VzLcun~!(bW$L;5{V*(GL*Xd z+(m$A)W1{d^J92qiuOS)pNnR=Eevxq0Nj!$axnm$n-5~HgMlIN%6sG5b~`bJj|8We z3YS1k3l~xiU&FPFa%?NYX?DiBhygM=i(CW)t@B*z_^lr--D$xMlsO8u5*;6(m0UOo zvT6xxi*{A~Pi^&Io{IIx$H!uy(D_!sKdNM3U@n9yd!Y^`D$m!Y zQD5lBppOjMZ6={y9NV;YAS5fC1Y=)u zU>6MMM;CQn-3N1`mSN8aW43C=mVeZr!m0C*DfRU!?@HR~v{bi|+R1oW9lzSH8JIcU zMf0jl35p@l2V%>#$ zx9M!&DJlSEIILfGM?|ir>AEy?tb@g=@6BLxqkazd;O4%4 zt@@hty-oXlxB1|YH;t=Eq*CgIZ z*G%By4zcb!pj>s&g*%oIYuu?vBOO61CMwwJqgn5cpUVCcZwUg25>6;}zcFH>U}l4q z$V;(8MCpTe=D$E)_v60F7NC4la;MbD zguScS6E$yEp>B%!OAQjC$`3R6xj+K4mIc(?>azx224@#T?ylOMuF~SID~iP1m$+?E z?Fa+w@#c4VlsFHqv-2gX)Q%mzYlG0gGd^~O(ZyFAO)k6^c0WvRaj)br08v8?ODj~R z(o(^yUY-#x-79@xiv?>lThfva{Vuevk#0oQ((8nyzgkUy!X+(_>sc@s!3Cz+fG#?9 z_uoGptfTY4;)c&{U41h+8zfM8D|~sSKNDN2ZBAyPi<}CCsWA!L6gXf7zwepumc;tz zHLT&;dWT+XwU>`>i+CVWk#$rQpXWc2sW7~6>`#BXsMY?QVa-x&`afqQdq+37`5APd>`F-E0cl0nv?5=UIpfdgDZ6?%iCM~egg zcDL>6?fY@PoUyjo^e4BiJXf(+YRb(v)Z>IrWIgt!VFZcx!aU)|O1P^?jzdw0AQLte zY|MD+j<0oQ+?(XLx0WV%l<(fP%ZSBgI7J^WWg?aF^KU3E#8|lb8A;RAhsaHLuC?s^ zC_=1X=}y}$j|onAzVR7ee6S+KGuZ6X1|oAXyoeoT=94tUIE^$*Ip$XY8}eV=Y{4Q0 z%!LDwVy|teASUJ-yaIPo+vi543YYmxAj_=fA(5wBds-XO}q>5 zTqQvm0~y5PqZv!r0_2=nlo~{OJX%)l{F2&cOHf=j`2nQ}{pp_%M;TlQB+W^KcDk|5 zw7&CTw#?Oz9WM9C<=|?P=4QB}pYHo<)Zwl+uX&Trg>OrdQf5c|-EvCrqNJsplR3_v zw9dNBai8bfHSFjj6w(*2U||s}KQBUt(w5TjyGg7$tUiaR9*f|=-hDsZzV!I!FJRzb zRfLst^-TE_VI4i-6}e;}tNh1UF@;dMylf7m=YAY+0H41NzQYvMt4v&Qy+u@1nT+@t za0>{T#5+fPKn1_Mp`n2UZjg3uNj+1Ps;Xg#F!et`M)SXDaf<=wU$j`hAxgOo*aQ1_ zM0nM3DAe^YmvdWz!y;SyC5UUF^?Dw@L;?~i^=`a#k4B?K!tMQeQNxpyjrfwnsY6{9 zmh^1ue9)|1&>+9<%~l4-lfGn+G7OVV==-6G_fZA|fM+a2COsl|c@t)OeJ6_gK|7ce zg*_85G1MW0oq;MlX2xFcz+0r7Hv-E9JdfSp>JAb-;1B`UENeDw58me+PMW1fV{|9B z8Mt3-`Ss$tQXPz!ubYDpq?#kNZst-GaprX>Y-PF2T4R;iUwB+h>xWhQnL)jWfDhSK)8(XJ|CzP~t!2XDtwLdwD{ zg=T}W-TTw!SzhaVs?CpP{HzFuQ z6$50~mOU#B?qv4Unh-@}XPB}wv}e(7dQB_uI}R0UMpd@eG5Y-8*gX6g-~S#_!_Lz- zrQj@>Ek!pGzw!|*ln&Tk-L3QdW%=_X-S=b%f}Cm$Yj%-wLNlM{T;xE=wq8PIy_LF; z8g%GCX}CTXl`5yy?M(;{isZ+s;=aIoK*|b5kG+^@D=bKn)N)P&`sTBrWkFc_4jN8r+^De~5;D z=I(DS%jY*Bc6Xf73Hw)p^7WGkp+z!1KQaiQfN}(k4)OV5(-+K3Pkw>f1t4@WG)NwWxXa?V4akq{Rnr(AZp-iinei82{ z|AI?RG*11mKTYeUy#B%{LG7_Oo)YVH;T~s&@hSeFli`i;BRb-_0-|x;g~}+>&6Ei7 zPwqyh88)SYRJ9WMsO$I*h8n%G3ZKQ6l}TiP!AB$%2-{-cO-vGxZ*(g0F8CF9Hsw6Ib} zxZW;%KYIa6Sc^mB;M4XzdK?_}tVA%}>$5HZi`10*CG%x&K=XngfY;Og`fB41Ibd^R z^;3mKu%M$g=pGyp+7?LLR$sNEIZKz?O9gQo6S-Bde^aTrbEr~F!P>p!z&I}9USt@4 zih`wVP)_cJDCVgd!J46xK{Jh%+xOc9$fIx@#B9VZO@v+`J=`ApjI2b%qOcoA&}gO! z&`Ll=k;0l>%?9ZQ%px$jem@#=$TqWFslkE&ElYYcXrSru6TBJ zHr;u@tJ3iAfFBI-u0hn+a-6>O*PJ4V+jUZeNoEd(IWSe;1fUy&dMaImcDn8R+uxVc zfwyHNp=93lRV|57^Xr4-tf_Dp?tY?>4;s(Bu|wtdZ$Pjh&$SW^-OTN(lT+o(WCP{J zVewzQr=<=^4zOpr_m@5?x!M3!FL3>y%7Fe$j;?Zg{&6W#LbyLs0;_@;NAqS%Bv(po=w zzxpFN@f8@`#tQ%9%-i65S;-)xyc-Ejl<&~@8|z6hP0FV?8KN zh<>T54kQ0B-#9#kg0_dbm#j!37Y{@}X*PSzoTPY$L#0hGi;~D*q3R>HIDefR?vq#tTPWv`NOn6)JghT8SW!iI znqWcC^Hvm25-2d%z+$2te!Uj6hpxxA_g?gAEA!?ovrPaL?@*oI~xX(^Y5g&aT zPH)ck4+-dVBU~2Cp$hlM5Gv0PA{4-PE`NO8 zH1v9!2fUNdkK5d0*(v&|q8%>-PR{+lZtqMAd$)TJt6x#;0hl;SYE z10Ui7xK)6`k*53D1#Jq&Uv%Y(lgE{>Wi@QdeuWdq0~ibU&?)B(&vdTv?&XYA{@cNW zKVH{X$-w;Qnl|SU4+5*yn36yYG+e5@=r3geP_vMTV7;gbCn|xA>+Tw&p-h5IJ~&90 zL@i=mYxnKr6_K`H+OSptZ@o{lkEw3qCzjsT5ywZmZ=Bn-mp%difq5~DLjJLT%E3(#vUTxyrs za>L-24&WkEdj4~F1s3J05Hp*mG(J^J=<{{z94JC8>aG2}%(lY3adU7lwUn_K(|kA7 z-(<0=FT03iGeMt|$F8uV%cQmF(hP64v{;^h;3XogM2sNIjY+2${lYc_)Wi+9Uv zaa?XMm9k^gHf@#cXANJJk>%bh_}Ay$>h-DxDgdiP-;eqS9m?`liA(cpfTi_5hAtRO znl4vO!}&xJX4ow8I}TwyM`dslDz!KI_85tH>%Ir*k2oRVT-75l3 zWpV578h8GmD=xr@%26WsYe&v*G&wUMz|acUv(7146$j(L+?b^(57zh4tas(_W`_+F zo6)#oBVFf&EiUphC;P_cvZ#n)x+* z)iDDN+tS-%sQ(5}qmi1|UL}l)%b%5V-yw+63wCzggrfWlgCz-Ml2zkGDWO~tGUk<0 zH=6);tjv>Jb)WM=(V~ISi1%&8~&Qpv*{5Lp_Wek`rFl_5S?C|z@2%bczRH8l9qHeTq^72)#?$_P#@oXi@ zgSit6t}bs^yU$Yp?I$50;`H=Fb9!5p#>v@5DQ%JR@IOx!tRrLfPdU2hR?V32rQW$C zHt-MHIz>?^4pdL|RWpA5;*{^#)02T#1R?wT`9wmnk+gL2?N%M)CvH->VeltBn~dJd z0jK!{xb{~>o?69m{>9Clq#t5p5G0mP1+t*#f^%FL9Z!fh4$&)}-h9920*7CalR=*= zAYrH#{Rd&U`{Q?N2U*4N{C$rjD|FZ29Sk<+1t_O|4%$(39y!oQ^pLxB(tjjd}0FSQ8W{J;R|Bq|;|_<9+XF_?TXzdDi_*t=FBqC(R?; zd3vLX9_ieY9!ee=!LcL!M>LjqjksC1{xL+PoKt=|yCeWEg6+%?u>_O~u3!_L5JYNH z)#72t3{evyGe_0~Y4v10rrEVO-w%wk!MFdbw+HL&#BQ-6_pB*BK}OaIYI(DR9=Dj( zx!Fv_AAe~>+BV7rbvj_(qFryfaSR<~6Sizn&t*G_NTG--qJ%{Q+~2Z&nLdVcy0q8L zK!)z^uq4p$13>%eu_N?P# z(;J4f*o-O365xiV4=xJ$zr{A%^jz-hV_}9;NsS2?pMSPy9ea+DT-gZ2G6-9*tY|*k z(t5OM?1IMmu7?`h;4xRMSIC$%yM`(JDB6gPAsk70?7FFonL;k^)o{@PS;zO`vt9D$ zIkO?voBK?TQVt;fk3InC6X zgAZdvMhJ{Vi2sX64 zv#NJ|m~U#NBZ+Fx!n~3H-?%IPNX__-h(lkK*9>&27pQRQLCJ{10KkL6iZ49`1l7Yf z!oSj|D`37vdPR9w2CoGaDJ&{+n!yz|w`my_z=I8;c~2pI9uaU(>?``XadbhXCLBE> zfQRniZE6f587-1U(+cA`aS{21l<)BT!88#-oVlnQz!eI@C4H=-<`yg$+I8URNU9kKrkohE ztp#vm-i52$UVlN&J2^E<58p56QKA2IxtRy7#r~wgEXLaQ+%ygkbUfvJW-uQ@+3+EY#wb5ce6+A& zr<6bu|JsgS$>GMuBFaprA|Ya8PwO|A+yin8Iz4N(6p;~#X+)4J$i9T z!e=0^pw2?n{=;m*70@ZRr=G>4V-|0*n0&rToR2Y)CpCpA$bVBV#T_nUEjXlZz}}q` zFIruDb8IxK^Oi}7&pU_?x6_rr!=YJ`l!h7Inx9-AXw0;_vki*~O=biY&aQaP9Gs-i z3T}c!R;g}Zh*>X8-d{jmmvgNCK}zqvTkr#}r{IXh_p;=m{fj>yzMLX6W9k}wiG2_C zr)w0k&awHjxUks*B-?$E@0%{pXK(z-7LVBn8PDY0B}hx{z)SuO0tcc6vZw5j(?JGP zW^mEIF81YPKo{qd)NAj_(bsZqg&Dpdg!qtNJXa1lcN?8#u1pa1yl~H(8*#;(Ic2%O zxA!PP{Ywe?d!WM^a;T2*I(8M8M9lp-^F1WlMms5$k#IQAef&rf=Mj(=4px(`wv zY9wOR*$JiyT!$aXD*yb+2Gqxhls_JQ80DyNE-5_TBK8~3!!ahvP688!1%rtMNkn{M zxENdZ(U*CmSZ*}&&$Mrc_V&0&q(&G*7O@-uI)R_5jANj zAZAW=M%KAAp-x{@Ir2zCt>dS>^1)X69yN>7{ikYglUZqmk@g5&Zie(&(HB}#2gDqN zE>R?D%4Ca5_w+7VB&jEpK}D32-o{1E#vr~f;-4O*eBnO0@~VP^KZ(A9v;p%#=JL*1 z$dN|^9I^l@3otm%25>P-fC4-$<*TWQsJd}TG;l{19xbUUdLSS~MYW6OJ-tD&I}bl8 zIL|nL{=hDyUBAhSG}Y?T|CdZk zkjyrLsd41E*A;&ZPG)bwjywTd z)!LthDXEuxf7p8{;}I-;Jv)0y|7jwAJ36l_G=_S4!jyNtxKP{04H9xxVUP1jDGi+ zWq!JHdg4hcIU|yrYs&DTZsilO(bccjLz*Ttz-g>5=R!Pto`_fSe;cEe zMllwf?)-QxmdjBO{u1P0LJu9Tu7ciyaU;f&SJUJBLW698kO@N6_EUDt=lk>IUPJSg|1f~%uV1gDGP*gD2!hYg@8idJ@DtzX4PG!? z_S!cm;`;L+{zXUOe)6ujPkz+{%(-SWptk4Nu1^G9|OA zv6X*2rsdPjFos-`eKcjo>=!1*Ksi_9y)1mE?|+M4ms@69D!54n+`eE zm&rppD+%r)jd_U{@oiV&pn+YK(Cb38uTQtiJHSx8z9ZDl2-;$50 z2dz!vT;EQfQh>abMGl3CV`ofRYK%r1g;_^vu%K-ZH~g z#SfrR-PDafQpEwwG=O|^Qs@Rj(QYkZghpgs2SJG=)$7C}S||-{!%t%G?d~<)F&&UL zgbRiqoe^IXROx1=jNPGiS(rxBjWIpJL)OzqBEkd#Y=+7e{P|Kg8euE{=$7tQ?8WL| zP`AsjE;122OzXvHGSL7dhkBgsv2njYst2^7spR@%A{SqLwqwfr_+mOq>6T?s$4SRm z)jOmJm*T9nfDgu3?8npYN)CSK*xRQntbyS^Lxzg*bai&WeSd?C*I6uKM?96b$29<0 zb^E|#o-Fs6Kd?A=vTSg1C~?)tRJaOgp<$Zgcg-Gxyhakxq~Bp)3|m|=l=*``&I4G5as83@tUDfxJ7F+S2X5Bj@V$cIi;6&i zdaIsvQpzGfG%l|F;6LdXE@2eNy}U?81BG7*wQ~MR-*_huwegKb_P*NA3EQVAX_vwv{-oQ-(^aI-&RlwWa`{M zz2WakR@7fjc^l?nU+Fs;oC}-3yJVL}x4%nIw&b>7Vp!p{d$?hDa>#t#CICRJZK4f6 z(;D)?If>%=hoP9dHI)+4%pn27QnTc)Jt++xeUd4$h~gBv zy{k7%*aP5KcfbrRZ>_Nb59Y{21L2%_(QAC)Bae6F2+3uP3%03{duVj^@_fsRp%jl% zzrY<&l4A7%20ccCB4hgEt2TaeeCm88>#}X>a*s@|zOtKx{RUwTGKk(G?A($l&Zdr+ zI~Wrz^swj6`#5~BUm%7kmSpt!^cTflX+H|()OgDe5d$dS?~`dAj~MdxPX9Y^JP=om zT4WYCBB%A11p(yXyHRssXwy_d%3Hq%wx?B*g1+*zKDCmsWM^h?`Co%@QviYYNUxzp zHAVqaCYGQO?=N6WCDrr1FbZmL+i>Cfa;!ul+b{2tpC& zSTb@YPRdONOda63i)hL4uI@pae@A9|M?pYu5Ut(QofS+hW5L9Z+xyfw<0v|)9xPo* zi|66E`@?aFqZ(6Sf=|()*^#4@cM8QBKmDn6x!1DkE=W!+dQ{~hYj1ZgrvFBdjO*|q zX&WImWU^nJ{iU5U|3y{8^T#kTWLS!zN5`n%XBV_iE1PFUe1_F0I8+4pHxqlBHMB_H zF3um`rIRGgmvxp1kj?HBVzBiFyC)5daGjH|_csi?P!61kdLpmM773&QP0imP(l&6B zQputA(IVi2@q6?4SS-7+V`z78>Ae~=3bXyN8dQ{pgsW#SJc3}GsOwA9G<(83aWc%votlXxVi$n=a$ph86P&uD@(Iz z_PAn}6G?pXOz^^_>9LLn94 z%QJLR%Rt+GTea{5FwYA(fP$iYHT8(mCO8^4=XOzfx9ysZ(MmEk#)^_awUZ zsDtj81Mj*We#JjlOcCQ`6oa>0L|x(-Rgp^8^>a@4&RWe8d|uh2`^^R^W6sbq-qv)W zVGAvTp5W%}Yr@sa442IK!$z_+sval$AL(XvkT*`n85#~GH|!qX)-74$YPNMjaF;b& z>;SuJ%R(M+Aq7u{Ed0%R=`;5F-yN2Ek%0y-d@@h=X)3D0+1b794|=evb6V}mq*R1Y zOZWflM*xK=^ZXTp9)CkAEbpI>l_LJXr-5o-$1IBVsrH`hQMUiJ;jaD-W@EF%_|5u2 zJ$tI3HqSoW_`?8$e#G}y<8GD}-dqu#ag1gTKa*aEz7NTfh(;tk#|E|h9ZC&jOAwDt zq_}{0`5-(X<~e;FrtP(B-x6i^2XkrMmIie#ubO9>AFnaQd-(ngo%HjleoDKH(rO7U zG}35Z?$BE5#$}y>j4L|Cq0!ZTQl1a$J;)@(P-OyVn=xY6HGq(i^)-lp(>wNR;1Vpy z$O^O$VWpf-`&INM+IZa`$t*>cf_Go!&RNa&!zX|2qfN8XNWX=)=(SGi4!_?Z{t@L( zs7BI7ktUd?T)}){>iS@Tt0-h-4*~^6+MBeXyI-{6(XwBl}We;gH)6USsG;dKa8N>h<|Oc>2DT zVb03&HaELDD{~#ewQr)FL`dNgkKMKu2QIal#F6ozPG{&(CiT(^$&O$W^POwj>rf2I zy|!iVs3`&k!_vudO#>qjut9uPLLfK1Hk@wb4X}O5lZ%aZH%YdzQoQ>+9v?e)U2TK! zf?O6vz37IPyvlELl+~69DcF94cJ3<0E>FXdSK|OBrpV4iQ37ofj+YYsS7-vU_fX8JYN zWCn)6%yyQh#-7vR)%gAKk2k?t*ggZ7vb2Ki3!fGJ%2&IKK!Q?Jl)}B&?z-DO0SXb~ zQ>}n6=zZ1++9TA5o3GFsJA_HBHk-uZN@2<@FCL(sLZ<3O^j0ND)cZck!pvzJB^epu zgMSWR1J7qa?Tq}J?I>{|p-pyv*7t|-%=6vl2D8i_?g3Kth92UJ4BgcnGmxA?rwFww(9Xvc>*a2}LTSED=r^*#~_ z&oP01fV^B>wtHJt4fiVqada}u4{RDRz)F9L06Y;Sa=#D1&?YvB01^KR;76F$faD6G zTm)4f%^K035CXBr=jn@2Q~^<-EX9OtR&r1nBxP|{pH5q4 zBvD74Xqj-rl7n0zT6cm!FPd>&>_`U4dw>Y1dxvdgb38*#^mE{|BBL}+Va;4pm;8B* zn-4P8)JeLT#(F#kDZvd1Sg`S5sfc=>JkV?+7XNkrtLb?Cfc@q_-NlQV7hMmUB8h4$ z8rHv?2lA+402Op(3}QZG=W*XLFsT`|*e%_U)TLX&ZF>do^uS z{!}oGmdAT^ko)zktc$h6DiqIDlm1Y75F}#Cg#_Gp%GWRb8wo#Mp z0I2%V?J@cxt-Ky zJEACs0{>Q^HJsZZhKVau#MVoWhc)kjUpS?+ngI2e7e{0e@)y!otut{X^v(knLaWiq z7!3B`iTR?7B^VypR@S2@uEN*A)zoNZXtCEK-OVYb$Jb!Sx~0v>-$_Af1{Yw9#|ruY zlA#$dXZjO0QJ3tV+tKUwdA{0Hl`>ycE9sfxfE)n!THYTBC#+r|>)K*1th z{XN)?NLl!aL|@-;fO!XZmII7}$$C2+eJkjygYKuKq+xPYT%^Xlj$H1PZ!EnOQKr1- zo7@sV6;ZikT&%#jmOyFOuuGm3ua^3VgIS_cBz7#(-7z!53p?`1k2h-M=uRs5`VU7s ztTQJ!$biDP)OYA$Nf2<}k_bv{-aS5md6e)Mg}C0B28sCR_GN6f*VTp@DHJr2(BCW4BE{ zncjo)g?!GWx7sm%xw%nU=L6~4O|Oe;&z?LmwXFoTI<=e8VVBB{_p|V8ed5zTvUrSm zW0j`A8z*TKUl>Pgv5K8?Nr6-sVEwc9oMr;S6uMo@n83L8!=CwUD{ab}4|wEi!nW>B z^{WDYDENYZ=G62zS+TlD{QN0@FN=aUXb8I{)(>^O434zlcY~r2zS_DJYcy40s504a zn|%OF7{D-sk}}@p0w~E)2Cur=&G9Z?=kspcdWifl%<|XI1HeAGA}4^mt@lNOfOahP z<3q!Up2P$;PQN+unVBs$oewvxnmQ|@2$cwwL{!jJ{}jqC8k1paSpwEVKI=87qNFB` z!D(5e8#K1U-jaBX`FdssE+r{lN=87O*&eOA@RZyTY9S$e^}YRpgHqjTHa_QjY=jt- z6wN*f@^uLF44F3@gJ+jF)_#}Oqfh+Z*O*1zQ3T0P!kon7om{IJD;y?)MM$5IdyD{( zr>`b6;XOUtZ)bCXdsd6g*j8wUEtaU&wvy4avuaRGBikUB5sW3Y6Ss_;TY*VGF8n5* zlfH#5F?cHPX@A{r49`0?i1yF_5x}=|WTb`#U_$-k$Zzq!1q3luBh56_K?POse(|l7 znzQOM*uzifh&aU^3y=rb){Xa+IC^Vi&&u-aVA(lW z&)2kY>s$j#Q$9Fk9SiE~OY-%!7lpcxs<8Yo$DsxoOH_05mF*AEG65z+WFfSQ;%uhw zmMbLn(m59^3`@@~1V4t2%BEK0-LR&f=%$vhSV70qdMy3jDmxwJt@o=&_4t z=SvOntiS|oNOh~i+2NC3O+i{H?@J>&_8@L&Amoy~?n5e=M%&7c+ARHb$op%t1SU^S zp($#9Ji_h|3koDd~|ws8VQKi3rPSWh}be7$`>n zGuD*ErO@BM7%Q0SbkF?t<@k~cr zDW961XyqR$xkl*mix0E&L3MvT>_5Mjk`f|c=@PiV@w42&Ke|daU3GF@>+25QM)Qv8}o%HGM1>RhLMQC1IE&M#h))0hQujMQWzBDiF~RY$hoCUI9n6N=iJY(CWV#6o)2LJ&7|Lh(6Z`(#MKkKi!d0$|AwH?c^yw(n` z^Qhaz4s7RZi++Ql$g-SwdMDV2A#I9ptmB}L1^wjd7jFbCUFGYY0cHX~(} zD+}9#ILN~sY)4J&Rxi6Jn{3TWG3!<2O?tUft!c?ak>D-pikfCXThNrd&49Kuo9g%y za4YI)mDSD4o~_5Vf_bs^QYO1}p)$qGsm73V1vEU=9A@kpvW- zUIKnoM^JSGQ+I2F7r63)+fm-vuQE?I-w;eByygL~8t37R(Oa_Eyju%y_l1`?FsO>^0wm~n9Tk0uzGONKCJ2$ zR)7R8LO$FXm;4KB-Qs8X`-d5lp1>RBM`wDztfgdRF0|kDlzz-F;u6C?L z&u@nPgX#!?cu>%KR|jouaxxsl0iNrPHVy{(=y+7n&R;f~Iu3&so4r9nJH75zUtjU_ z*H`@f&4{1B8S(SUTYf%yThPX@`e&2r>;4!(;U9Kb&?fzHwbQ7>IUK=3LEHK9+hqTf zx*^}vG_JS*dTW1w+5R^=_0|vj|4;n(eqlW@V3uoxox*}T20mOv&jRe)%;q)>w=+tY zQC?*!-Y?EEsrsbl)1sotG{AkVC4Ut2{ zb=)5_%ceR&@}Xm+2Br-&6oG#R3#d_PRQ^6JxDbK7M&UY1Szmg%f15!4bVpa;R%v+Ja>T<#aBz|pdMoY z0Pc2$-3NAL$)ZkcH4=%SQdU@7hgOFB$pJZxBWMpa&g?nRKLe*AsIZq1nV=3|c3Hil z>-DPMtb+nvkGnNY_yYlfJqJ~sGpwv2%eB7Jeioic2Fi3zgQrk;dS$1B?#m0RsY_(fE!>f8I!0h51*<3=fk6eg4Z4hA1Q$#? zSfQXKlLe|qfC#=9(-G71Azvq_XWi?I$&_y9WQeNr84=~xA;HfPHn3ZzKfsRn)l&rf-*Ub>t1rAu#LE4G? zh+Z<7Kp#AKdk)HoiC{>0V-FMoMuz-XA>ln(SZfjIdSrns83 znJM`~6Gpc)Lu+bq0iv<+5?ul-=6d%PlpTh{NQoOpY7k2O{8e)F0>})8S3u+~>JNUe zn5UL#V?%atk$vQe%YDo99ki7g=@b$-r@*Z!#^5=GD%@HF|4t~GMtr3S1QBSmFug5i zFCWM5aLigbG8P0Op~5LclJQ%>d9&6;Bko%Fa#&|H&gyM)IewuK#Y(Hnag7kuL6cHk83)q` z4E&!`PI%O}Ovu0-0Oc(>`CJBjG zr3;Y^Wngsg49A|Kol0C4UTiV2qBuYyNQvV*npkMWhe*{AtSUy`;!#nUEc%?QVntau zV0QC7a9HiYN7k@VBTZ$G_O7ymT$~8GAnoL`Da^NorII=jaL(c7gurZtf`pV#$ZTUo zE^Q@{yYuL8dJU|4VgOf&o2%5#wd5z^?sLaeFDJ{v(Grfn4yRF82Wpky1hjge`ON1@#?6W*gQ$urr+f2p z{XbG@kGz?br_^sqc~X1{V=ec|s zQf@_A7IGS7cGHk(ux3CaL6qJZBT`)#=!KJobDv!dUp>!*F z=~xcLcK`w04=tDX(OGA?Lx*wz2SiVo?l#_vcmuB^;UtpxXMu` z(1eJWTrk+>_`ElHH{t#pp7l@E(m8*`aF+&!ym+a`G6=l+Ew;I_q=bZQL#1sZdL#rV z0lzs2EiC6je8VIQ`y`@taPVNH{UU!B9+E7ISgqJLV{pj1AVgxQV&W&Q4^YIA`N~>@ z1D&j&GrgQmg3JvZ+dw;9(T_%SriW_zKD;(^~J^4bjRg zU|U$rDxCW$VdwGbeiNB*W;S)IzJSeT9sNEGr%EfeR>pT4)~CeUUs50BrMD;bED}i-Mbj-57 zNIJ(FeXdZ-pg&g|)1zb&81mH=acHEJ3kv?R_V;%kWB1X6{3WBjdTHtlEsDV(T3~RD zPku=pN>@*i4vkwHfUFTwwr}@IGNX)_D_0Y88IhJ;9u)p2T&1II(?vkdZ(>-^qsoisy7=y-v9kW@BjEm8WiA&=Th`Ap7C@y z@?}=DRnr~Be*gdg|Nrb=ZFAH%5dNND;W?)18SYZclI?RLX#=E5AOuQMUK*~R z1j02X$)$I>7E06KUdg*_z1XOoDe4R}e8|hQUTGh#v@6S!?*MXyJ%9q?HGo<37zD&$ zfVe=dWq>1uFTMm^BJS5vBu*tUh#6{K2S~hb03==mfWoO`2;vO2RsiM*zXC`!6M!S9 z4hCXko7ON(5ORRTQUFYyIx-Lw+Z-Tyu>eRcM*wrDjuOPg_G^IT)SCc_<*gd#u1{A% zOl;Qxl25+@NG#U@x}AF)#N@;~0EyOJfJAEpVCmHHT`exiiJJh4))qjbwGEIvb=(6n zIq^O~a^em^V)+1I;ncAUVq*IcAUW|-4M)WCdw|TT<1vVd?H)jK;yyrP`2#@Lr%ymk zY@Y%opFRUfET02(efnc9E{W{{K=SE}7l4W87@+IapFm7>D}dzGLx9BV2%sAEi?HGfNlnjL9^#50x<*Xy1$drKebXlAnl+<&;gzEj=bc>eU^xH;u2y)tRmQj=gzBQR!?!1Ai?is>@w;eNf5o+$eFxF2 z#l`7~x_h2WK|*%{A8~ooEDWUgmdw+nQGa$kIhm`DG*<)C>w~DdVwR3hkI!NCV6A)_ zmAd@ld_JwW)Ug8x~Zj`cy)Q3h`(}SR98#O(6Z>9e-G#TeH#4tl zVQ>)K&$nzh&|7)h(KXCpg0)Lp_WY&Q3SDu?p;b> z63gL!U1nG8r7eV2F)@~thjm}vk>*XHj+h;vU(V}$WJvy$;0GGX6pjdzv~fwMVMIor zHIxezBrRRzvdVP`Fqt8$vsI&}(ve$B){?Nch_{uvuC|VOS7Bt5&kbc2maejKT?LkI zS86z<4h^?tX()>}P0=Q9Q7KKsrFBV|msk(R2dxnGFlZg1TJ9Jk@lxl=qJ=TNvWM#} z7)$Sm>}ufujVo}$KfDC5YwF9jU))#wO7U{P-!-hS$4NX~b8cJIn{c-u4B@>rZ7mIA zt?$rpM%+UBg_Uep9LB=wy-^BP5U)DUGP9?rNYD zDUFptQBYd1E9+K<$(3nhzoe|27baV#%zArUheDWynNpaSDKm@(Y8yvm^<9kaxiEp3 z3hRAzZ7vUEE^88|(Ka3?2vWLXsBiJ~m>h+%R#=||pgkF8Hb|R0hTLcy4;0^J69C3s zz{9kRC)91Jc{7xTiEYlT4_@d<(LBr?#3|0zGC>c{FmcE2kG0U|!pwTy`p^o?skUpw zgd!j5!0+zTFv(OTO-zW z-KdogFY$%^s*;P>s+ycHuwYfiv9kx+xn8}#WPeo6f7pmrCk@rZ^;@g0o!aH)`Vs!x zs=K=zTYHj?0adTsoL!CVP12f%GI(NT5CW3ff4?1nw1N^FaX)00030{{pQl0ICQ2 zLlMYJ&Mg4@A2gS)qfiW@G&Rw5!skoWP`qM|qO6t+l~s$FW-$Owi43muUobAxqw)DK z=0@gb=<7d?j7QJ^8uIHukuG|~zW~&5bOGq-0?^R~prZ>wM;CyOE&v4p00960>|J?N zBexR&`|&9hQuPKXGfy2mrd#wOUf^H|l>l08~$!pBw>N+RsFQZodElx}AjpEpKKaKuiBH1SmQ%XZZh@ z%gy%Se_7!!w+jppoA7jt(4ZR}2}-$k=i!ZSi{D0W$Gw)dCZ zUvlS_`(?;a1?hY~>&DA)pEh!BDqie!Kt$I&j{VWQhJ!bE2TFP6%4!pjWA z=nObljRNDBJkJOhoe>nfGY`IWcTQAaX>U##Wg66UcV4LJ&b&y|t$C5AvjR=UmDu?K z_xK1c%!1;haU`DfNO=*iu9OZ36zZ4>4zw|TlUTS(5Z)wca1whr1vICCb+X<6Txhr~ z)RDOpS>W)+xbHptm^r7icGN}i*+)t_6}7AGpwC9zg z5C}aRVLyOh`2P?ZS(watnc4>;%?+1@WL?$3>q3yLy*mZ&?O#60pk*mBYrtC zy!gb!ydaAzTe-Yw)Zed)Vj(5yJoo`#XDs6=i0Cqkr7p=~Hy*I^G00BGgZZx$;-MeO z76){hvtWy7gZDn&`3rxVRkQ;c$>>F!6taj1F4}uGa8WK%i}DOvG;h2jS(4y~;ft1% z;fqpZ7cCmNXu+sOi-jzDQM{tOf)y=Mu%a9y73CeKsM@MFKU~&~5Jj2-nPjMpFzVdE z(ttt%r5(+Bj~JhaEmxOe)gjNm<)OW{6*9sIDGLrApKdG<;{i7i_`Vp!{5EfO3@^sA zQk0JGwxPxRcF0yLjcUEVe%(NYs2x?0>s9d(js_l-LpOTgakX5f%eiZ)W_~wW<_Iq- z*SB-aNUS^r5mu4k$1XaZid_8p|T*`k$2G$c1>K;e%(C5Xp0~jBv%H0&oy(1 zxG~!Exys{sSf*At8>r%_H}pSZS^cLBiNtO0)D_iRuYHH5kv&lPX~Ylwk0MGGtke2W zMS4lV23d7)pRHhjfM~3`zt6UdU`2|Xpsgb?6nzZB`NVp$izC(ZLTYFf!`W~O%qhW- zViB|!fn_v`aQ#U@i+j9zKk|BLW$0+hz8PMsV)f#@QLA1z>llfE1k0xoCHit`{@*hXz z(YLa&CXvCVNy|X#I(fA=T3gcEn%1#7baaa6XzZG#bsddgleC`A zp{G-B9gSj>G~dxkHc9)%=J1P7xs$o?G_CJwOq-+)Yz_mRGITV;P0~h^Hqx}Q&0(xl zeswg~P0|8K0yu^)I8@Kprgl70mO6Js^R=F71lXbwY8$?X#Dt43qOedCUcZ!x%c z0`}EBPF5;64qc`|jXd2T7co|_i0Jh&3OXSJAS$fpyyUJO0StrO)y_FW5TMVMk5|9&@L{U^|SgOYra3j#+%bJ$nvp^6Cahw(PspqyjtjerNO``BvW~b=*Hwho zvHr~Gx8Fpzf3rU}9&x(F{1r!p^EK$gXJa&u`0V5J2`Y0{tXw~34Xvv$qYo>@eI^frHKTWhJvWLr`ZWwx=4+jaPdk)y@a&ykZgbSHX* zrUR>JqRi7Hr7pz=-Y`T+SdZt_iyIMBEHc)XSVWoGnoSO%*`+abSqntdgC!7AW*2Be zGo}kP(NQ$DS^^Mdb^*S!1o&fa0ci5J1R%=n0Q)uzY1M zvw)T+i7uDc9agzSSzvUUW?GSlcCLH-v1>mD&McF>UZ#Xenb=hbXi6b1=IAU*H|EBL1Si>E#M&!ZB8}&N{cIl!2@+b}-Mx%}h zjV>_^2!wHi2%UPpVGOD%foM4(tkBhzBghKa&5N@lq(>51MNYmHY*k9N=Y>}ZSKa~$ zE8wsg$O;&|2xkTF#Td&AaP?|!iLG%24cp%*L=_rfbnQZOj6ogX_ds~3 z`)>OVdKjIe?BF(v#;;$!dU$v!BI>^vzQW!Abm{2A1&#Dp*}F3WMU6tlojrxGZhXmG zNkj-yqfq;#0;~M}b)(s;pI6^rAJ}qc=oDoO*~)#bSt!Iu}rgCd1Fo z-Te{|#-%_Zu+hQ-*e3q=gGYvGSxN#T?%{{E+V#E+0~S_eayZh_!6*oxs4H%8fV#po z*oE=#!Oufof5`i78O4Tz2pVVHO~MQPW?6`YMxqB*9pIqpuy~B-8~bPAwu2G0+(k_2 zI(iJ{5Old|L03M0Gcb(gXi}XnOc&Ii1AeJF#96^|*A1g((XM#B#F@);o(GOz8w@-I z`SqYic)e7-`^fY$Ekkzm1@14*bpTGj4(tG*LGtO@Z7RrG%50~6O!T~ zsbJU|VkmcUgczb-gZV9Doe}7gw@#U8Vn&=|M>eIeKXJmX$L7-EYTR_=Y59l*%F1(Iwuyce`k_tAhek`x9fyeygr-16Qp3RD zt+YYRHg7M^Pg`g8^Md%R@*Y+Q@=sZ$WYmZ4YeZZOIrJ2E$VYm8X!cpb9&)-hlf5V{ zu}~X1Vx#}=6-qmW&2nL9>-QF{apDOY^=qqjRBws~Ij)`5&uho6mKc(j1a2RiUg{1hoFp(N6L zE<2`*c~Im>`@GgVsWh5vtu@#Qoi{I=SG*75kK_8uN#a3uq^%NmrL>LERf85ySFp6U z=9Pcz593FMLwO6W7YwK3E;TNawj~rHxrm}=!Ss%w(#eE=;QXOTM1q$&x?QrOO4Hr4 z)>uew6)jcLWjx~=?hM8_-Z#hB82s)z0rS9~a}~TC%P}^CaTvqKfxbMTZ5iqA760fE zX32OMj=i?u#r+Y-%0O2gq0<$QWk6v%V(r`}Og&8MW4A3fonya!_oNmoYIP#bxG*uG zG%I}31{Mv*d4YZOf|2l$iIi3L9a~w4N1lWqSh9lyc*Ykfk^iyIO6)b;SY3smJnw2s zftB|&6iEKG@7N!voGkM_C{F;DyvH$2x-`GaHK0bExFO#Gc(^5q5YQyPqA-g67j6$= z>oAr(UF&uJH3;n<*s}iAmwI*t3(+ntsh5!p?BH;997-;>2y3sj$9JYyUDqP=242V9 zYphJKkp}J-OMAr<{A0C8sM-31-+{HCsdk~nLA^md(u4Zo#Z|XF!mb0%bL6!_|2*+M z2<`Uq^Elj*2zKOzAdWP&!QA6D1~6!aa{(6ZPi$w4`bp{?A5MHvAfICKC^it*?xELj zi4BBGwy!>f46)3S*ypHsRYI&&WTA#gr5#%)dR9W+;#HgID&}l4F-0aTTdeXKk|Dw1 zVaX=bROyCvn`K)%dY0vDxsaS9mmv|)VMv4o<84bKnWjoa%{d;?u9{>KJa)DqpD+Dp z>MB%pyYcM>?Ll_7)^GTiMPjPsOLyANKKLPD;=^wDE;L*agw|_lU#gj6{hEQ>uRM#_hL$(A) zhvXmt@09EFM*S35BpJQ)Onc;wE2@%MdUh>%*v^Hyep|#%FL(}<3y?@B}<#RjN~|( zZVArPW*H+{O*GUKp{#^U8ca zioDmt&1G!*wab}%y@V7IU2MP^NXKE+f1*WyJ<_mu;gaO|XW`>kFKV}>;nLF}_y6ng z>ZXn^_s)amcrY61fd;0DPTSpAzVN2*pqv(h)k&!F&hNHN5%Xd@#J{!70Kp0;k zb;{uEri{(*T_XOzkvH zwSUV}?HME`r()^R(Pn*s-w8mMy6+xw*y_H0H+@|kI$XVY3VH{Iym$j8L8b{{;u)WR z&|}q1fi`BvtKKoyAz-CcQ}NDtDZs@qbMPIbNMIeeLSs*7Oo3y8jbY(qkFyR(udu*{ zQIj0Cx~ki)f70hq`sENb^L*uk9OP5(Ia>7na}@F9!0pX6J9^DE9N3zc`KD)P>P5r) zMDa5oFw{dhY49rIv?Cm%>p8qWUn%KMMQ`@$ddartvoVa_^W*mT(EhTk*MqW+GSky| z2@#Hia7i-6q`FS*`prH57Yp}K&|Da=1~DVx;2EHAN+G1>kV1jK7Pc?Yu`{^5$TSxmI$|t zTj5wvicx*Jbp6@P4pz9703H`6R55!7bKJ=0WLg|xG0ZToTTF$Fl`evEwQj>&L_j|l{TAo2iAE4nf6FdQy>4T^B{;u~>6kzF`g4?*GqCK;L7Rc3M9?{7Z9 zt{gQj@cJ?c_~V~yaN@dtrW+Y?Zn`nE2Al{Sw})f5**-nt#uXd;9#`mH4Nw_G23MpC zwc+#@Wm#3aEUJ30q}FO)=xA?!ld6}PjT@Fh!;s9SthJPdu5__b@MlIfi5#EOCz0L% z6KsGbkk#9(+lVGcsozIDvHP^lhG3+VP#7A3Z=ne_94|$XB1UoI6x5hqxEaAYDy1^O z4XiYg4kNM%T0}igoI)Ja&>sK*0RR6&Hbw!tFvF$<>S8ogLNU}Jm3SCV!zh>#!dQzZ zJOI$k;+I>UL)EWx?6jmJ7(R)#&Q=SR7Q4%|$WiXWGFocY38?LbCP-pd zOmQCIk)m~wgoUDBc$}x#z7<&>hSAEKSonfU247U{SA4tBsJENqp{ZWCkG2iZqN~DR zBsbBV?l~PLhg~N|JvH+YH7Dy|gd7wl`WrL%KpJUrgb3QZ`L&PmOMLWK zT~C?97Gl{BvB6EXbD+24vvk@&{d_9P!jmbR9lP+kicrbAeBYM>AoI-Lc>XA##vP`y zW@kb#xM(~&m)DM!dfAj*OhcxinGJBZP=(YB2|w&z-EY${5dT-){MM}voEk)z`c|0gi zHjO|;E5)k0BBo!BDn@KBZ7tay@u|nA{Ww(HOgSiU#E9j}m;|Ak!3MU4=a=evC@xH| zqmp8JAGi^~GZm4icWNU3|L)}VOh@Mq#o@4YnH&{9MkcOjIXdrY^qmCk*>oecK6>Ce zMILuQQY`nfwMP^LCquZrsn%}DyT5t=X=w0XfWh18Dy}Ab9YeTKRkaFxd4V@| z^{{QKa?N<#bK)l>MCh)^hF}!}-bM3-%b8!d0Pf_vV4s zn+GQC2qjzUTdsLvx8{LSIzq~nvMghv8JY*yRz4aI>6vwjaF!M67`kZv2EOLIA`#=g z6pqh(j{rj7LaeFWjt@3y(TBrL$LOWHEC$NP0;AjP-b!e8!LIgnIX>BE9BN@WKxTM5 z<`4E;**PXuK!d)|d)RF7AyG_q0(m@1QWA;bVmfou&;w99e)ff3>tdL&txDlQy&n(e=q}} zEy@)n&#hK~;Vripp)G$V7N}Oe@a}2SjF*e4L?%G=Pm8`UsY?>Z04?0_Mu`v@y|->k z1UQf?My+1tmq-PR_C%0dCX-PvzM*p3Qoss3z+{NoVoBkubNGk8Er~sL?1$3@xpvn$H1{scoI}TJ zV!Cx+sR~|*I#AE_;dEz6qB12cXW2$@lid_3FhsvVbaP1*DsBxD$yOz+a}N_<_Ov13G;9Yi~LO6mkpWPmPJMa;k{j4BQy zN&qGC9=;-fUoJ1P@)|o}o@c|mghg0+9QBFFMnIE~hq;kZAUr7YDH9tFrouuyQ@3gunmz2Lno{T^1;eg>i#88R% zv0q$UY{6=QQ+g43g>R#K(J%OM?0j&?bil*(HbdQtRfOqO%XoBK#uqpkl6;g*vYC6)8OnZd0>mQGUq?B&6SXS;`pCQ5`YAEKC{;&9uY~EV0;cG z$;}0s*QAbkC5&AGZ>;ECEWS`CSgpL#l5;n1O9#H4X3TWh#nUgu^14VO6}6XxMIkkK zRH@UhxV;dwdcMy-qI4)Lv?#3C@ovKs(9!Wde}5k>u8cx^BeaiZ$#_8Z@tB}tW{sdk zldT^xjaCbhxJq=*d(CCH+c?p1y!XD0L-$$EiI&>oe>clM&afZie=a4cHc$Q*+c88bM9Wgb%sM4HD=lh7>0l;98w*o&|0^99G7&73F`MPVmy550=CCN&Xc5IoI=_ zPV;fq52^uWgWJSFri{cvVdD?UQ-pmAqjZNLc2`R<;SpcW^*q8?^&+nrd{u_8+K5bi zJ+PXv<|fS)Qk!j~XZnxrGLShnL@J}Esy`y}P?{;!DWAR_^Q?^=0rd9V;q|q7XazO(MI@ zNlr_1tjrG*^KHslZhkPzS$&v%xtgb%-QkpY0*pi5uDeSfuuu)kdS1b^RN3fG8w>A| zGD8iAU)JHC=QV2khlGR*?u-~aPt$vmi(oKgWW@X00NTQPP3|ev-0+d{u-tfJQuHBo zXCNfgk?cELRKP75jPQED#5$Mj7X0}BVikpI0GODBblEL9pYPJ8a7(dy8EA@0(gwHb zBwap~#i!*I^*`#uoi#fR4@2p>UwZ7MlSzJ*9kYx&*vRQdWYeI<7kVa~l-VabA?2Ab z*LYSGx0M12g>EWyEj=zYxo##*F{-hcE0lPd;h7ZB(k?i`R^9!?k=fFWG}pp2R)SfU z2xgqYeKO(dta9=j*7w_wQrw82eps&-%MCht&FnhmkH^?=jCW%KjX}!9LJ4?VqRY&6 z{~v^dx5R%_wDn`mC+fbRukOD-2yBo4`t>lR_^%gu5uP&mq3VTxQ2!qP{g2|mSjgEu zCLbJ4#L;TVa&(Q+=amu8pi->_{QLAVxLzQr+zG6YLk{Oo9k1$CHn@j9RSoA9;GAbU zbDa(y_ii^V|Fo;Vx$k{tjnhJ^oEA~%w1`TlMbtViqS|Q@^-hbZcv?iw(;}*#7E$-K zh{~r$)IKeu`e`BcPm8F4T2KwtqN<=4RR^`GN~lHELM^Hq>Q~o8eY_wlB|RIkbjs-6 zxKS8!vk;s)uog>9H;w7T61gR4ROWnJB6@;ah&8!ShAYZWXmnI@&hbnke!xPrAKVb| z3D6<>1wCAFeO>D0Id_78t(4Th2UMS69G4zZnx&l_EYcw+NMM zZ;dCOXEf@xdY$->*6Yi*6B%u^2jKydNTlEdkCWF>MO6t-)M}3LISfl-i8F2muw-pK z_<~8oaIQp%X0u3(e6ITx`I6%Ndbn8+QL|=d4#WXCA~6doUf(#+h{->3R&MZd<+%Mihw>Su2EkhS-{yROhyD)zZ$T6AXZ*^t zU^$OL=z%WL#oAiMXb_m!!OhR%&EJC|F3dr4)7<&IBh(vidzp>r6oJ_h!jfdE_5}Wo zuGx3}z0&bHSOQUL|EBpEY~6&d+F%`P#@ zYZ{H(foq)(FOUt|m&b1Z$_gBAVz*9;SKDlGU~RBQ%9<5e(ekMK(hk}%$YX~+Fvn20 z0sB>B{!T8ez@9M*JK`;rv<}-3wh+hOBGiWyS^31@LP`7hBLlgWP5in6YvmB%pk&>; z8hm3>MpoFMYEs>|0_%hf1M5TtzCm<5-avz`*R9kGOzPQTYX+CTI=2Exo20gnT9L2U z>AvX4uev=e{F+>CSb-G{FZ(ZCD{QD}*g1DkTBj{LxTk|(oV{tC+Tnd2zSBOsXkXbI zD003$@&nI0i{TdGYR6vFhtt2jIO+B}_7;)e;^jrVePV~N>+r3M)=~G^-oRL#k^Ozw z#B9KU!NM?{s4cdDejy70J(CuKumZ~3Rn@ri)Kx=063SSI48@hEPWc_KFV~-Y8+Q&2 zj5TpZI!hZz%>b+G-GExr0P7n))HX+Mg$ff=l00030|FoRVPQyS9gzr2>ltY!ER?6C& zzY7mT1t?rVN_#@QJ8`lb4^`FMT&P&7{c3wWyX#i<|5GpfLT=WylDhF0kI&fq$(K^Y z_(JXoh*18$VJ$a7=lO^0wx}u`E!4%~j;8CUyRDF?KIt(}6E^YxoWk$%@!vFGip_%o z)A~~Ovw?MG-=VG#RdufspX;VRz1*C}k41U@UORASY2>i_%xZwua#%xV1!swJSmVkX zFswLoP&SAuFVk$!=Q$imu#l4&9TqwgOcvNQe_3yX7F$xyY?4*JUC+y&;GwZt(L)0{ z29`!z$Bm#87H+qY7RpAlkYFD2I(-02NDdN))Yia?fy5ef4tvOj9S9YarIfrUWjgoW!;XyA^@Qh%RVXpJP} zmt-M5?4LriVM(Wu4p>U+YHhMz2?R#cy>1p_*A{1ywio+sYqcwkizGzVm1UPMFBr+I zG_3GTGpkys+hf(v6`E#1#M8HzVet{VvE>=IAcU&*;fQqC$ z#UB6w0RR8AoZkw9FcijLMZ5?th|1MX*-dmIgf9>=W|)fQWGY=m@1DoZ&Mdl#bG_~S zWXFB%&$ls zygxV6emH=%g61_C&)<3ewy7k__5}sb4a?#@%Br>@=eFIm2Yuaa8+Hz%vy^F-|KSlz zPKE{N-7ELQL^T*Rr|N6BZ@jWKyHE#!xZs;|4c))gd$Wr04v?}Jw;x-JuXSY2k;Vx9B@X}q0RR8&T}?~FKoIqu zUlA%a7F1$CwStgtV~ti@NUP{2l)>6S{2~;JP=C8So9tw_M5Q)(5OaE2W@dLvw!4RU zZzvTtKK|fX@W<_ufXLtA@kQj1Wp2A>ESm0CRy?VMp{%8HteGth9WArU2OFytw*K~$ z!~cLi5ZpE>k{a;^|D#cF)>ia?s`Y>UpWoB}p?cOC-{MgyIxd;ajGkc<-6!1sOe3hu zlT-A8zLN$r3Q_kdQrc%-T^~798V_ZDj8&PRT#cVi1%5VE_t{L^=SR9eg^BtUrRYzy@96!~X0<@Du%{XBLR*bjsn?AYcI--40zT3Q9pr@*j3qB9`NH{sf}BJd7tX zgrO{8Pd1_6F)xwP;K{fh*7X=S#Vz_ePZWT#hF$c>Lr$XsfeeVZGZT`#NqWHTfH=1o zwvERs;H|-4w5AnNotL>sNc_y)k)$P4Ln%I&jYr1EXZKFHWS6>EuByi9Wc$9f9t?+bfDe(F?I5F^wjnz}RGHLTdVgh5#8 zU&t_v20ep;$I<)b-l5BdF85F_mn^tdP>({uon1HocI^)8wmxzqo;tuPI^{wShwbHU zW0}_b_eOEvPJLnE7z5~lL8zxt&!C<|y^s!k3Hwn5@)gu;s5ekUa)P(84?~SWy_4TQ zWRf0-JqGmw>Lb)As0nHRIZXKm@#jl-_#8ogh580{4D~$>V7CUa_R$a6e?t9&x{BN! z&u$KOW48pmR6grYs!gXY-bs#lQJ*!rglZ0d^=JO`X=?sB~}dd#F)Xu@hF> zeC16ykvirg|E9(V89pd`*X^pdZ8Y1%Li-@F_g^)ucml5^6 zYhd;EIp0a%zt8EK@3qe*T0S@F!{-uorIXSJNg`81EF#lFQbcBiq>0Q5$q)aW z(eU~2-|U@HPunmM$Dhlmi2Bl|g0i+6L*l7Gs#OXFQOcwtRAnX5PP9QutAbF!`|f`} z$97lNph?pnc-boZa=F;?ogIAs{qz0bH~@A)iN846VDaki#&3bce%ZR?`vd9vfpq`aav*1K5v0MU4PSL}pyJhRRvXe@mYphbABl-P(NjI@5W) zF3lsahn=u}P45|Ae*x%FFD0{B`X5ZGH0Q0}>BiOEdrQR-47IYAa2QRVxivP)e!UpD z!U|pUhBWi5Z0Sk*2i@oWjw768_p13-GNLVOu^QcCIrCjN%%`%@d$lcAY%A z`!t!N)ZY=1q`8>CCbEjm8qIkY5p}qUCgkVl%b1>(PjzF?6@I-o4t873)$4Jv8wM*OZ=EJ;)RQ}= zb`Y2?7>-Pi9K*HHeM}QneMpTWq(yktTl)>~b6wD;ELHWzRb*gy(L<>uC-OnS!g|N& zXJGG6Xu(2vU8YG6fcpkiBqw6b1mwm~7jJs7DE%>+r&0Qn--3~|O40AnYD{KKFI)gC z9aj(l7mv!p$5TG`aK21v+u4K`LLycdOtMl%afQ?I@3kdU@J*+HHPh`TsWDJx2Lf}0$u*Yr z@V#C&ejde7;(@91foewL#WM<-as8nV-@eFnTy3AJ{*VbBg7jT7S|A3Ah*GB05l1f! zs-Jn?UjM2chIsVT;3DXq2ECJR&}aVYF8}}l|Nrb=?{eBk5dW^HxTHfZ9AqSc?Lh3L zjVGQuahy!-HZyKB6oa5l0bv9a+-aYu57HOw{&w$9C%|^6Nj=ky{Xs@Q-GANg?d_g+ zwTQQUlg%W_`RPq-nhmFo@U^mYqwSv*WE=@ds35b7$%>&DJk{x{eYZH@2y|A6 z6O|HEOjkYFSH8|#_JiDufzdy)JobkkzXJ)wu7i-88BUW`mKXHj$`!`^6>XW#XM5V8 zi#(C`iiPT(x7o0D=GBf0TYXzhN)lP8ZJ5jVNy zD~9_L?C0wxIazj3IlmIP{DE1!X6(FYqbgqEKIh zc}u(WqATlOP_P6V4=a}Y5Ydh>z9-)k*L$W$!BZ#tmTInMmjU>94R!~uvO0u80WwY1 z%<;B{E@hSFR%|#|KG*mCxjS`!aT-cNy-VZxA#iJ_P9T9_mh1IE$o$yWBg${3z+W|YOv4Y)haOh z1WD*Ryt3(pFJ6;Ut0qfR65|oOJ&>r5Ua3D!FWN)7wMCII-VLBYzbceM$tQ!3S1Ng5 zsW&VeL8DaRnjzs-=h>9$WjxHPB)wPXAeu843cY-bQQ@!yI$%VO#||Dlc+J6U4qkWg zx`S^!__l-ZIQWi(?>hLdgFklg#}3|b@P>m&Zp9JR%)udmJ%1g*->SzEH#7kM_6)=p zhy~cOz>WaB7LYP_A_MG10&H7gTY!cI3N5T@xDj*4MjTs!D{s^+P!phTv(#$`R#;`l+Gq9NN}UBZnFc#kTY8`__}t6dFqAor9ByohtuK69GoQExLfrcLB@08Q`J8XIxcXza3Yu#m4YU+e$OTbSATLv4WlI<;%&+6@oX z@!$d~c3tn-npbH%|1xQh0~q=K`ZJ}x&jlO1{ag9-t=jO zTYGP_zPDL_sW$7LdeAyPdVb&-CLQ~=4MlyEC3;WWp~c*dP(?}BRHv$mm<7>!Wxi8_99Vmgs% zjp;BMxA3rvi`yj1&H6D5P-Xx%k83(Q<@5PmF!(83-?YPm3V1+|m{s~Q;}h2bJA7+T z5eVuEgvVw&xM(dpo_zx1WFsZVJx97?WNNJjo~jpb4!2Cn8yU=T!pn`a4$p|fNaW4h zS6chcgN`%!us6coxY5{Pd!nokG~M1#6Y7lZ+bm^XsJ$@E$Ha#-Y9SP@BWUW0_*reK z&7YzG-_U0U2AC7bPvrMAm#`r$gf+mzk}~Mi6LFG<2~9H*1#-iSCmM8<{7zZ`V_k2xav{iI4g$Jj>|@gYwbdRD+8NQ8uFlQtW-_$qthlEUYg$iZ zymYht{*n&0dAduyC94|VPOI*P(Z0&elsTC3DBN_@;a@@)h9@TE)2D^3D=-!xXPI?x$Cyi*)E`W#$!{Z~Yhr zjSrZgSba04{7Jium!>tXXT-HLp2T$HM`0Nm{V*!4F8w zaq|ih;J9%N9rY)m(>@*kDxk`3*W-WwbW>&87T#EASU}iE8v?3YyF|mmkf>;*F_YfZ z=FmQ0t?%+;Zx|``C@f zSVcppWx6`W-|SsYPs1<_J@YTjDO77D)&T;Bm^g9(Bm~lK(-S2yjUaQDbO|JDwzd3u{x|&irj1!4@~7>n1S3@dSsu<<+rn zVR0ZOy_XwRYVog%u%*|*Q~`i+{=omw|Bess#EoMe6i@^I)616l|K8qC%m4fq|5JP4 zV6C5kIoOV*iYbe6CZ(ujGLCEq)v@?Xzn?l_|dEU|J65M_J=Z!D~t!|Hp9y zbwB?gVm5sub2|zsh|CM!<{z z?L?%L0_x69d~n8F4kl8*fyH?Cic+kQhozq&)dBLd4AvHLG0qfl zKP|*1ke{T4&nlL<3&*7O0TA@Ut0RBKNNl_H2>Ad20RR8&U0-k7Fc5!UKSjn~pbAyj z3bei@OS6IsS(PwteTqy7ZBzT|I<0@bl37f504LD{J&@N|7;vu+q6r%T>f7@_D6bk9rWtDRf7ST ztR-E!5Z8M^QeT%z7E{I)V2W`LkVxF7i%1!-mLijxlW(lP=L|lbx}oQO8CiyfZv{uz z21ZqAMCZP|wtA8x^N8Ix7BGbKcKdq(nl^ZY0I#A*DSi(9q(goP^#{qKQI!ghkofcFrqbe1an&>;X&=-nt(>sm^8Z1#M(BfjKm;%#4@BvJK zm`u3yAN4}ZnkNO~=diq7In9WDszs7}LJKR1+dq-TQ_ z@Xg>>R6?^95XBmup6i^$bsQut1fa>LDNHdl$L4s}lFwvot|H!S$UCMi6^f8z_rk6O zmJDqC*QJIs;ZM{^r3Y+NHkweu9D z*DzY9s;Hn6rh$6_#_*bzr>%0l6AZow!|ol=NCMwMV}0rdBU4QbQcOg}v3()06H|^w z(g-laTq(5jC<^?&R$VWgi%Uz_x}tPdyV3}FV)fbwV~g3hs2UUaXlnXX`7zI;Ld7cD z^fWy|1~f&%0ubWZoNw0>;#^mg-&YADvZ4$P4O147AVB9jo&hEM7-Q&mFvd>uVpo6w z=oirq5f+4#(ad?B14n+$ho-=LEqdUn_*T8m;Gb3@1RgToLYPQhb@ac`x3NVHGb|v? zqV1RwtGi-GM7Cna5@F0D9kUM!^yW>&frBGK0H_SnkBg_%BuZl3p>Zu}9|n-d8x2gy z^q@f@6VSe;z=FG%EGTc$DYj_PW)5tUyf|n~T7z{(@a@k4__``o$~8U6 z!~=7;I#%SQ3^-bb$sf1#MXRMY6h){HTeP8Mcqe@*$!yk$ifm9PYK*e7#HArtOFZBz zWw=vB`sp~`O6I&H6c@lyVW8GJe!-~53adhioH|6CO$>jl+F&%ny!cmVf}a2vH&tTA z-+uv=Z6>89{a2egXgh|NrD&ON-ku5We?U81}Fm$ikLh zdfgXgDTJ`4(5sR-i@{b5PWt-w)i=`UVJUKAr@i!M6k8h2H_|*bqX?@-Tj)z)cgmf- zRqWAwGAmN`?(QgxizJNP>TyzH0{E+S^BkcpN5Om{P0K`G^(Y?Hv`qL^{NM zUEd4m$)-oJ?_|^Cg6+`I)@3!LehJYZOZzdo}<-h+j}bx zL@6;eYwq7@L_2C<1XR=DM#}_GTx;A-Znat7#5?ZOp{;QqR~BD_T~#6>S?-Y~TQs6p zQgyvC0+~eX>FcuZHM>^FuFathHc~W@7j1v@z33ayA~wCji)LW-H?zR8=0W??fpPkx zF%EG}W-tR>J(fcngHMGSePl7F8Hx~H6A=-GEPtrog>V#z#d0`OS+xz)ihVUpv9Tn` z3x~3|AQutJGJ;upILjF5US~iwaEI(DeOP4*SCZ2CR29l}hLccBD6c>@NmJ35gK+Da zi^xy4n{ZvqH>DGAbPhF;C5UGZ<2l9JJDfupIiTqI{WqlUv#augaI-dl*&g1J8NWr4 zSqJs;H4X&m8!uVg^p%z+^+U?@wLclC4T_j?O}ED7v2MiAzYyXwqleO<8cvV~5ItEM z&`Dkzh&N({E!DNS3q^F@0r%0+L3gRxyRjFin5$;0j;hj71X7o`WNNtbII5p`{!Zq# zKCUpKH+?xvwLiyNBl|rv*aBEtzCoFMiX_kR+5C-<0nsGErwp5Pyme1hsCl0QQ9t?UyOXUl$JMU933d<9?_cbsn- zwoO$4)JawWgtI$C0sH{~0RR8&T}yAkxvC=$!1E&1Pf=dmwxm!c@uR)7LNSS0s3GrRNncJ`Upf17dqVo+M4iwktE_4xpn z=ccQ(Z*i_e!GrRLlpG@UJR%3<63LqSL_$sxjvK*zBGO@;Af6R)m$=KBgnPgBzkI$t zf`blCxBy zMzBNJ3kp0UJ+A=+w3>n3LT-Fj9?C#IE!7qM95DuS$UO6eA4I@}m=$jtrw}Z`5>{+} zIUf_o64nzlLJc26?s|-~8Jw40B3I>0*sWDYL!@jzg(kZqzNd&WXTwBBCM3fBESZlP znR6aLCUJfSsU{IyHRH8Tr( zbfS@dgVQY6pK&wwhUP3dW#JjyRkwjUDpeb2VAj59Gvm$B<9+0(_Mq}id7-Uki2vAHDw+p z_%qvJl*<~%vk=HB!29&jx;A0PnM>|5Sqj!>TnlBfH1k^`L5&a=&m|7!#oS@siLy9U zw&oK(mM?u0&8l_VLMce~OHx{{ws`)O z5`I})n=%=cMm_>AAq||4KLPSwfg`|?2NE;5!E0(zgN=nc5`cz)HaxJ5WRwdz9mzTd z);epwLXi-VsiNKK#^3I`AG(rbI`8<+u}I~=Yx!0yj&gPGbmhMClSq%=z3TPa@U|n1 z%4Y%+K6j{!LNOXbr~9E)6h7vn@R7eW9^bCTv`6iqO!M#a{|%VN z1`H^%e)Hw#`j6XTApXSfiW>)VSqal40tO6@!{B+^MFR-L^ES=1W)=?i#oafR%#EXT zgPlVId2vgJy3xqiVN!rm5Vg~029KJ;${DPhz+DX=s-@EODUY*oq=K@hfjAm5hnWP* z8W6JFH&l)=S?CGBpzffzL@5-)%Alt)%AZCUjdhP#n3%Gmy}L8H{zFcsz|ex0x$Hu= zJH{J6Jk><7I=~4%SsD&H@NHFh%Lh<%EGVrTDVCfyFJ3Q3?VEegi$lEH-x$>{ipEmT zLq<&vnkKg%Km56^gX5(kECOTDp>BwB2gieuVL6;H2=}n`e6RbSuvrxpi|EAPScUat z`{V*T4SC)$;XZ<(XQbL{kbp({KQ&d+aUHpvBrZt8T9Ld93~VRJyZSy5bt?@!v6Y^y zVCw{S!}B`yubiEj!PE2k43C)M9)-7onBExL5EWESUeeG_)Iq8YJ!CS0mkdC8Jl zbjfxkOxBb#Xee&7ioK*Trn2+8Me8?wVI4Lr&_k6i5JeYo$%01Xo~Yt;7C8%%nbYk| zvOKSkb2*Jr#==>QoIjt(fB=_inucwJZ*DUC@payxVczGoA; zPKwI#1{tCs9_R$~Bbi{ZI3y>M1i0IaoNvjr5NB8RzN&A^s$KIhR?VD1)xa8Ub)p74 z*}MdGdD$t@yDBatL%T9#X{grSnXgc*;7QuVg^S(T5Gwoh0Osb3m?Z{!@M6aYA6Nj=Vfxs+2y)Rc%Xd4Y4Xk z2a1ELyBroP#()C$aVM^vDF`Zbgr-dZ%3QX>uvHudwX_$uEV)2S8(r#WE><9%yUH@D zy{xPEy64a+LQZ+xBj21#QggclhQMqavwLnISz4(8NA36e87ly7&sNr0a|uvtdk=n? zRHMPw$BhukD)}#hBT3r)MKoyAYi1Gx9~Cl&1Aa>;v&DipO!VneJvrYMZF(8e)sTEg z;@JJZMQObjfF6-TFLF_|!w>|vGlh)xNTgK@Dh!X(U&BSV^HB7E8QI?lbk1> z`6P5{^ZB&xBLw!beT4t-U>`Bsc1N=OCn5t%L8#cU|9k)Z0L5nCQd3K4vgB`BaRqhy zq|#L2&OH7s3x*cjbv*DiFSYiFS<`?u2CwPC_(pKZ5H{uQR`DbSR{K$rYEGQR3@+qC zumE5N^=0w2hI;u~n&UA#JX*E3)C-)dxM!&rH=wFj)B}jB>RH|{s;Y}^8C5No+d8WH zL-Mf|FD!Af6aMq9%oOocfj&FFXX5*pajGt}iR@cwVE4i+h9lx&Y5d5akYrA(;PJ$N zLb^X3Ui)x0`nd^qVP$T-km_fY4ZSZ$Jn54+kiDkSnK{*Jq0u)PhAq)^z~G$2jlU$7^a7$R&1;gIy*`xFN)ZI{nw5wb7SNTB;0#;nbV#Dl{zL(Cgda z0v>jAE;p1>OP8=}7_*XzN8hTeRUdG!{@)JKVH>HOnK|`+|7xbsKf3-?4bxr%N?$c@ z-Z+nb7|Gi?Dz#;OSjn|pNlnt8`tf{NI!pDDmQP};-lsLEJgsAs%Hy2uFtS zTIrnUc}?bwA*q}l3Y|*ijG?A+hL9!Bw63exb!`gmO7V;#37%aF-OBfjq4X;E1+6P= z(k!c4;sODSfu)I@jhBjf zp*IMw5yCmyOEy<@82bJg;oB-n7K)AhLFhjrOp}*Y@~P|OtJ+Qt%pzt(?+>U74?05xDk65_rXnbx#6xO}PG=kaK;5Vl@0 zP$cTOnf&i>ckfPjI-RhcmpW;pOp8Hxd$+nX3Wglm#4X7l-{r+FxSO#q(@}`C2+@{2*o0b>4r92&n zjY0V!0rMd6VN|qzL8W(GUy?tgRSvomsug1^9pN1K@Z#$oxCn_?^@aHOAOO&L6&>XT zQY==IGD@@`7yBU9y?u`;r2s9aB}Y;5^ie$C{* z(j-g@m$q5SN=3t#JB|WfUNHvXqYsZMUkmqV7pqC+l!ZTW&vxof!ibL71XUlaioZo& zT91o80Pb`SdRaaJ^jlr%Q>!W5DiZ#XwJxqil1p7mL58mXvFCp=82C8&e|LAcs^kB9 zt&-vYN5cR1749U5`1XphtO@+nfnPgx_E!zR*6*?dppnz)$PTNyT+Qaz;m8-~n)Ll^ z05(5?KAHqU8i3C1hRkmGZ0rWy2GRk!a!onsH3-L00nd3wWJ3FQR7;dgiScx%x59xmf%8p z?SVYsQi3wxlimhvXh*KO3Qv4X$E2vH4xmX+EUOnCtv%2H13ViG5Nk z^Y9Kv%iClaj(6?2V~0cMn490yjSw$}ff8nJVj&1BUamhbjY)*Lq2f6CeOkF)=?U8^PR zzxr-w|2>xdr-w}Or%y&sDQ>8MCT#AyU%K;zX!@+u=We!Xlo@|tvhin&M0|?zr(QD} ze=@gC^Z*LSOOafB;^T4(r7UOQ08BleeT~9MwD=V-j3i?0j{t>+z8hFM$|6-9(wS7P zrhU-1`43DV&B8xugBV3HuVgr%=zY#9_Xc7acQr+Ke#%WrHsDNV*AbIS-EOE!t%$=M z^##?MUbm0AZoDNu=+FxHEdkD;c>mhJ9H}+v;SVgii&Ofd z_ekiV-lul5qB7ttn#rmbCFfo3Fp)K4Mz6^@A-x(tLS9}30Wa_<5D+xx?_Ihs|x^K zucP9pPZ#Be{9a+--@)h26&ezp*5xf?YeRUNdd~6wZ`R8_tKAvk*VqjJNs;c-vb-r1 zUqo76%tzyb#f8c0$gJ7IG1(#@x&`yQMJY>h#v`p3P)rT(YKe!@QZlRY{5m&tYb!R) zTWoO_Gt@F!5=Xyd9qR%VO)+YUr!SuPl$io_Fmb}fR=Fn}hwpKu|81467kG;=*{>r0 z+=kJ4mtn_G9sgbLeD~p@QN3PI!+-Q0@Lw5#;BK`JII#=>u>LP=H^YA)Y5s3eKa{R_ z9%cQ%zFn^+<3BS0uSfYeo=pMUEv6&ayP8iCGb2iC_q&$;{JHg#3BuL)1r|LG;1&K} z^V4$(uK7W*!VHHS*pfM5=OAp{EKvjPCinCj53Ba^D z9lgf05uRA$d9t8BI*M1S8yow!bI|%>*vXw;PMuRi3y0^0jWc+kLQ${v%dp*RsfAd5 ze|R+LpXXT}d*426ITUrDI|Hmhc1Sd3%s~YG?SXyooItIG&AER%SKbJw+M%k>m6NQ7 zt#^-4+D9#?{X^@h4~(2i7%IBhU=4sp(m3aocXzRO>jn3(Je!~A;ePc&37x_3CoSg` zfz^P<1DB#b0GQuE8MNp+H-J!pwLJ^^YeWmE%?@D&@k`;#(es6S^fNHP zW~(>W%BItIKn|gml|Pjm4LAPS<4q~+{46?xHWN_VP>Ol1OyB8tY?x)NNAG5j%$2WxP?84QEj04W$8ZZ8*cDVtsa0!}QkjW)yhN{US)iiX5uS zEXA~d2tataHqd1TnKCGt5f0e!~Liv8vhNgZzZ2$E0(Q&7H@=LEj82)8w#PQ4mmK+pLQv9vVn1QWqY8AfHYbV~6)Jhp;I744yO?`7Gh1LHdQs zTe%S>uF>?56gc`R#3v%qs;lzDFZAL)BnWzX4HggK{H;Uy%&g|L@)(lX+G;47wIq$iM(|&@e)f5;|H*`CA7T;c zj`g2%Wv8s~|JEzn`p={Mdt$}rS}ai1&C59zxuN?dEb7Ee2>5F&NfZ^+=>&#v1@eZ#`Xl$)SYO2NdckWlK# zFBqz_Uy~h;j&Y8X{%{XQLb0QvyOUlEdRJ~-n$hx_u%waUC%8yK2`vIYWP4PoSQIgH zHM2L-#d*QPv3-%fVm^}opN@;%L!rnbmHw~Sz+L$t>pOKl|0Dd&^#9}Nf74ux*Ff3) z8hA#pfiGoQ|9|Wq{cqYv^yl$cxL%Z+4MzmxbV|w(4iHL40t3=^g2-~fv{3;^7?NyL z|M$JGv(E<7PE#wjO{xNS_wMf9_q%uR;}kW&GRo?>&7C&ip4VA9leX0BU>e@bOE_Bc znfTKP-DZdk6-mFqxo{6zM~g6uY!s)uAvZJ6Ns{X5IWp{*;=4R{iM|NNtC8mA0WI-9 zAnz0vrT&^-hf@-3_KjMrwPz3`&$gjMko{<{jV|^a`elGp`~|t$Bj+BA5TIxDSOGh7 ztLEWW3}=wnt9F~6K1ACa{veu}!*Hy$YKg(0>COBD@_4Dnh#eY;%)7r@hBN;I=|d`R zDHKBo%38IgHXCM+i#4c(PwI9XUj4#7X~9vs)^d4taC>lswmNcvS_9i=POZHygJBF9 zLN!Z?dP#>`iZcpxhXKdT1y=@(@>lt|Bz!aTrejaa@VJc14rjdcr+D_IPHOva!`#`N z&D4%+X#IJw!Mti}7Y~X3W?HbbQ-J((T(L9?*=BFmPFrrHS21_w7ipRrYtb8vtDs;L zqPjQpZ#g5ZGL!?+;*FOt>+RDV4xG1d{FD2M&9NTg3_i|%JkD`aDHi2H;zNfpIO}l^ zi;)JC&1iX_!k`NTQK#E(blr1nz#UoGWGZ^wDA3E))>M3oVquq=VNX)6%k-Asr=~tS ztbA>48P0tC9C40DgKEt_%yGA6ZC)D%o*rB026`fZ2APjv)Hk31Y(v`~`J?y2|Gxo# zO8yuAWzPSDVtN1R{Qo-V|N15Gv#xhP!=}Cca4)2UShow~LLr-_IpH94*&H65Rtp}` z5tE$!N*+|Q;*}$nxuEIz$Wy0|4vP5t3wnw3m53;mK`&jRiW8CaDavcE7HrT!w$67{ zrT9^CS7_tE%%3Lh# zMY<#@mi!*b5G}j%#sbBl2NHj@BwV0@xV*_L2|(P7@B%wg_BY@F z#9%Cx0D&l6Ek=QT?MH!tLgef~kASTcOAbdI2|pl+yL6;OQ3NFTs|TtVAIrxWf;c2r zZ3QrWcRQ_=7!N^z<^$n z?AK~yCf#lvP^8;wwxiY%NcR|a=QD699QnXZZ~VzfCIhuWfvbzToi&~ zTm{90R3r>O$9LKi&%s)|Dq)xp9M!M)`n^A^PiYK-XN9*7dA>yc<>2lzv^DJ zFPeDTy=wRRYYY=ifa1lF#Jg)}FS2(CB(@^R01w9K+u%D8qL6W;dMy zoisg~;Z^4{l_88Kk7LyCohI->$`FY4aq#UGdLejTVO zy#^eOQ~_5ypJq^FRw3D@VBtJtfYHgl96}t-Q|gL0v~;r?QsaRbFE* zdFuwvC6#zE@+FU28^tu&wuH5`SDFw;0!8L$lk| zXY56^=vkInXGnj6Eh;s27#!}B%TN}Yzj(Kwo(<<}^6c6cqKfoZ%Si$j&qHPvHcyDj3SVZN zqD2}zYKJuSCD!l$>2-0IY_tj*N0EWFbQIo#)}vr=&&J6^c5Jc6?e*&2z7;&&F7l-2 z_>6z&l?LGcagGc;qB#?bwM)^24Gz85r({fzI}{c^$BzI%qWG7AAJ%Z6 z&~@PZ#jxlgPJ}8Z=3_8GyIdR=4*?WVDWSe)4iom*tI1#=U?fV@ z5QaWpE~L?7?mjVCua$tt>9df!z4}xF&{>jo4Eu!cmcdk0!7Lc``!`eccX{F&7G!x= zNtyA_3k0Ex<>9nYQ85CLfVIO}VG%&yunke^Wz+!xx*?9)lo8UUE_BsVQI`M3;=iSB zHp)b4-q{r|Y^;X{_aL(3kQKjHw(UtjhJ z#>=`W%ic-CwCuI8L+MwT>04U*t*52`11)`WI`jRV`s)9g9`NO%d`Z!K1~pW^3F5I#rzqq%J4e7Y#Juge!JF=ZsyXE^HdFsg zhr~Ti+V`@s55PQZYuiAMk{{;b0h@;q%kHxrP-Q!hty8QuiRO#wQHp&Uvi5|pWRCav zx^{OlLy&2twB0cWewLt$^gl#>SR4 z^_DK-b4PNytDupCo^|JU(UXXK%D-hwTKyj#J23gtU#msn7D`3XJSuR_A)xm5bEQ_D z9rbtkN2OnWxicul!Gg?`H9XW9z!6-X(RfKP><3b2FSf?ZAcSAEd4`g1&4mrZmW@+T9 z3ybq9VtWZ3&}xad=Vyz>2Vrz$GQMkXxtL=XEC%nq6GRvFslzIbw z8TB{Ofw|~C7y7CveE{ZZclmOI@Q!J1ay9z+k!C?6s9UCJ_c>$e+GBfjQz>o$KnL!2mM*9Uwzkgp2u{o!7_4O^Q$ zEs~Mn&AwHTlJk5v)cvL)eX6KvG|w5?4yzU0HczA~c{B+5t@>78mYL8Ojz<%y%y+6% zc52S1DjbZKpP=<$Ih#ejV1=R5JC(APQuCBH@EK39WO(|*-TjZifZu9F-xx~SQqd9_P^U@1yH2hq`KWJN`Yg6BXBI-PM>MPA5lUZk6FBsxM z+WB6v3bD`?(EvgIUZ6NQ0o@TAv^;BgYtMweU!LH;(9%H}B^o({!|nIW0}aKER{;^u zoS@8Mq)1cpJ}U7N3n5!9S)17%=yPaVg!N?q{n4MT4&5ze+pvFo0qqY>c)jqZc8B&u zAbovz(qEmQdpEGvaVH}gu$-yb*a`D$Tgz6^X6Cu%#$k&Pkp%VGSp*F8&w_YJXsTBE zN`hT57}bpoC8&tYr7B#&%!J$SJb#@pmeh0SdFq%lS0@ugOZxt3JYKrjo{20Xt#L(g z2{YCr#zM85y;8OOcp+OKN+DFh^oDaOo zB~hv&c^DQ+mKbp*5}7+j8hNEPZR^TMwkgZnITkGfE4Rzjpf0)5W>+~Ix@{WJLp>NO z)!#Oz?)AoeHJio!E@^8}mYlQPEIM^eOM7`i1_8#y%$s-#lN@@H;`%#mL%y;U>&n47 z&+Ye=3j8@AJoKHB-%t3nql0#{58usH@jfm4dx*_G$?HBcz}qRC^-I ztlK+4ba@N)n{m+!{i?IM!z-r*AUl{>S!o_BCk>q=LkT*ebPDNe<1HPfH>qC z8ln{b2XjdUTaO4zfn1Ni&jMags*|SlS*P1N>NF4TslBd|`xGNxbV_+L5@r=FQ{^PY zKIlf|P8Nti2y1or+h?#-))6=oALqva@%6{UOD7XFKTMNe2cQ^Mb2k+_-+Gx<)-XwG z`TSddCLLMu^v5xeiZ!|XEJZ?g(%rQuR$@C0a+u!h8dlVqwYW+6>a{VG#Q zZBk4-bQYh$%)7>9eS$ToOI&+4iG;CZ&X+5l6=0=h(wdDqWERLVlSKuxSfcaPK&z7_Z-xf{xKOU*e8E_7GX`p3r~o0}J{P9x?Egy)qlEe3wU7gbKq zj~mu=BMD!nimFw$DEI}R)HppqZdlKaD14PFYOAhA!7uov&guDa!+LH+;j5&mGgD71 zsgf~P)LB?lPszHV-Nf`bMUE@|LWDA~h(vx*c2#wAQz-skRt9M~NnNgVrH!kSm#)p^ zCsJoCT{+{Le4=YD`H9rcN>{=^Y??6&fG`Y2FC{pOxVd=%(LgpQ7mr^PlQciLzwl^y zb&#HejrewKL_Q7gb-4A|6n)I{A8eF2O9i-&=VSJDnYL6CK)&yQWa$Cvv8gv?G6tPN z#g~dh42@o2V7fNyt%Z_{*1)1obs~mZFEub-J@qa@%RhP>DEd@1VyJJ7T~TWrF%14I ze!MGdnkGkJ*Obz3JIF)W7%7Y~IIm(G)YR$)H&|2uD|# zMQj?9VoSm;k#wXFN8f3`kNt5uI_>o~Fmqf80qM&^LZe7ewtfsWtFAh6ER=>ygoza|T;t&YGD)RSks&F&q7jOokFe}f`l+7A-#MKnF7$dx0x42D3O_sIEGy4HedG?Dr2yW#dO7VEXT^I zD`PQFG5yN1GR`tAE4i`-s=6smSw)mB@zhPC$tsp?iKK24M^;f}OAK{W2yzjRKrn5Q z0F=3$8T=mr0RR8&9cxqDM(}g}D{iP~{D@;P0WuR0ogoY%w7g1Co7Q+7W1OH=mZ&9} zP@4bV+uhUMo^-NJ2fmR>CbG1TVy>Tv5nqxNu};yObbr-| zHpF|3(Ba?;3&CFA2}<&Wj)}Ojmm`+>|AB!v9*(Y+D*?Kr02^(UFBrxRn2y9W4Ot## zn;M3h_#ybHscglR4i@W%#<_?OeROn%f*JxxKygN)cz^oR`zSh{_WG+;G*&8BX|gl# z*s;g=yv8wTk(R#ATU zh3z~TKcFn?*{w#abkoiPrh6`Ett%Nc-E%=}HOQdpUIE&3u&#jU_%gybj4)$;ssfq zSrrFP2~i{gMG^jF;j!B7FhQ^Bm@Qa9U`atSn6 zR-29HYD;uB$tje{2J##&#g4C`Hnqlo{ZM?|EY;{+OQLh0m&I{2y!kL}o81lDh1PcN z%LgvzblWm#G`s-3Mk(IGa7FN0=E(_ta0eYy9bP3_<90sGZejB|1Qr!%uKT(ihskp| zmvAxZp+2DFM|Y0nP9Zn!Y9it;fwYBA_s-4_q$yy{(adZpo+Yzm3diLSm z`|bCSfBZRM6_i+7UW|Fm>XG4)VZ?xJO4Rz)X0O&(9^SAB=pF!7JEAK;Mx4F^04a&- zX;L-sOp+H`!kyPa^`4%w)T`>i-#bSalzLAZ4QY@7a<*Hm=$|MF?%J*f3Pfu= z4PhpPMqfb1E>X(c_C=Kt?a*pOQWP($rP#KlBX}v*6c3hUGfP3oKB=N)COid0cvObp zDa^!FuEAj}FrD!zt*cGK-4wKZpm@oYhhLR4Ge$ZB}FTo*Ks#4{99wOmIN*iE~A+&r1jcEwG{(+tH3sk5 zC)XJr7&oIGFn&dtkG1g^*iDj;9NAvqG3M=mMMz=A#9&)5#_|Kv}yMC_s+%!e~3-Vzni&gU4sl>k_?>IZt|~ zr;AcIXo*1nOXXkq53a|_sEwfzaq1^n*Vcp?irlPt42xciWi{{QYh%GjnwfdW-n@*; z0nL$y2+16PA0`2plvMaVEt^WWE6yM}^)RgzV&16JVToKi34WY)Rvt5(jU9x_|gW&tJ zd9c6*SJG}8ltY)H0Ix+97tgHLjnjjilU-~V2oNjdX{cAg=P2sVh3FtiVM}%KtiPZM z!8bCOnf{1uQ2qk|0RR6&OZ|$V!@WQ&O_G4+S~g4>sEUNzL&H`BX|Bh}wh(ti^&<>~ z*ZI&Q6SeJxtrdc<1HBJNdV_%`MZYH2u{rphAGYB%m?Wrzj)p9daSC?P_YVdgIs!e` z4?F>D1)e7aIuSfP4WBav_xWL`{J=K2L61U#jG=(eegK6E`sM-TYr)_qqlyBvXkrdb z6nel2WDyqVN+qO&gWxlmD59{lhfoAzj^Kh17sO%)8Tt?@00030|LmPxZ`v>v$KUrU zvaV8#lpsR5KTJwn5Yd=g(K1cyL&VxdLlYMP>$Yz{AD=jJ9ET7Z(7O1g6%BQK65q}_ z_V14;A?GVN7sIdgwmRpx%u+kD-ChEiGtCx7B-80T^He7;&8~$YMnL ziiFC@WuHDzMh}iXz8=Pp7}7_b705=A&_L!uVM2)e1{%&T(-lSD=PFyRAO2{i zr5*Y(Sfgj^)sQ@@S6kTQ<3UtRN*JVt(*GEH^W_W1?l5QZ%OlH?1QUAhAi4~);@udq|DvZYW*{BjUp)89D|fq-|LC8B|7f-v^_F=4-)bxU*VFPJeV+el znhF4UAOMnBxp<26AIXXj^CaZS?xsKv#xek8riN@zL?l<8SZx!ONPk^EKxDb#hW?tg zIR!UVa6<(*FmePx2h+QKsmYYRsZ(hbz%7z{cUJFpC+zbQ7*D_kwq6-ds9Ag zuy+`0t-NILlC^)&O@5^Yz!AOT3<&@$MFL>jWf!c_n--|~>Cp=1SS!a`Io61QKc#nl z45@&a9Y>Q2@Q)=G5LLf0sQ^E>RKUKzm`nk{PgejKlv4pfp8rP~%kKpV0A%Pt*3DW| z%>SEKTjl>xlmCz2HOu~|@c-M8_V1J+?f(}50RR6&-O>QQ2G#@n+B>Ku?96hswQHy+ zfrG;tyek_v_7j>1-$4oNtXBf-CUEy1vfUuHASW>ya;G1#hPHv~wnJMehq^FP{T=PU?T3gXZ6A0Y0C?PatIuSl!)glx@L2FkEPIFM1i$j_6ks0JPcNY(Tqj#T$N^%gz)kYC33DY zoji9=rmAY(rIH^L`9lcPeZ_Dwon9-0yVR&o8tK_6P4h4TRvXto9s;9@OMbE$?2@i% zbXl0iTQNW`eRR-@{}MrvuOz%S65>S(Z9gC+q6H9oUQNkbp$V1qZU2LO#6rRBrpv>% ze>a=IXsiLVVrdrC%cG!$m=3rTN{sX4RjhY%aG%ap; zN^GoT6$3bv-yjpLMTz{xvMnCJ*Wn5CDCMgGP}OCKl{>Hhmj~Vwlw0P0Ulbd68cm(e zP1^xqamlb2SJaz1)u43n+e%I$)YDK&w`?1&r3&SFQ(}|E@}OwJU`PaQNhD3bgVEA{ zMX;f`oQ%jJom}BD+W?m=SaiweyD>*HoIVqF)8r;}P^(E1d~O+R=T!MYa-3A<*XQ9# z@xS2z^CAo<_apy%w)1p%N&fe2>w*8jAO1hx168kIGH;o2)F$m-mJS6wC>GrRj7|n; z5#GWwmP(2T0ujH_4frjtzky~QwAzLxTx<}&^Wo`fCs%L>&n!Dsp%~9`Rim;1i{TEn zC6Ctr5egp^8}r0{=Tlpoz$LX63)D30*AJ^ufM&{tt*@_}%e_I@4X~bzA}Q;-k(WOi z-a3a6yOi$;(ZSd`UJ#jH{Z>z~{#a=&OZ*>BKHcJC`x`tW~+JsR0dI%S~-pbP|wUAoHVmQze^ za#t+l+01A`j$n|d-FN#mSDeHke^}_x@*ZBY{Nd3`zH{%lJ&d7H~+$zW~i57M&B;1`Fg?d~U+l6tr3o>*ZYGMrP zPzfDaWgMB4mD;T#Zz&=^roM>;%{CE#je0TsoE(VXMSMU3NngtyP|531AJgHV`g}3q zrX*dgobTS?_M#T0I~OH$kjW<;JLec!G-l0^+3y47qrrM=AV|qLPM_R9L*Y7T=Q+UB{nJ{A(0ikty-^ zR&{Id0G-mRD3?hx|9TU+(Kv}~FO%tH6UtHb!pMi+Y!YwEWHzVq z7#OeT`!x)s5~G!vHX1oC-YOprpcEfaNq86{S3w{m zSOMm`SSLs(0DTfIW>wT(Q?W6qQbBc9aB@Up!l<)U3Wg9Y?mFX+kBX?`GMuvpB6ajA zxRO_r*i2AGrCl5o`=P6A)Px)CT>!yYaz%h*HjY0jn(9JNeFy-RsBl!OE^W`U2Ow)h zm+ABe*>fs7s@SHxn&HVMsOC$8y+{Cq-`4!w!DmtB344G zW3ME@HAXsP=mhT_Z0_30aX9s{&taU$$cfF<-V3Y>OQwR<=N<{Q>IGwRhapN^+i)h@ z+kf`_s}jvu5@*Q~hD+wAC_gD`iBRR=dj0 zN>fj2C|^&{OF1pao~I`zOhtID&M_gMCgRiT_6|+Nou^w*&58KOCiON?>h1mQG%ap1 zUOwN;mDN~LznCNO$$KCHufkjj(r)VF{ekiFSiV9-ockm8WP{TVk(0d%Y*IrZ-6Uv` zLcP|ZWP2L?#s>%8iBgxb{Md!wczl6B9{vpR$H$)${*3YG5`O~xdHfcC-_avf5YmCC zDgMmxC&ZsQ{=BEB_ZzBW`TUu5u2A@S7Aj>*4IWPrJLLg2AAc%z`OS$e!{QlYD&=@Q zWskS%7r#9f`)v{^?1hkDw!+HwdYeFZj7rN3WzH2 zS@G^wFE0^a<;wG|dq-5xkx@~0V?~zi z29-=+<(kC-PH*l;2^-`o|7NTD)SS4%jJ5Fj&XRd5sk%L;EG6TskhUsZLrMd6f~H1( zRAj2Pt2Dskgj)czleu$q9-C>)shZ$wnrUpjarI+=COxmo?F-qV>C}adP8oBs0TIi= z@G@vsCF;4bufqaBKHq5T)(KGqNeRd7Lnwu4Tv!x!U>!qjQ2hE1!jk&CzTU05I5dz8 zgqpo2XKxE~jne$FXZ8x-g+n3`9hFeJT6rv{x*m2q#QSuRQ$#-4^CKJwlWU1}2&uTUYxbGI3F$lh zijV-sROpIC29yqaBJ2=lBxE^2nT#h+t8w0WBV~lsT?ZI0L=8pANm#whgMUGgL8JQ5 zpUG%~E%K-bWqXkI(%kiYJ31YBICiVI#&KQgtHIDRFO1Y_AD$k5Z^mR1WO0Q4Em1PE zPip1!Mi*i%;T=IzFMHZaUh8$g)$O%UyFD%E`($H*dhnyWt(5Jzc9%SikZAV=&0=AZ zg@U5#%5jI@u@UXqxQKDh6=T(Cnu*}evaX|=lRZs z8~gQj=2_NljsEswyW8)mVWX&hi+;iij}l*zwHf&ZTfk7FWMb#YIepnbd)deC)g-*P zg#L7T&GYtIpUFSAdyr43-G9UHTIGUs)vU1vn)zM!TG;4*B~P*eCMOAe9{TgRPHxHc zt61ZTV);utuoYAXG=eFlNi9S^Z+DNa76B4gw|R1=N=`wt>cQm!Y-lJ9@}_gudns}& z0YbtGQ_dL{%8DGq#MclV7B*^+$D%qEKNk!*8YmkBadWd`!fZRtZOp{aIT;Ovg{ZCC z9rB6p%4c&;rM;vHz@BB4i!TcEv5A$$w@-G=q^^QQY%g2DF!XY27e}pG=JtX{g$CSW zWX%;5r20jpj|+}}g-%#;`=|LsC9Ehx5=x6Aw0{%UM6Zw(i)?u0u~E<4a9%WRZx2BW zKqiR2xGaCntW9~5Y0XnwNZl9hV_GsA-J>4tB+4!9ghzjP@iwlfgv26QnltHw+AC#@ z2sIX}PZ-{oGuzl7I>RWOJCH1VtgpwLKh?su&CLUPxOfYX>&AEuaHRgCpUiA=q{^YS z7L*QX2#6cZ0SK9V(4A3?GPoO5R(k)7HOkGpbH(JFSPN=+(3ff05t2-l#E3KrOUAg& zcamq+gy67^e3d?l9k#y|Ix)k`6@`q@^{Qr)5`*|L`z1&FgPSHt{u4W=&i%ISGaKmE zJ#;DXf47lRbR3!{q=@y}XFEBj5gswG?tPO&;MJMsKDQblzvkyw?2d&$H_MM+{R?vZ z6I;MtDgJ-&1NpVPJJ{d6Bj~ln+7^uEq#tI_nXWY;7>5?CHV^uMeH5(k}Gat4L8) zY78e$!N@3m9QrXK7om%ubdLl=oWN;QdI|`Iq-W2SdMl%oB^IUMI&XBG_6s(L6B(`x zsWlI$E-xBJmUWBE5fIMoT)Sr0toutVnB8>;IX*U=ZsVk-oNNet$tcUu1GCop#)DFo zEtR$vl%tGw$K(7)Ua#uKP*)t~cM+_nVRS9;4M~WQF06PTjAk2h$qiyL^rPT|l0u}C z8WP~4xDgsJfgrz0^qp0OyNzaZq&n zXP!hmwSn;N9HFs_qzXos$_<{H=YM*NT8q&~4r7bCynV7}cg36;Yn7nByaD}HbN7$e z{Jv+gS<;88Tr?Q(X+9U7M2v$*!OSi?@Z34Q4Y4nR&qYJNufUrN9Iqt6m1-oURC(e1 zGaArPA-YXTuRf>`vA^WKP(<7u-MFysh857b0?96*FVG-Lo!FqTWQ9?67gtgMU5n;! za%p`)NTcenZZsooLY(~2WM0)Hhl^h3J^ha8Uoe!GDc*E$L<8b1OC9@30&9kj%9sG? zn8+kJA#_pI4X$eAxgU*|KV8ljh2MgxI9?c!3O?x)Dun@~Oosa;O^LYVUY1~nfJU|B zNNJ^x#g3w6nCb53))x15ZMw?@#KesKM89kPKGvl427L-_zoK$stT#g5FyE=#n#Ag~ z&J24;5n-5wi)6k?s^~h)ph_LQszh+oU!Wk9q5TR&%p%MqAK{QR$#4o{Q4*6f8xwlD zBAAxMOiArX^gDK0`ii~bnBjG2DAI=@4laU8kX&mL_mB1Fq=~WzBz~opWD|d@=KQh9 zYTCq?1z*(A$bOp@d`yR+K~ycVOvVOTqDBRY(CA&Jnj_fw!VRT~bsXGe6q%tx5fI8E zu3cJW_Gt{n2VI=c&Hqzoh52jopSGSp%jo~?!pnpH&pr8n%Jj9ufY|xmF(9<}r(S>% zqTh$HKZ;{09&(A98{zT>5Ub|jin6Q=Mu^k;4z+_>MLHJMSCdNBXmw&VnRO<^A5_;S zj0KGjB@uSbEVYSQ#x%(al-iY9Wm9MW!D|q!?zSc|G zdQ}u+U=3ch^pZ}6-5(Tk!Lo1PtV>=kSkJ2&>)?KDXjI8nfeF=6m_=Nw&|0SIvJRv% zyR2riJZ|6|qO99ar7AHhu% zNI9-L@&HNKR7*SmHtPF6yKCczn6IKBfdethN=(Ozw994oQZhwmMnNiE=I{#F;er%F zVS_NYdbR)4=1y+4g5(wzV$ngPoTxyLn3R2y5?`_;hzx^@d6Wa;2c(Cp?A~^2+ZALv z%5H)MjwJjMt?Z}~%4kozf%B?u>K;pd#MBlmNVLH+I}4x<2GN%gJRO#I(dfPruNvp) zjc)(VL5fw6o*BqsZ91O>kTO&xa%Tyu|6&R!t@Gx05T(I7YgmOB?S8k_>xmbq=b|Cb z8t46X^JS-TF3w(_pPlwvY!;-TtM6`F!W%(9;6p!ggGtP_e*?WLl`}~g7x|t~;?(~D z00960)Lm^)8bJ{L%>9bh5BAO;2B>Xgu4e*94T)eX+Vn%43nE$~Z@oLxHiZA)dEHxH zq^4=o_6z9U?6Azv?9Lwh%+uxU?ztmJ2Bvh5$u=FMMwlZ(mJyn7DWd-5NcfW;jH=Ly zL-V={Qr+<*WNxODgFNUs8{C8bv*BcthNdyea`gFD-BfDTYNcF#RRIUM>C_ny84}PgJ|oxr>&KNLqvCr=T*C|hJKokC#%dQ+t^GBx)eU-=y0THAyMqhIYfP{kzAa% zlUDs>Xy_nEqj_za9W1d5CgGVwtK#(8dGJV`W-v2SfTL2-B8jbDF}~02*8#%PtishU zBkhVe>W`A%T{7UR@-B}=mi9tn(Khh+un%Lw&(A>OE>xTy3-3c#KO5##+hQN&AM!8L zz?&Bx%tzDP**!{_!^+Vca0ZcPVXP#?>R4Okakc(BVZ$Df;H3r-bl{lJt5#=%yQyM zr>mginttpUJP?Hq!E?Dp0@0oDVnk&%`UhY*D$W2VevuhDZ)9x2dt%eU25|G{q*FdD zBVYOzlU%r#TW) zfLBJY0S04otytWZ+{fUr5lDU`H;)V6lDSu6eVCh*LjK&yD~Uq5AsUPB7IzU{96JN+ zl}Z#7K6@Lybgnf#0<%ZG4)Gn^Tj@Ri^pO6*I{_94z*_U9KQQ8(w%LlK&` zQ0TPQXr2celZ;v;CodVdZYqe)rK4E>PKovn*HX-h$(4=jnigfZ1`7?Ho^D z2|Tcw4!*OAe5Ct&w?bMg)wQV-mzibpb9TBtVG+kTzF-U>Zz)J-3^D7Zw( z2(E4FyEJFWg&ysGxp*TuK0cdgfGX1Nn3OoANDE{JV}Xfx&2W-sKin*ifvMKcIAY{r z#VCpC!Sb-{eJ{3Nx38dvIfP%vMqILNU6Kc8p^^QJDe>=3hdM9mY`zv>aztxekS&R< zM%vQkxiNqW#)i#Nz8Zdzqq>n1ONd4|Lk2$PuoBcK8IgnRH+bxio~T7X{gjg)gRDX50N9AG-?`C z+mN;r|Go3gV?DcxLkh|PwFd+w-q-9rKkv@$XSU{*D)9ei>mX)plfFJP>`Svv2eU1X zOq;d?%}gkdT@k%}h6BT=!?Br+{M&( zoPW~>GeV?|krBhbcTdM&Nn}zV5~GOq9?`l)VW1Z1uBfvMGZ8*AQ+;HFqv^^^;U!bn z*0fwOc_*0)#jI}cIygrKtkmjxNH@~oRFHb&&JWas9Lle`D&AY5GNJT_710Z22N$?t z%^8$KgLA}dl3cE`+Vea{7}E~6X<5I{Qt&~xqJWl|{h~hbFRn+g^SWr9==`;MV`@H4 zzwsQOrQo!V-g7maCKcMP;=nO-kv+`S3dZVNO6kXK5$eBM`L@;F_gTqxMHh8la<`Hl zdlixh3dfg)%7Ih>B{o=azLng#VhOh8klQ9A4dwDWErNqL_ytY4zwjC7BXMdF(^D#1 ziCHNGc}^5*0C?uhc~vjkuUhpr!B8@B+{P)^VvZ*i08QsU$0gVp3=#mSt*HV3Gdu_G zlf9OX=?~{F%8^-|W6V0j@krI!(clq(MzR0|g(h8+q zy*WrWO|ge#}cda>JwWWgCzOvP_!6x z^qv8IFtvDe6RPZY+k?~2V4uB$0PS<2(vg zU5HYYtXcVyG7Ix6r_?_|4mV3t9_YNT^-PAH&FB*7{x0i^OJL}wp|SyOmpF%xad3#Y zE$1LF(eY+kt&Mn&O7Nr76^~PtGQTD6`8jQV)a^6?){_pqzP=WJ3V9+8#XbwTd3KRq zx;n;waPs-K_I=?1_+b_B4XbKUQ>6rPS*AglCxb553I_yDxOH9vr9Z91fWNP4IJ<~ zj!&)GwQq*S$Z7`Lgm4gt!0`G890d;sVF)k$8-9fjidc%L;aUaP;A!KB!QEQzQ&Y@3 z`ncmj$84ape)FhE(2qWD!CyZPqmMlZ*1$Q1g%MsBV$d)ChY;pJ>>X=w+cxmC{VO;* z+mzIgwoBU8X@g{`*L7`I!>I=h%OEI{oCvcePqL9@f&csNK}w_^iMowaA!ya^CFl#wh`0;X z%Q(3@YZucXwK>$Hq(&BRt`L8FzU ztm@U;(F*e2s+my?A0_QH`&pgwOn-sqB}e*FnO_#Mde0^{I%-0Rr!VU+qieF=w`+ zchER6^eE?mEpg8`kQzoq#bZd*7|cBE-@zw0D#G?O25Ay^O|-r#-vSN^LgOU^tKLEu zOuF9mtvJUc;5K!pQ8RPpS*Kc*sbARRA_TU7HRPt7G2SRg3=e@;jND0iku94X43iJ; z$m)q(6568MwZqo>kjFt6w~xGH)oPepsX6=#-LxUMs#W#uZD~#h$`*y@C@py(CE*ar zU2KX%V{*=i!Bv=2XjVX%ANtX^7-v2Uj<4}0$LQCXR!^Mm(SlFLrC=5!2z;W3F}A#W zjv0M0dOOG8w=yGgG2xJS%kIs%e-^FUj0<$rfZ>OEIle;adVgXwoIqd_UeW8WmF>NT zU~=-?Nu?z~%g(rho#NrX{eS)bKP*PXW}SKR^u=fL0Jt;%^X{`!{=I4;B_bEa32&VpouomqI zO_#ojGrO`_{$^tb0j$nG0{_NA0BhIy2(0BGfb}&W0o7g>fxNrzW|T^z8(VxDRYm39I5O03m}l9)62d51$c1eF)+a^38W~O#L^lf5YXFXW&EzFsg@X5|Ck-*@GS`Jq4a8y z?lQ7@jth@qNOydCNxP5W5^e{6y%o3P` zL85#!s71;GgVXJN>Ec8PI7Jk|K);hq_d3Nnh9^{Q8Mj|qOyWrTvC{dVQ5`1g)Mpq` z9Che?i<3gPIcR)*9(ouXD4xyH$Owzae3{H)?WEbj-5-uV{_uYAp%0U8p2TO<0Cb7q zuVsKatuA4$!pkU2XfZ)|=4{Lqws|-j44uJf^l{Xud-$k&x*p}DH$1_lK|$C!1nw^f z#|KE?+uJ0=@{hmm?QMlzsW;Go`tldb(DN9{D~XFIEI39?9iM3vOkQqCrdZ%B6wGg& z*+I^8W;yBf6Bt|s{D*ykS*2SQnkGxz8FPAUWzfscNy7vF_K^ww7-_0a77m8``t67{ z!4!G{(zuO~a!Ui9jv9<6MP$4o<=B?wIxEvqrA@3*S&_L=nI{5D`=KAqIDfg^-NsQ! zX!zyFcgIj7nPHwXV(PovDse|;qjSoD%2!C3L8{@xvg3kQRRA)M_yP@4p;WPG+X6y7 z=nY@c|2K#_i>cpPP%hc-eEOM0A^zR zgN<)WNphDU2`0ENz^a#upIt9LLpcYtc?656yIt7htMUPDssMB=frzye3e`Cb_t$h7 zZrz~{tm!D+y4|O==qLPLg$4jH*3ki~M!u;I(7LY*(7LC`aO*bQmL-22^9FK%jf-%r z&O;clBT11zg$}-yX$mhdFS8_tQ-+cD4!AdONlpkA+eo>S`k;}9lOHW3%;J=U9+~3A zIAu1(K$6I#NE}Kjj>z$2uLmn{Z!|c1{b9f%VG?(;=v>5;$;^#9xK1a*d1t4)xMG(J zKTz7>gqVm>r{C|4_4~%02mBg@sw--AoXWJ)=vygMN{LVJUkhIQ`%q*{bPGFzfYyNy z2Lk@4U9Z{1d!IbSeR`I03o(hXAA%Y(MhUzxwjPU@0K0?X5XJA=Q@7jw=D^j7O= z^yXKzqEog?5Z2HVZ1oBz0*;TPB*!ex7GPITWOf=^`w9X%byLt%n2df%xw*_ej*y)M zon*=PboAQ#bEaIKT2Q}xacY%HHfPu35OD*KGOnh8S6lFkMqnS}C|TYV_{GLgZLuY1 zxfF-63M?QlNKC*{C?#@eO$rCZbvSPODOW$$>JtFW3BVm`Q{(cr%v>4R1U)O9P|Uok z@35dN`*eCprHsz4bi#ZjKhPlKun$3CAGL6Ldy6ra09L-_Q?*ESoy55R{Sd z8v?L(T{)BiETfVJ<0gB76ISbp(s~-$;i;SA!Pz{Xn|*EMB-U#-Mr|dogI!V8o z{0c%9I;wJF$##;p&N9Cw?Tl?s5U)UhC@~yYMZG#sXCC`-9pClhc<#^uoxh|t zk9RzZ$LCJeku*xU2|fD!%;&c3c`0L!92lR-Dd&=e5#*9>L&&M{JUfQLWx5*lR7@Z? z1q8O>`?W$BuztXP_!rKD&Vmf1inp^Sf)reP$lqn*K1Xpw-{&!NynK?R0nC^tvXQLa z=T4x)S;CN6&~zCbtgC*ZrZPVS&N78{Jm!KFFve2~zstlqP+B=2!2{-)AM5aK4)~2v z(*-v+#gtNnhFScDB$cRgaTQfAeYoRcOJn~yfgvrs5Z4UY0GD0-Gh%-YPcVVSJIM3Z z+au`#D0`?T-iQV3ux3$8D$jOa@K!Ln=%#WdyjGO>H0t|alrZ{OPdxGX&^@s(gbh_p z-9PWAA35rI4XbvcbD|FRx*|n7U^iS$WXdr{3|cjQ?J#3j3Q^<{w_ppe#+_1Asv&4_ zL@t7Y>bIOtiSN*z7oL;uxNDe`>ULHP%-4cP=L##$;}*ME-2p2kj-#29$`z9XBcu}G z2xWydn0xeMxcxrZetGG871j{kZc{38>f6X)Mh-k0y@O(_R2J!v`z16ksWbMG(#eRr zp-1Ash!e~m%rrF1?tRC@ToJblscAAXO-lL@C*bT&vrizf+6bwe)DS;Bfdy3?#e z9W@zD1|;y=;)x<4l}wAcz{$g9gMVOsm7@5DA}HZ9|6kZa9`H7; z)~O-V9o^4_aiLO18+tQ?h!L~FB@QkR0}rVbg(01fImOlxx@Oca>Ppw6wQvVHHlW%G zFWHN()sTgwMmdU-ajBJIwAgw~rzc(BPOtwmhtBU*9{smVqf5?z+~3ROe^hI=P5#HX z%Ky+qj;S9@zWC^hx%nSeT;{EnS6K?)q=IZxK{lx%%ThtIhez6{MDi(# zDIa`EqOS@Ea-JGvJbF+kRhF(o&3^mcmG%}v@-~E#IDL){R-aN+MM;ZId|9Q+*_M-e{Iem*XDeg z;cR!0x&?*;q>SV*rjea+c8Ic9R1{^x1$;{tJ<6E|$oVK=*6iN)TK#_aP4D=qpbNS} zQAb)*onUnwP%y24fPu^T`MEd;MxCp{zg4Q^7w{Ap^ORyDPZJsvem5|Fmy`(g4X~xQ z!IllSY_R3Yu*LpVSQOC#1btw^^PP@6f;qn7Gp$P{h-{wCt5rfBPe6wt?-}GhLZ7F| z`v!TR&>vFd*9Q4Dp%t54YiV+=Md+&(xnqz!gdU{G#|HVB&_kPC4>Y+R5ZYAa)j`^N zgx^EN7CsRohZ{8i?$LZXXFeKzwM$sNWB;4T@*e;I0RR8O=$lio;2Q9j-Do*7+A0J9 z00960qFxbztvyLzp+LMzgQl1O00030|LmPjPr^VDhW`pb06%6*S&bLlQWFva2DlLu z4~1w{N>t*(KW}#z%0tydZ^rEHO(63=+02yeEIW05xgQ@5p&b84IfkNYSyU~u-?f-S z_J{2M|Jna*gTS3?d~Xa?JLYj}-^OLHs=mG3qh31<$W0`F*;cXr%ximixm*`+6#ag_ z>F!mq>*Azb`G4^H%d)nM`BA<;ogVGbyB*nY(HF@q8xA|!WIUfvMs8+nlFjq!%n$Rs zO|ra-?;D)mJ4V_6@L8?U5p)kahVDZf=nLpe=ma{2&Y%a-IrPmz%Q-ao1^fbj0l$D> zz%Sqz@C*0_`~rRfzkpxBFW^`3EBF=s3VsE@f?vU};8*Y~_!ayLeg*%bfk#lXeD z#lXeXE|IGtANjFZ+S^i_hpK#6+h;pPJjs5GifVlz|9tr29` z)!|Y3W!r81q79lvOFJ7+@@gTwu8v+c8wa||L8JXks$Pw)sJVK`t}FLY{qwZ3n=S6- z7k8-mK~C{ne(@SZpY4U*Fw85z#^7_xKh7`zxUM?Qw(FLU-F7*@=6Zh3^}5e!HdKW`4a*YOwX{wC(2Ad6Hk}NnIVE9`1Bb8y)za&Z)SSUvUd`Y30^v z{D2>etq8r>1LE*b)1`k}JB|H00BiaDzQ+9C+I5d!wHwFH)=swK-HjC^-Ct&}%G z%&HIYg29Z(uKgCzR3zExYA57qpimV5OlSj)%TS2W0Al@gvi#eidAf;1c6tcck|W|q z={_;OUp6i4NjJ__Sm&(SvY3$65Z_D&h!Aqhy5QF!>_yk?^1`@=haNJj0U%<21)ZS4 z@d@E2DXH?__eL2f`s|OLL*Fs2hj8TXg_A5%4c!v#!ID~-xmD6!(*YyFVx1HWCdRX= z)$2p=(vPLwD2h2Ip?05%hsR51yj6kUA+OMAh<_f*L~`Mz@&CyGV`7i~HEtkp_y1Vk ztU0s(AJ-knS=fKy$N!_sIDk~;>s;rK>DRq?H`Nxd8W*k_e~_!jZ{n#j?d)(#ocDR> zMfFUrZ`CCogsd`);y%R`5q~H}opI%j(@ETaAS-~-EUEkQ!+g^Fhk&-Mw+5E=C*x#= zznOxSuK5fXDg=)2R?z=GLUR9O=#AivLwsE|OKSOfo~NsBo~J7wZ&hIiD zqPF;X(Z09fC`5c(gGAn7OsIZfF$QMK+SiNRM|t>A4NLFJ_#>kpOVbYLqY=f~rFsI3 zJ$R?#{FDpGrGDptNqphlxe|IV?t7$y_~ACrV8m-v!nEv7io>^Re@;6Ur&3#Hmrh9` z^TAmzf`Xk7qX?bihk{G@ENr7q=hhrMx?-o0s*U;i$B(87Yz z!6@m{#dj0vcYstTP;o>>q!8b{LB}10cxoENv?6yaT0vQgDz1~Vn9$K zJgN1rOYqIvO@;pvSLr0m~V7NA&stCGe6eYhnA5}{q5Uz>MJ_)_zsx1(R`taA{K8JGkOHc+b8LYnutxb)V)rAQr#O$9%Lu2q61lYLAYu(9h-M_Wf)L?wB z-8;3IOiJ8tYASRxlRdOXGM|b9TDoVAMdT!gBz%fa#;cXpGkB4-^B_AK4Z&F}Y84*U zQd27BukZ&`+S*R3LU+HUa{r??IX}@)jpL`cZ{G5$c53RT8CJqf68ISdQ}WZkR2SPZ zKi>b_H2lC(n!ell-`eJ8)tUGIR$J`^@Smj_~1?jVO#met%=?VLUUzlqPsX^oyYR0kE3&3NJu29Z63 z3*zp;3x-4n?5OCSGX!hv(<0MG0VXvNj5#*Rlr4Y=#rbp$$5L895Hl5I(?#m}Y83lZ zssr@^=sO&httj#FJPt3!V#mi$VU&c%i@CTCVm$Wa5%%w3EnP^%ih6@3u0(6rk>Vtp zG%f3<97(!k+faQ#ja4un`&Uty&8`uNbr8q;l#)P3p&XJ$s9w^lKu+Sa>H?uI2!m_y zgNRTs@&(Uc0N1_odpT<(p@0bh$G8pBHf^CyTLOaH!&+u)%VK;6N&^=UJnMv%$d8j#LW@Kh zY6pcbrsGhQt%PIbr~|R4>}>Ctp516DTpWTfHcEl=Z}_D$HN$X-)rdo49&+$ikev}V zCK3eCr=^GBR7$izpk&9Fz7nwO_Ytw6xXK>!8p7yRv-zwgO3T<~fR#;_Cs>5eqbnwb zralcBjg~$=mWk5icQs0@B)uiddomv0*&uc}qaEjxi^i)NU6ZmOmlz^o*a0Gv_=5{3 zgXR_H=|JWgEh8lppBzeP><_66BCQvT`o@}VIEg*vlFi@A5i4l`G5ReNU z^8>M=waoOx_!gmlpAAl>^%k{5J@Ny&$YFRLjLJP+Zk(vr$+9~4;y{?S({xqqu;aE5 z-Htjr+G)9DXk?v3lqkUxrrWk{+qP}nHg4OtZQHhO+rDkPd+vL0Rx_JCv4~BbsuNj} z`NjXUz_~TyZx5;02(OK_NQ;#@K0wRFI!4lbhnDq*_p9hM=)c z0e6r!3#o(`M#K(5%Q8Pj@M_SFCoWQlpz7dhJ`7zrTo8xCeWF{NyvSQr4zGgydayrL ziDlfE_{H2dqvXHiDhjbzsc!q4@-Of1U-8`SOZqmcHEQ}R^$aAX=F;QvpJs2;?G2Zi z!eW$apT|bBn2!wCtlj#c<=lkJR~&Z*N1e1cZ+Tx!ic85+p+kiNm@A8*?oXF(vyDlm zzSvui9i~|lRH*LzziWr%)N_ zIM`ttfQlrk!DPjT%86^mMv2+qi#1mY0YU;qYi}5WjtEPf(z{M>@}gm}&bq54)-Xr+ z#-=9|?kRPuQ%P$9(XBH!0@}LTO0Bx$kF!R*|J&Z5;4^kxmo7hiUcVU?fD8lA^wOm0_ zz=t95hPz(=W4N^dYXJ;C6b_2Mb-w}j&%;bW<)nmV!yG)1wivQ4@gOkQGg#5Dm~Bn+ z5!I8YUKDFtD1b509sp^)%qj<%4Dqm1t73We-DTuP)jeg>uYW8?>ZGN6W1uKMM#|K- zlwf5?%DLeVTI=s;&)|D^`W!XVZeToAs5FgXWYcnP$wNmu?08xk66Z9Ff}-1(aZDYm zTq(4(RE%?t0_u_wQDr=o1!F-$NJ8q8{W@i;Dl0OnH?dAe{Wyu9Q3D<%wc12#sUS%X_T122L(f~5r9gqn9Nil3j;AU!Amp?K-B}YDu?_f z`@yFt5zX62xY#Rs>D5qJX*Z@iHAUW&im!|snMsQc9h9^`w;tORPH&{^M@%VQC{V?L zOM0$nn#_(r#QAV2Y+K@;J3p=c#(x4a}H;X~D_oK5z`S~}Z z1{niNcP{&)G^^K;>PI3svEx0b?J+z8AVrpB5*@r>H8?rOSdt{elWB0HDJck7Pyya% zAq%nOZe=>x7T5b%hlm@pmymh*x5L2*gI)ct!0?SI0uXQ!S*J{5T<(T<6s2)MMuo#f z8a<55A!6?0luZI^108WD8en5B9UxTR(!iB0b=8C9T6Wx;FC>^uN`A4j3N>0wpjc{6 zFABL6jbcv;53|k3W(R3KohsXiY`fPY|0uvo)&2FHUaq6Z3Zz`>DC`j zefaa)EtpV^(7I{;Ax#7wS-V!|h92!&p1RSgpRP^aR)z!n(HT?ZFD+V6?mB(5{SHC| zkiGwb{B=zmcSZP@&zaZBK3skfyc}nV;+eDNE=yRg(Vm2diz>$y&Z;?by4RAx9>%8l z(mRm?QZSFX(+wvC1a_p1Sh8#Vr zISVzAvr#yY&oLE;>R3ObHA9jjfdd?b-jWprpW(mf5&RBjXLk#~xSWg=@zW}ZhNHl3 z@Fz}P<JN+r*>>0dLu--+*8)@M~5uAWUi4~Hn zH4}b=g@g#Y7>NZ)Vw=s9QH z`%E5kl5%?0_fV(;8k-4MVTk6+;j!20nY0~Qfy&_I9`~zz_fcl&s}VGohwAe}QftDR zuSL^SRVho4m&aE6Lg=ghs8lq9!1_V_!P&(csW#f3UKi`|5Flb(sFYNbVz>5vcN+=; zTYxEw7qYh}SM9NPy-nxA+>zZc)3vF+GOpu#Po-ny8G;8M#kR$Pp6?1x*%AFFUn$-} z%-qmOEyeBu)YtBOC|Zx75YFdIZphfHU|Ddug3{qfQO_?Ei%F_nhRre)7YmczJhM&% zrfx)vc$e5u5Z1J8;JS)f093g|32zbh=EK4?F1q%fX_UZS%B%Fk_|+G9i}%u-kVv>u z;IJKP$S(EqJ|TRv*-uqG?WA=URFoLKols<2kE5nWPJ`WqsSCkmTMxCVG42cSJmHFu zX#87CbG5^@+Gm9|8rYWBsb#x;l%uu|#0V8FXjx7Fd$B2mX z93_1Pnsk~qkfD9hH;XyN;gALAQ$ccjbzZ5Vmr>eva@b1SWND|$iNS2L%rIXf(77ZmJ^1!At43nqhS<(Qn$SrEdzf0xs}RoCvB` zSJM84(nm(&A`7dgE#8dMOU1P)l?mr>uy=MnBP+0+*`!*MZv`;m9I53CcJ%Z8*OFSY zd%YJ}+rPeKWj0smoQ?HZ=0g!1@9l(<8IW3}YUvn+UUjCAT1~ULIV$TyQ6{MjS%qF_ zXLO7)HCnf;vd%$~J-wDU3p>I!$m%-|NMhP(c)oL#&G|plD8FAP^QjxE%5>&T#7HwM ztvE9zQN=ZA@h8M1A`1jc6ZbAb5v7F50x^aJHVAzFilxzbyd11);@$o7EnGl=$?H<{ zG(9;c!Y>JiP>;eIkq~@#ihFgyEZ8J)MTdsCuQBkJ_*6b#&NT(%2gln_6gaml83+&2 z@rUg=PbB+tN%=OLtniehO`xcj{#W8!2aCAX(RO{vZlnwGw?eRazC?QgF1TamA9oi93D5DJ)4{ zYwuivO8)+L7wpcNiTx+~5wdozT-+rXX|X1HT{%Vf2_%x9P-Q95A0B&p;x+f(P>1XV zRI|JTV=%Vf`@)+CAAy`%=ny0GeZBqN>ISPV~{^ zVfV~Qi2_I~))&v5TkcbEsHv?v2i0Pm=_X{*`@C(9ko@swC$`3eo z1z~+1dO9+~9P^Wl=lXnvx`}=^N(zLH0e8spKtCUQfY~u(on%oYqWEh7a^VaUE&XYZ zKOy(VE8jj$Qq7K|F?m(x6X9jO{_ei)`aRKcj z6?)d*z|N)7cj}jU0f3EClFoUWOhtU4GdDC>i6yPoI!AWA%Wz_3IYDDV!05v;3F5vP zrD{m<_BLCGE4KQZFlcql#PX--Y@Vs-WF!BFHzzS-k9xnnhR^$U4b!TV)qUca3!G@} zfr;H~3?GqbTQwoisN*nbQjpK}STb%Z%pVFQuzxZeKz|K9efS0~i}i555$J1+LAvg? z(BwyHmvY48nCeLkcW$8J7K*h}Xr{{+E_q~IO6?m-c8kME1Jq1an#CK{dcphuv?b}1 zSrMh}69|JyzHx2eFlCdugn->f)+!1i6E0tbj0KJUefQ{Z%8M7g9-)Xi5RU0Z+bDFA zxu5bYZXOafLt*vl@xM)6AKQ$=l)9|bu*OdOWp##-u;)kCV&N1Y>5`lA)$d#!qzph5 zheBSc>(;pQ(qAe`qjoF7agB^WSrY^G`|o8>arTVW5ChDZ{zw{=(q^MwTWY^S-25Y4 zfZ4vVjs@7ouJ5A$gIlM|6$W-Ru6E*c(s6W?Msc43z@{0?cbEbX48>vwbddyN$dlXx zOG*4ef~l<8&Z!R3+YhIFJr0&XqL~MxbpG@LBN+F{Wu&NAvgVaJn7)`}9N zlD4zlGg*&^_i6ady}uG%5}6z|lE$*~E>Z??Skzj2eY15D{HD-Yt-;8+w+?JV z3J+#0r8ShIxSYo)(cLx{Cp{8%bKS(G`ffIb^GAv+H_DB{ds< zCgiNsDyrV;reC|`c>%+9j@HE!7vHs%HjSuJU(|PtRgd^a0wlBxu=JxtaCH4mFtLOU z3OdP~K8$BKRl+FhkyXKkGCS-?yKCr3R~W;ohqM|kId#Az^~}E0+81Rw)09qmcY2k6 z-;dz``K1YTM`N)8*z$=ucNfY5u3jU&bRv{?a1L-qZr=cu!r1pEvseHX;+8N6W56j0 zVtx1M-0!6?b}Ip%mD{h{L=qg5>*$a5HgojFvoS_Age4d;C zbfx|!{PTI29{Pu%XXzs@NfVWXq47{a*`i{V!XB;B+<&V<^)6K)BQzaTX72LC_d(65=7JCLchjap|>dCAvWFWAL%iJ`CK zPT$PC*V{u8u1_}nn=4!U+!zBB!eMcg*!Kl#)@hOsYYcjVw0{Y|QsG$i%<5mU35`sq zmxklGZ_@@Hzx!86_T2k1pF~qk6+IMRSwrHO)aqo;KvpV(g_QSxuM(Mg6#KH{{- z=D4dv)-JhoBk!A@!s~pq;A)=)hH7N}D$kuVW8A`{a8ZX!+liY|Ma$?{TP=# z!vXmQkRHlC6#)q_@KBmUAj#w%%7IMDdz#z8+2GSx<>F(Z`w7~_P-o)v_5G^@D&f&& zo;(zLqxTmGEe!>PEjG%`X3Oh$TI2uFO~y5vRNHDVxbOVrg7Y*d@{cC5b6X% zJ~>E%?o4y06{rZLdM2IpH=y>EEl?#Te&7ITh4~%hd|uLv)%$SWwMWBkbk>0dR*Uqy zd5O>ryCiJFD$j)krspKQoXM3u<~yrh4P!EY9YPij6S8S1l;4qpW0i|~W}MsP91Bl= zF<^|1q!v|YS(3F?I>y0*$;-w&tTs^9UEy%so<9r5!~h$ir;S%m)WHdTT-bmd$(y-E zw%Zw01Fc~i*nlgLZI`TDb{N%rY;4$J1GND_^54Yph!FQjW`%YvZJ!ohHEXp<_8>~Q zxf{0`e=r^F@d4V7s&1I;t1 zrDJuqdh#y|*oP2!uV>@IXq$&IF}RQFH3`|1U<2A4J{zzQnX-15JOr>;Y@O+JBz2ER zm)s?8oTFJ$GkcavNvjK9qhP!74#xGs(it8_*6>*vX;ki{5K)X@nU z)AhpqVGb$^FSp~>XD#0DVAM#2S+|qHsEZJ=`$&^efgF5d}U?GyrO|N}1qS2~qSx^~-PD0e-4F_%vmYk;;PA4wG3X%#ect|peER8w&+zK< zrT$uPnr$`ze&_Y3{X$>udi}S`Ug=KBT{0l-Jfgn)({S;P+b9T60rpN5`euglO&L=<4IH11R?B=RkEt7z1Q4t8zttl>9wvnR8h#Bz1is z;l*ld$IrtPUTi$WRS%i8_MO(yYJQ%n5N*R~vEV;@!(;OM%VV0Gx;5AeX&clUVVgvi zLDE-Xd*l$9WQ;>E@>#->s~zgpCWYof>&W01fijpj4fmX<(%PS_B*RL?%WUP09Wr(u5*WVhqWC7pcm8yi*WXK{=0C$aG&t)XyIbvLc#q*9BS|z{{Glf z6kA0SD<7Fcol>|Qz>&+_Be6-pk6?pQ4fIfNNEvIQ4wzU@JqctLVi!W1bzW+LQQuw; zJ0xZ*@=AIEH@Pz3YF@XvQT244B8w5}@tc2@yM5H?`<$S_Tit8Xpr1p4Tq0?mTRY0g zq=)Gf7!vnK8RqxAqCq=E_VK{AyNhk<#+~GYaI}E!n_+AHNyyyuAWOIe!*vxyA{r~R z?3_f|)R|+Ehu5|7WzDQA72I=e=*UVzg1T>e@D@?WHSaosMCr8QC+X#s%B_m05ZJ6jA&( z8RnpAY)xyXyE{R3Q+`|z*R%(SxqNEu7;{~(`rxh{4Ke1zN4rW4c@(VpSz2p2;gUFC z&d{BveU-fs^oS`~M)r?T#uHxZM-oUlk5w z<+Nu&BX<=33XRqv__fXk(*>`s;oepr8(k?!X-i#*?HR)M^#U-|N)nP#SILEX=pQ zaI&I&L!YGek;A~n^m`x{TgxNMb@n?BIwnf)2?N4HXKkQt3{pxM@^&RIl^%#U36*)q z`@#i@TXoW|H~MI4U{-taF!-oZQyjyr2l?+bSs8HRl)QmYffGs@#*vblib`k}&bw+F z+2}SL=I9?Kvks zSNsnV8aqBd|K3h3)200F%`4*eZqKhnAJ+O$?zVImkM;hCwIKbqGuE!l`quQ2@&@kv z0p(&$auwD}MycJIAifeC)W*R)daj||3Tvzq&T4^e0 z!QaJH-QV)7WB7Z$e!57nY2Yp97kTW5M6FdPqLk{Ji`S4SAeR7Jt9PPkoNV^+9`r(V zfMBU%r)EvlVW&<(tl9ZAMquTW9r7hW&zj?2q*D^RydHJOyh?d4=Qy~e=8#;0$S{_L zMJ%{r{I?7U(fi~02Ae3TT)Cu((;%RNoI-73vP2L*RJ0IMSYPg3n^EIwqyl2%wx+H9 z764>{E7`GS42RyaXypTmWPyl~G*Q6eyO%OE$Q+Fv#Zsvp#Sz`wfw`IH{x9?9JNw5F ziLW>iVh?huru8m=qDaeN1i=|7{WX(L5SsPu?=MooImDd8hT@Ivkkv%^2Q}Ez!9*)) zztZHHMI6D6bpbm@7lA(4@(`Wo9*=XXJxhAP>lBI+C5sqgRls za|R;!^B_OPgP4gbAQ$5>X$Qvci~M^$5X!Zg3-s|8zW!!(_~u_Ej)@cEjwzH9iAg#CE%(vG%!qR$JjkS+iiyai9)vR?L|P8q zAs%^n+h?>pj#KJ-_a5fEhyO<2LS8KHfU$tGwic4v9IWz&@C}?r#i`5uUk<(iJ%P5a zCnh`y5!Nlp0F|rW0mOl@Z<}15!XZG|VoyC1lSBy+SmTzfzTh9i8gCwl%3IZ}>w4{# zB9@6}*!VHP612?t-JNiq7`)q4Unq_VaM~g}T@js93j8>95Jw?^4~~ zz);jc+KcQzNNZfn(2^NfWYW~&FRVpEK*pJr?PXAEK;_L2b!1M^D^iYIV!WQ6SIUfo zZI+o|?St6sHKyBqtj|GaUmu;b>D?Za9O1&F8OXG>kaAx1P_~GZ5nl?2cqYbtX@ap( z&?s^Nk9|7W%vOGi<-EJ|NSU6HWe^08Iw?_7f zHM2iR+&wufAFQ_`UfYuIZ*&Nx_LC6fGpw(RF&Vj*?I}Ry7Juz#KXQsq$j=!Bkui|rz5Wn2-+oA(`r!X~RCR$mk|ZKe@MMI%&q#x@@U5^F z4jPV`{LG`jyg$}?w7puRqPTfsZ+6WNnB|Pw99DAA>j~HkcB07zl3Zk>MnnanBC3~U$}c|a#n-x7?HK5acIr_tK1b^N zYu0R-UCl|XQMRW;1_9)9At0z8ZGVIQr`T*~S;zkOC92@TIb@T>-ueamSkPQIil(#J zvcIdgq(}g|F+FA!2Q9d|gLam}3BkF`;=1r^yzE@2j-H`zQ7=hs0PETdtYsBiCufMy z-|Ile7hXE~m1%S}f!6&~AHr@KmNrIw^Ur~Ik;$0!kciz1DA4Zfw?(Dc|q z#O`PrtqiuTM_faYpRek(^ywSC5n;jOIq*7pT~b(m2YL?vmX$k`05&=}q(Y6|V&VbT zMox?+r+)mhI)P5yHuk+kxY#LITvEcEt9UK>B7Y<1vLbkG4`fI0$yohXd`s;`J$XFY!oEcE^yvg<7x(LZ zO6}mq%07AB&@>N(PgO8s<%D1u6l_gV45 zO38)?VEF#Y^tN@K1NjJhjOXajN8|6){@u;?-LA|h23{I+@;6KpllmW5y=W`_+WePo zg--|57V&z`;(u)RhUQSl3f_Bq6&eF}1L6|u^8eJ|uX40wu?Z1GA9<@RDe`wFt+1f} zB=ndcc1W;cK{(pjp!4$ob1Q9>UpsmzWlAihP68&AEPv5Znoa3py0WW&`NR(P!4unz zLd(6iIe2%oJMcj1?xAq+ZQ6f#qjTrbprs<0UG&^%w5nW%Jh08Zm}ed&KBJX|$YY1q zky`RVDsY~TKJppeE%XKB0WQ>7K~W|5?nLI{1>~dWiXQQOTJIQQ3jORaGY|IBlf;Zd zjcIVskUHibsJg$KxW(xFvj-3O3H#!bM`((pmX&HdjnE1Y>yCphNc__N_0EU$8NdAU zWtAuN@lyWIr!M{)cxC+W}rX#h{+do-yL+elb^M4)OKicHymzVivK^MPmLpvL_^6M2Z`KsRYOI@Yuxx4vzEF^pI zRv4LrK;oIRwLlSZ?$Q5#{9SbZfx$#PT|3*&Q1Rfii~y~J@j^m)X+`(#`LQXZa_@A< zq#1bhqjuNdQh-STotss-bEwIth0d)+;Xy)sAwnm|xdZl@n8q` zHudSz4;jcamu5ASjj0Bd+4jwmlXV{)8e~H{qT6#(qJ6`K2RFP!yemWN9vh;8;RE!w z?x#NPW=fLW!NlUMyNbRW_dqoZ7N4cgMZiOMB&C%(V|DSh{`b|iFyySwzt@yJ{!0tF z=nkE=r_EU#_xQgF7d(V#k{YwhbD20ovq|;YWx1x5!P(@7ocjE3uSj^D@`FyjzOlEU z-GZ}Om|HJkoc3lmTiD0l84b4f@sDPstv#Z%+J;>AUM{;tXEh8tZM|HH!i)SINcez|FU)9pkz}?8nY0mzWQziZB`utHA z)3`4zKQNSm84)tz%yoKp&t#$5q{=*qT%CcqJ5b9!XkY&seFvCI9(-nFPU9XOIL3^| zBQ|h^35{2@e;*ARr+D|)wD0rv@qT~w_6hsH6ZL--5C_6FXP;3ks8yFkHiv8`os*Li zw_*bQTal<79kC)Jq7;k7WX11yZvhE+mI=BxK^jn15K6+(SO)tLI~U0~y`I)iW%2sW z>jyaZn@5z<3(*FW&^A6?%;J?vlb#_;fa^Y)_0 zOZ&b_)@Q)BN^)CUTPUc~&h!)JiN1FZQHzb?JxrjQ6(tUp?L|7LqqVK)z`Py7t7K?; zWG-EWmF=sSx^d{)=_8YsUDL{+#ll`)U)V+M_`#oL4*W2$a|b`lgTL1vDAvQ+OFE3{T@i7 zjm9+ebFzj1)IL%~iEIr4F1A7mU;3lY~!*|h_xK4lS)$LuW3;&tWu!5c=)L??v+X&d($2s0IJDH-f z36zyU1!QA}mg59K{2R2GX-Ar3(7mh+=FjL8S8A@_L}l%izlorYH}1nKd}GXm2%;eKEnNPwEn7MmQTk<9KSfVUdT%>OANz6t$I9U52kJeMCN%tk#%x2b zIhhM-_<3)w3y3+~GvI#T=9@-AK>bqSZ6g>!BrUb@sFg`N!x-E6Hz7*nRM{UPCra~P zzpI)OQN-vRBf##8*W#3nSNSD0vRXgA;HFA)I-p3W=AAv!k4PS*_A?%&)~0c7MF2K{ z7Z|by)%7=&Ghi~5zz}SfR-w1869}?&)|dorIno^~FqP?93o&DNGZTPT^5L03Vv}_R~OOdxDImLgj z6~J>KKlaaO(~GAB+w)7#`86?tjA4qK+YlEo*Rl~a~c?46; zCj`u z1d|I#xuRfH`M!PiG0y_A$RoRsU`NTDJ8Syhxy3NPdI|m=+aphc{{1EYffuKH!pDwL zhZ_;NUImTVuqk?}X|cjqv>D&R3cUaHVEek~oAX1q%iGpj{~3HiZ~ZlIC2xSX8=D%T z$$;Jg9;w7dFsf(bqK{fI+n>srKgO{EgR39yU8%%fSSTBUd9A+`TggV9e#FwZ^|kR@ z+jO-Q%gO_964ESrJyR>k@nNo3r1UWx4f!-9E!->n`SeJ}Nx|?zQp$JVZedGI0+IBH z7$w)oPrZK%IQg+L=u9V%+Cb{~a{YDrl>yFcqf;PvMzY}lE_3!8b5J+!B&c#wI=kyB z?|Le;%W-L$z?y$raV@T5;RsCaRGpWSAijT&(s_k16BpL;=>o94j(xtZ(@Hdp`s=HaRmU?RWfg0P0p?6TQ1Qz-K)PbAHi}%s$5s3Q=@@ zdsW|X?po9=fLDMLuGQqKWL=%JFN9S6>mMKS7IdMUO#<92(#K_1uYbr#c>c5~pNkKJ zS0T>Fsh~*Yj(BWrSiLq%{1^Uo+rAF;efxvw0DP7}eLRN-&&k(RLu`JoT3*&LN}ziO z){W@z4OLZkb=0anKGU8l9H5Kdrgd6siy>PKEMRZvyl8-Tidhvo5PcogS-bU+rywpd zgzBkO*U?2a5_q@;=x?u!Q%3Dk^20@Fx#7zoS3CdA#Ldmjb2TgWp~wk2 zR5L>=!Fr2Yqb%W!6ilk1+-VWb=5Z9J{_^Al0>BB3C}T&m*T#6*F{EG@E%|C9^_=GA&Dt1c7ZyyoW*tk z?Ew?Yh0T!B;T5_!BYYN3>~eD_ko1I$*ezzcaQYrFw83_x)nv*C}2|ESnX+USdI&n(o1AUNc62B9V zF#D4iGNa06vUDYwLh${a>`-}2vRUzeo~x#02dNj$=7c7=xi5JxdKQaJiq{A3+Gdj- zVe6(xhXxf1``|!Rm*Y`Si3tS~uSX&q<^XCCRsvme04aT;rcMH#e^^S307TP$qc9@9 zf@TBVk>-iGG0?ag^yE@`BY58q`v9as{Ouz=P?Z+dQIe#~;7OUT0HaH%jcx=GKK$nm zhIB~zQPq?-oeyRqJ%)UzYkk<=K_OXOXeF6-w^)l=7XR7?C<0^e%Ryt z3GqTd`}VKJa+X-+uPsaTY3i>J(a)>@f*JCG6edc0F@5^c`lF}=<)kUIw!;9iggpIx zQ|w>{vlw3NiSC8P8B#$u(a?CVb5B$WyJqGiD^{B`a11qvPI6Pm=!_w%@-gjX2dp1< zLR$>XU$l_z(4HBsubd6-7lW5n-sm1tKx~w5xht3L|S^(U|chh{4q` z%H9mHfx@P)F0GnMWcF&$DabcYq{G`AVPlz)0f-Mg6Ehz9hpBM^1ZNP$(T%}B@Sox; z3*R%%>zaArA+WO%@b~V|nPe!~k;^g9)~Kj?_f$2HCpajtSVrY6nL`Y?`bq_Z}Wz zXm5XuSFIkx8Iy^7{2!Fu0kQ^pUEn-E9)+zVM^|2P<{{J}nrK!lS5Q&(<9N>gPz4uMu24yh@S<-5yR8^*j^iwKy0S5*5rY$pB25FC&|k;} zDcH9_l@aDfB&3ro((5xhqUNS&(Ld2po)qABmb*CNyMKcisSyzXtR5f%P+-hxFmb|F z$c$guARnp{uTn~cX{5_$6Xt*l{}f^;%v}l-nqG3UX+TuR$4!N?&Rx)fCA#ODe)655 z(yXGr9E)TC5mu}0FFGKx1W{=2q@MpKy}|pbyF-qCwBF;3_|Aw?{aCMR*Vul&irnvk zuUqjrC2erdsfreG5)WIe*GKoo+_fU^!Xq7gcVvSCo?E(1z@-sp*Yst&B;C(I^!2m= z5JO*e&pD@^kEgKeX1fF3@7c&ah-HaYzyQ4r%lefGTK zvv4e=abf#6j_L{i%=3N$-Vds4!h^a_b6;xSro>j9X)j`ZTsmKa8MMo=t%IKqgwNDJnDME_OZ|M)OZS*z3LSC3}OBN`3M zW+qc%bbJQvzH$$TjR~jOMXu{7@82duYDbAWJ^>WB#mU%LzKdfyJuRd#^to5-i%m(Numrmt9a9jJTei5iDAub9D|5q!j44izDuc z5#*)B&J%gKmwv%`Bf|<4i5q;Buh}%e7deP9Bpg6$gGMJIWBas%Z`fz-41Swxm}|(S zisE0EQzz*ISep~=$AAR9BO(OM4IEm@&&ah1s|f6$;)1KcQ=1Pii{!yjzVw>1OBbHXeRleqN0pyt!~6`hNL-KZWpLPf3?$ zmAa-`;lj3W<3Dko`ocQ)7%;X))!H`9vNBl%t_Qy@N zpESP^gD4HG+hc~`j?=vS>n?EF0t}Jge%S)zN+%3k^^z*Y!MOv4Ja$dB-Q&2I2bY7$ zxbw^(+v@tBw6B5@)5ocplkB=(TpbAGEiyq3;Dm!^TI`DLoao#!v>AMJrk<;L96^3& zi=UGp^ChrYmEgj%!;;oClp(|_jk04>xVi#$)sx9{Va^`Ox6^^CL3cF>ELT=Ka>l@B znAR!f4b2^Dp1qTNE!%_vi4v%s=;Pe0GRxQN6-AI4kMCw3#}L{H)m)$>bXN$R33KIJ zmCDH2RoS^8@a1`B&H*nvwYfHZ8hLG$@-iSCy79!Zm~0?9JEUrn{FH1^-^|E|pDl6n zBB3Uwx(XoNqtFak4Ob|oKHEsrx704Rtw)&?AkC#&b^)7Br>Ux}YUBG8-+9b^^%ta{ zQ0J%EBkswJ$4nu%^d>!yb5^N?E)u;XS~wSFJ~}3ASn@C>hp;)VMJCVahP)?s%%6Vn zRJ%5nm#{Zs`$DBvK_6E`=me1(k0a#YT;c+CgJ@d%S!sV^gRbJW*iKBB_=*#U~+r zB9{M#5LNuFhC1F@9-)fG(XY816HIJdjF4!!1vHyDs5tn;AAduM9A_H&eK5liR8Py9 z2~mv={=o+?37@m+A#11OI7wuNgm!gt_lJr6fc$T#rlT#7t&ZUPTBl(`$rux~NOd7B zgUmTfq&6V74x$R83EquB-MY3T4Ji74n_*99K8J;4A^Ev1p_u%<;hd52IAdyV7Q&K^ z@8;yaxj3IKH#d=7d|i8p$@H;Hu8tt3Qx`pqq*~T1#U|WXn!}eQiIv*4;qg-a72^RH zPgWAAl|@~VET{~}B~nXl0#*eu_mxPBD>c!7&5I@iF7T1^mG2I1nYbO!a zIVEa@I`L>ZI#cts>F*1L5UpNkjYf6?CfMuS0ce$Y`g3?-f@n)@KzUDN_cwkwv&J$c zz0Fi3%K!bNyd1fNA8`eOHldpPUR0b8gl6=c>ikHDEXj27q?>>x0lXTTWTAP2i7u^K z(~!k>k5ZOp0136cklzt1$4Ur8;-?qw((C>)Cg+KUieM?EtV~JpFLayq(!Dq5Iz?NJ82APC+;9 ziK!4$rn87Y?BTR#@ac}6)RB66R!9fYyJ1rtXDrt)T#Sl^K2U8>zwIC_BXR_M*=2g# z1?^$a=fiwh!7}SS-@76GQ`UN2uG|c*iXEs~muV``^rL!M^v0>?A)^KB#iuUA&UI7buR;E^GeTaE*F}qhYJn zg#1zMPk`u3c6~G^bKug}sJ}X!iV=h(Xl+*0E=0Q9pdTh(wHeq#fr=&qr$br92xN6* z!k2B$cqK8x+&iItUR|#n+{CNM)M~*MO;h_pk56#iRtVFF0e#%ivsGp_v{;zWT>G$q z`!hk*2xGpaTezD2VzpqR^z)sy%8tGxSTaz~?+>dr0f$KDyEFrCoP(6h>1YNvrAs-x z7AkEm>jM4~vlDYM6j?GpcL3RnZa$bce`5o(ZzSg2um2jzHACQS7sYL37YI2aOE+0d zu*Ce}w{VM~qceDCDOnb)!M3uk{NvH* zshT<{$trR$L~!GY#kzUO#G2M1-rF9?R6hZ2SquFQ2EY}AEx*hKTT@4Yb@c8v+Udu6 zefe7pOdt5Q`-vKj3La0Y$M4!s-P&OX^?EA43G}ZjLwH&|RZhsfeg>898Q9paT2)fF z;5r^dKLNFGx4~!4Bl=^ya7(>j@$LL$iL~#om+@wcC!e20{c)URa!_J;ZF!$zI!Qm_ zQ$CVX<|i$$@ztekqJD3?<`^qmTDQOUYJY#8SLmyr_vrP%e!pM)-j(abxr562F+_KA zb}fiEuV1>tt`*(Lt?*;OJ}o?VcDFu_i^PE8i}UFzPLdQP6Ud!kIa3!MSLqYb^C$z9 zzhm(V<~qL5c=6%?K3SEZTb%rJvP6>B|26d|>);-SS%Ya)W5v+zdvv$VnNcfTVv&44 zF%tl@?Le~|ONo)r8L6>^Q+p1VO~fQBp!C+DL1Aiqbm^RKIm-M~ZHMg2SV>8K%(*;p ze|ew!zWmp}2Giy=Rm>5Z06vd;^1KvNpXD)| zIRI$nLhVs_Xip9{psLo((vUXMMeRYX5((8H>$94=(h2D@_lzS_y);WoRrP^1o>Z0* z9#rJg{fQZb+wvV$v~%HnxzXVhB!wn8psM|oGzvt!eVZ}byncqOuOq;|t%?AK!vM7WoJ3 ziO=AG1-awR@-9x4+A^FRvTB@^jVm8M?S1E2+Dut|tT>cKQ<}k^p*u_L(OfgC-2dP-SGtPU+YAVPc7CB|Qo@9E+M1e@3?N|N zfVSg!!j3yE2-CxIV4ttc=W=btmw!#jXi6`Vi<({bbB~j$c60IYR84j5F7olw`Sb8^ zu!&S>#(VG}Ksw;qS(B=EE-W3~xjQ9scRf@sDI*ojUI<;Nm6ACC6Cp%pzS|h~6Fz7P zTxd@mR)ITo=W>e!g9^=ydx z3{9lUqlg~=nN)@E2&0CFbt6lmH8?=r1zzMi5R+8lSAqr!M*E$2noEi*yiYWG&p45} z-Flv`1(Q8w2@pwt`r9xKv~@I5u!OCXGm(N8V=5548l{h~cI&6eg^&zErds`hBGJev zo)bqmr89C|?XfkPFCYCR8p(roEZVyJWyw#zrRwF|BPWjT?0eS_w(ie}R}DX_HKRK} z(lmfe%26LE>PRE%;#s*R(m)@gDqU!8*5H!X0!Z5QREwaPDg3%&K&I7i_O^4Wg`O5V z<6`)+*R$IDvmYzURrHj<7; za`NMVH`VM@$ioIgelBb1lOMb$b}wF@>RCyVxv>T*e*Ohw`iOhDuU3nNI{pE@J+ zhAKDs6N!q=gE+SW|CFdpcof+o#Fty4Y_bw-&EAl-7vY9*xZ9A9Kt@(7M6Na)Bu&YR!OE2`OtUtFGOKiW!LcJ!Lv@ymrt zKv|Ocx@+dgzx|3FA4Jh*;1WMixOBXty~e9v5}xgw{(k|TUF#tRgkSX`pT@Hhk;*tceN=st<8z1(-*t(K4J-Ocr@KZU ze>>IrS%vd`vehoXu=<~&DZc~ggOJwm^piHOq2KdaRP^0nYMp!5U*+{<)PFPao}YBi zM+lgro#>DH{^~!;zb^I@*m_E;N3QV>HVxKGi#~OnvF6FSf91mZ8Ipo6^Vfw#ff?bg zCfCVTX|5=cUR)4Egz4$4dosq+L*a(-dkoAT7+3JAY1>FHRt(qJdIQ^2c5&u$sg$U%c&hWh@5@K~{Mfu~-mCFO&AJ8@9j;z1u&s9e|nxcDdgyZZuv0s`#t>AuEiRHPlM zK3z~a8F@6Bi$O;NMutL;HDk_IS)>igv-l^Qgc3N+cp6AF#BmIo%9k#XS-PvemhHZ! z4|Yr7cyhEzIJ9zmO%q#DNH4_=9n1FawPykGr!LGDGphV)lHo!><*T^ihb(Eo@1MV= z|J?3heK)gjx6L8(39yyU$*dx|dis3y?AJMG9n0WmRyM_Jkx!HS|1@jaS8aNEOe3E- z{doKeHLN)^xKWkLAtQJKTi~C@6v-yS)BGp^ebO~irhpHzWFQeHY=_b%VzmE_GHpsM zRDiKXdX^XkXm60M;i)PsrbG+s(LF5P*?uI+ zl`9L=0EW0(NFbE2(-6kSw3<*26ye2kvTbP4!Tb4dspjPB%VRUb4D?HR7{Tj;+9J+Z zWEaB2j9}SrL04^IWdx|jBzycBzD<(8x%y)5DR{x^jx+xBW9c-hFwVv!jG1?-by)m_ zs~6Bx3UX1A%#xwB^q}38Su&IAAff=&QUP|!nUJMR#?G6{w%k&KbO6Du5T&d*;<2KN zEE$%u@}ROcJLi+|AejK5l>)>acT|Qn8K?Z4cd`&H#?U)75jqOrJ3nlxPCd3 zehy!ScV@<=w%|2VmzJtDm!bqWRbp!?s!q~|cm-gNn@|V`HUdPnFe#B5MG2A;EHn`q z;K&fkaaO(Lmh=D(ii7X~8c!cx; zk~cGMHK1tJyS~QJl*W7Q7VpltYqxJ~`b^K}Ey1jwp{VBZ5lXEr{#19an9@}cs!wP4 zeQ&9!E?u^|Kc0t7monSwQ=sxTjxgyI;fj@n%tp|yza7?@a7#TIH0Z9wtk0yC9l}7r ztBaBXe$+R^qj$&FckkKPP<$v3FG3K3h>6`c{8S-zOX`4lfh(mFcR3G%!Q9`CCI ziB~-f9)wH}BDd3r$lJpp(uBh+XQVU?E_WW#|4?Rm4xn?*23uNy*S(A|b7O@ZzCunn zgP3LRByN@s$=W_8qp$0~*uQwQ;NeudY~8xbgV+BK&bU~h!(;G=`}}6Q9y_)Jo%k{B zzGZ7}*5=uUbX5V@-Q?tUVGGi)O%V4bIflmIu+uC4WRDPB1_Xa^Nw5AQx*H6G-*4c=b8yg4_#=K6AW^z&}(>C%~r)}xv__8E1J z7or7?cf8h=yk!5OHPbx0uXH3>S9~N&}-`;yG_(x3jAZ~xNUEiQiYKW0kb?EUhceD3?d|CX*wOYKM1p7wp*NB2Uw zkWN2|IhK1U&^&q#{C7+MYZs59q#kT^{5adTUKGI?sj0m|JnC?$U%sz(>C1!qJ^{V*?(njpZiZ3=m6k@QW(O>_nkVKESgogd_ZvcRUQ$iPrS?>AdZ%a-ftL*{*cHKeE7+a zrqeZIdV{Zv96WfsKHT_+A$HU)4go06i*4jdm)xz~IK zck>dl))dShc@hnxvAK9j%|HN;m<4gYeyWU>Y+b%fMG876xiq=CJbOSy)jd>=! z8P;H5#Sq7za0@YX$~6$t`KwX{*1UJ9B5aT(Zh!L6vlAa&{d9QRfuXC9XHqc5z?%sw z0V`V`U{)aqj*K9p2%<`_QgDf3V2mYF)=c9u9TV^?2%30A8K4MXx^0rR3x#)L0Rpbz zlL6-dLquvBJ8Si=x9y%M-X2XmMBZcuQLP!ZY|#hNh*<#x3oq-!U`PgzaxG6fyD_R( ztTk20o;0-^yEv^O^TDq)HudeMYa(D&co~bAn*#pEXUYUI4s%W&&k>;?_sM=B3A3I| z8i(B42ODz%zQb{JnLqpUy>_2*R=0k+sNm@K)$N7f)svd_y-zKH-6Q!+ssnS$@TW!ft7>*4jl{M>~YHgiEwJe-cz41iOlw$vETw&gHT3dX!^zuH7fp($1 z+A^iwUTCAFz9GHZ1$|@>?UfCv<+i3n5);K%3AGuJdY-StcdEM1^)P$>d*St!cG;Kz z@h{xK`R&Q?#OF8f-`}6S{mTz;-ML?QxBZ7-|Dj(eMP1W}lw+?%$2TXPaN$tkwM&X| z^-;q78pjonv5$vOUznV4zw~!JH4R2u4*BZ1{q{yeszhWG zt_=XR4c=9B&-pK|sN#5X5xABijgd_;?PumZi;jxjS79jW{lbmV7U0mGjf119wLMa! zE%m%4MI=;9U=a>N1S}^hty)feh6k`E_2q*H_)A@bps6D;v4GIjuKF*B=3Nzw`oH%i z%TMM}O}LN52MP3Qoh3a`PKml1(pw4gSAm)g8K#)|@<=%+-goxvJ)im}`)?F;jC}IV zmvF7_B|}(KT;qFF2=XD3FqqTcopJMOrptBw?yIlRok|pd=_n3d7ZQe>M#^V=AGx82 z;#jBk_&pjxgSUlE_nyVq&*N3_V{u~=mOopZ!k?KB2Kw&D`xO#31bagQ{9J4h zIiK67u17j{wUxoKscOwjteq7T5^}4>0MnJ3JUB9ETnmP*+3sON@-gC&3L#<{V4w?z zFaUR1CcnCzmNh{y+hvT{^7P%pVO7A7u?(3{D^H$mYE+$5tCaPr)q*^&(2{P1qal+K zTJ{<6sxyp^*0k!z9mJVHsD7=Zh{dc-(-xzr`!X0%ZmrC8s`9zM@IqmG=WB@?F)faA zh$+g2;HQ=wfUe;Hi{KX&RKg;nM2%ukJ5mo2o%P5S5CaeD^*E?SuHVF3Q)|A zRyiIhB}~j_W^QwUOkgv^9#@G8h^L^njk35 zNqo0%8Z5C)jxX`#T33>Erl1?)h+MQ(LX5kIAJ z_+#!}BmGno{Tk83lnN$)tQ=z9oWZr1;+IBQw6d^!C&VJvmr^NIcTV@Jai*72TgXBb zD&2j)9=jpDzBD+u#Nlp}NkOm(PdTmX4|P{8F@&v;EwG`&7ClJ4R;sK@6`(WF?LS3# z7tF|Z-^kL`I{p~mt|0`oo?kyhvsV|i`fsI7ZhvpZsu}&YCF?Se;PSJEMjjd5l6TXI zUaVpuFJ3QpPk)etN*M;5CcY+$0oElwPfi%#k&#C)gNC$|ODx%v5k2N+54u1Rq6^4i zvyxd8YixrCobL}x3>qs zW(1zodV|eW1kPU!qQ~lmpH1h%%h4TEf+Ntv0Y&xFK`}bv6Q(=zy3BPKIU4G&w&P@Zn~4 zQY00ocX``5Qq;^i##$7vYIe)D@q>x<1eczHnHYIjYPf;-dxJ7!x7uxOaAI=qe^HHP zr+UrCccsVkWHbWCbmpRDve4cV8FQw01vxnIcXcy%-<&) zL&qTNl20d9@i?r8dT)79s2)SR-{@8El|NMXBw3F>w{@shqO%`M{zAveeZH)^u)VFg zpX{E0^3fVKXg9a@wFlE)1<&`D(x#%rQ&)m~8#+l;X@-wp}EgUNSYKHM!?8vgSZ`&(1Y z0h!k`;4b`5Qh9tE;p%}(?uqjQ3ePwB)UGCHGGJPt4HH`|be%0zJ)0hZcH z=j{*=XUhfV+kz6dd^W!cwkzIf_=psEPL@O>ABPT#Xo^-BTib7;zmm3%;1^8#vj@ig z7CN@|1=Z)ZjeSRWGEOGxu>`Pwa}^mu8MTDUcl*nN(Tgpu&P}wTXL1StM#R=fvu4IK zUwv))Y4+&qILudp_X&LpS0=gi!^ijTi5FZdUENW09lN&-cz3eDJ6*gjnY4 zLj(<+4xK$-+mb4T+}|G<7OSvC0KYH9fr%^P43GzqQqF1vVol_`tkqcZ{1yJnBy)45)iv>`(X1^ul ztH!UeD*s0LG&tp5p_pGaRf`Z=m3i(ZE@W<&`9b+j$3g9=t_(j1-HM&l*^`+ek9Ia; zrxpsBB&>`ylZ*h9hkGcq!Cr4djjm|HT-?DIpoi86SswbHlZF3kpo+QtOFJB{fF~2? z+>^ZzZvmIfz8(w(!nFlxfZ22o@H#4_N z4A8pg8T%id#OY(F&c8NTzd41|j3OvXVPFXM1zRW8CsOH&47Ev4G(fW3YqJ64(PRyG zy21j3PNO-Oc5$xl6!bmd{z0`_tsaC(*|^&R)qR^!|4xpALjePPgd4hGW5Ndf7_Ehn zA;8?N?;7>Nam$*S49D|-%R1f))$9#5Zv)8Nt82tO7^7&-sn!+^rk_=vQ{g`Q#mu#3 zt5corVpLzWPq!_SA|sBvab~BL{-!8I62)|Rddj8e0wUe+t$(})(J%Jxt{u0miz8~P z3}RB$n@I%;jGHec(_eaZ)z!#!D84Q;W1tAJXI2oeUp$swJ|<;a9am}6To$$p1!=Ws z(uw)yR;t-?TiE*h7O#1&F!lSbN-EK(6oEHCV(Bat&@6de9lZl zQjA(~98fh9foZjqNvr%A`@wpn@@maFFjz%WY>{?$hvyTqF*! zr0NAm*=9X4MzzT^@lO<6mtHodVzVA&$bYjv4iL561#>>L(U`F-HR~PwM+Ez{&uK~u z&pC2D(eETw2^_{~M+Gl_Y@;&SptjfxCyk&q(wIS7#IQ?hTe?ay@r86t)ofV~w;ivT zB!cypJ3lO6$0v;Hc*51Hap~i#-j#^tUsChvW|Kz-3Mq_Hj@Gb;I0Igp?e$;tAc^2> zMZdf+j96pV>+uS_a#9JF&Jik`BlcQ9j^cCqdjh3ew)!>YtBVP+t$KA}*}o0fQKp+K z_V;%aAYu62Fs!o+miuDimh3a>3|=pxs;2!u+NIbr5;}yFc5yQk9PA60`bA0bXGkPj z8L($Gicxr9jZHEGm!GIGmfR@?u`BbaY`fip;;hc2pnWqPclOM8rQ!a=g8KRe(#@#_ z@UHj-n-YZzVFqApIl3+*J(w84PeObJ`;nTh2N8x9MPb5a=GkC_Wq|c~4%%f`H|#8<}{-o7clIOHs)qM;5DofUWOJ8ib1>D?ZL zOKLw#V~Xugx(EB<@96`418fV@7J0&Fl#?K6<=&oc>vAs_oq7%Hs?ne0ZPal(0Kr*^ z{z6VYFs{dZgq(U{E+xxu_uoPqkGo2TurHLeuTqxj&&i)bSx2R3+oQ_=E){aWkdUc~ zc?#YyOUkD6(r!peSo2lvmD4qcNm^4?B%D7_2FDXZ>l*dFs402#r@creEIiNF0n}YoI!Slq z+Z_n7Kzb=;bC8QX33=oSxr-1lTEDQdij)A3uEMF_lo~(x6hj2l(K-iuT@kW9MwZe3afyW}be+XBaMNVhoZ4$xSChjEXEWbC%? z{bZHNtBhy>MJ^4HW*(I6>jSCx7SmDqM%onc*sb+N?}KN|mWK!3 z#mtH7I({55{-s9YI|#y*>%=%d0E2IiQ=ITR#HerGx5?%F=`bs5GKByPoo~UpTLs#d zS#=i!`%}f$L(~)>72UYI+o~Vz(6P(!phLLwb?W$w&<+Rp5PoSdGbr-%rn>m2<8ZjV z-bKcOQzuM}mOprUN#~YN7oSKp-I)C~9tkk~UC*{5{$l^8Z||mG62v#^p>L!sJv0F) zbE5D16+S8%x{)`ZxFz80B~r3M=YU@tpFw-i__*tEeYXHlWOP^}f5Z!Q^a+rdLBjHb zF*W5F{Vg%nZ|H%)@nf_YLX~e@@N;0T7mm*E{gR2W27-J8>_IyWga?B;NpN`y1#DR(bv%^_YLo-DwPY zGKVafLfMR*PgqDUNixTLRxS!#@W`)47f6tK2Tht-l8AK%?kjl26$pYqN*7 zoTAe2l4#Oa$=W>DyqyqB( zJ#3NW$!PQWfL@QeACrgl$ywVjjcEO{`?ErS&QRfBi1NSs$f`3V_K*D;)XpD{4>O8Z zGrPC>cx3#2gCObf`!{v`{g9Rv{ymAa!6)VHA~$gB?1O)ElJSMIrXsJX^tBAdJNsYG zn^z>|$JDgpD3w#>eVspf=&8Qm@~?FFm5JRPH$DzB(?O)yD{dmL2 z*2Y)(86Vj^a_Qjak{*G!)Y<;Zn^w2h5}9t-?$}MulBQhhfh+dW?zK)91v)Fi!-6;U zZ_!6TT6iOFrWQ^@EGh>TELJjBCrU4Uh@)eeaq+jZCIrQ%;?_W@TE$r3Uanp?xn#M3 z)~zk?R}Y3`fCKhgQLW*5og;!{<6;5vHLG=;)5v&0EC0;djRGigRw7u2DuZh#1~f5L z11TQMU~JR-P#2PYR?voksv-#&>lDEg+l{XT_2* z%t&064sqWTS*1<9LKPR44-Pe~M~6*6Hg|{3)7K5G`HwQ{0qQWGc$N%zc<)?a0}s6f zLCr=4vxoa=I&{tl5QLU+I97^u+ZH;V&RX5lMJvTbLrnB;k2S<00XLEEFpr%C+SZ8EuEs!Y+YejR1 zqc5-^`qE%0eB+q2&R$QM-cLoEl{JH2_hIzM)e~meHqxrLb~t+=Dg!T0H{*4N6;too zKDf9vb)2pM_0e_3KO(ihb!>keX0?$9j$Rkbn&5UirJEzy4AU{NDwc>T*Pxr&3P(~? zuqyH#--xI0IwHWh#Ra~OZf-w*2evjE*`>I6Q+$Tpraa<_3d%V-;~#GlsP)+LYKU3b z*#>NKAyU?~!;zp0>mZ|v;jaU;YL~|n-E@*spt9(K~(sEG7#m%hfRK0a>r!!emrgxBM%!KA&GnCm&OeA?rHvd_hfPUls<@5F;Y~24uQ#5 zDH(uYl7#na;C(NH9=FIiw4aW@esxc%Q!&EIA)F8MYY$|P{KgY%>!j?DY+*a(|H;;& zDNf8oI=a3HRfY|Vu2~Hvxs`K02pRbL*Ji5Ap~9f!S>dckKiLJ0Z^B$&aggGSg3l<* zO(s;dbNTPk~0Wm@b*c9dWcU zuDtWB$cE_zV!D7{YCl}p&^2t^gE%|Kd<2$^T&@q`K|M64jNK{gJGHO*>3o^-|LcxGP)5Qz=!M`(}iI;0tX*h3cd?+b1POb!waz7t`Zm z6gADnG#lfNtdDBSu?b=`8yZzF7G^dZ5g2CAGjZt8_n;eWd+l5VMpwy!pm{m?6}<$} z1Nh6fJkR#76u`gu-OT;H*$9PH?2uBvX>l>?8243u7etZfTR}V>Wmqx&XnMxs8V(KN zff&U8*@e1ZE)HHqEHVd5QprQGho+oIR`aARNVCmP%RGgL##C=GcC7caLG(`W$1hyD0FS}E1yXHMeHhTaTLc69jLqJHvHPj7 zRFO_>H0@O8;Mg5EUMM66@5w12jU2*)uLwmQZ>Ye9QQM08AJ-K)!a2PcvPt21X6WYh zdcOUpa4=N37^Q|6+yqt@0`j^t%j16OV|u(QDs=VT3i967G)g_hI_vx{|BD^z_R5Vg z!0dTODKw#|P_0SfE=a0KG%SFYaf9?07a@^n9gxJikMl=fssMtGfJkSv#btBpUv)I< z5b^xAr6r@Il)dxg9|Qn}>KRZXgga7iKnv9oi{)Sb)|XA~=TRRk_q#4)MX~QdR!VOu zvvjtOALfzTGH5-zsB{47{ZoT#Fl$rLDqgm+@Ked=$0X?^Sl$$GUqL5VWKa{5M{;!x z|31(0iKz2xqee9sJbPY8{dmVMb%H-_Nkjcc$KnG_HB2<7ep-m|-AmZjC?OzVGbJco zjHB|+Ge!f|Dabv5V**GNAR_=f1x7I{;R9U~li2itJ`yP38$L z($J%jdK4rr`XDYy_n#)3{HYU&Cc8{jz7u*QG?I-rjBz?iyW|+pLCVI|95$8|Pq;<^tMWZt+ z%wUR8+98`93NXiYE@lMXyNo5QQdj#2!?T0t%`3yRbjO(D{Tip=37~ z<#&qfRw5@!)q1w1bs2VE&n6lf!m!@l(Q67z@~g6peO%1_@E6Bt%msT#NG2`@5jnbJ zr`%slh{!b3rOM;HFqS=UrnP}cvk^)sCbR`5H>GB0rBwMPk+`JlEW3&2qKspqd4&t^ z#I$C*%Da>fIUX<2OBmiRtaIc-;n*zNkypD2ooE7y&M_(>0CmX}iVY$}OxTftuDfBA zH+0tUpsAHWr;cSVrw1lYp{O~i3`BBp6HvCu8Cv4X1XK4#5k74KW)C5^$n?bceM^3&3S9E-dG#U$^WzW z5Njw8DZMSICrqFXkarZWDC^VWFe;7Mk~R$y}cC_M+&yp0=CUY4&V&qg1WAL z+x)ws1etP);vVt@VVdZuYr1w7Ek$NWzo#;(sG`*8QF^H+Co*DHL3()=rZVykT{fbX zBrWrlN5+G>iVqA&A0W7*N8Qy0qjR~%o@vMvf;Usy#*4W|Dsr3g)MIfPhINsV86I3d zWi-OClW)43F+?^~n#F&rfQ2j=#Vqwu>YB~h91rHyGErjf`x%*7X5!pLd1L}BrpHPX zN?S{1~YE3?m*Yk|#YS3`J8UStMw z>f%qGG^7_?12?O;hn(mJqN5fN>=0NuB1#+N>k6T7sNVT|A$n;Kolmz-cZwjMty+I?j;wwpT4}vyvCw+~H=&%JVy^DN z_XC^L{}j}M8_pl;dRrvqySnzCHPbqN!&%ZA~n-q5o&@r(6Y zJy4}sq0$4F(m6nMDN=!4jelUks6W>)!B!$KBy>zb=gDlkCe>ASW&7L~c%W$kzLy{J zx(}9I->Azj2Lgjm*EoH$e~r5`1%q2sMMBkf*#avHG#dKts;$J@?MnSLEaQyrhxR#E zf%Aj0NUeG}H>>1<5UN#@?JKu2g-VnKD}9-I6VM8eMj18W(rDG63TKWfFVg%h_2IzL zJG9;6c9-bMSkc48A8naQHf%J7gddXAHR4U6k7o4k-a{cQkR$EJP@%-1Kj)SopL)R^ zhIBoA!yxHnx*|jQOz{@=6j`&{feL)8U6I`CONn*aT?x|1enOou+_Gmu&B>IagA#1XwSLz!B=A3ADwyjz||_ut7SMxFf3gnX4XVU-*$&nOHs&H%Ys**IOv zq|))E5ZosA#Z{}l(1|jnRPq}OA$SIt+H9x;uBF##3{(Rm67#M4N4JJLOIPlLbgWtL z&9pdWO?^RVjAtn;BAihpY)K6r769neLW+Xqy(Ah`g-e-&1ezt8g$1myIQTAo_yomQS{26l9b1|n~X)!rW-$Jbl#Q`Faf zWrKH*7qIWyuxfS7dIqPs@9$2H^J>5G>}($VzJ>g1cW=Y1Yt@2ldw0|Ncs4YxZf$Pb z)(%XiKZT@z3gw;fUX60FH4OWeXLtYd(nh5{4*D?CW3l28$&)QtZ~iHY_kEDW#j~-! z9$eN`{A0kMufK%YQl31D@yr7k{CVdSBb;Bb0k!<f`3I&F z(9OGLGs~n*)+_jtdMMa30@oEfw_gaC`Ec0$Nl5q#6aNltXz6GZKd@1Y>V4e?&-)4dikd z$8P&x;6h}{;mM})#)1KtFQ46Yyjj*?s0_GE!V}qq883)UGJx|DlW8u9q~-)fo)6jM z+X2_14$H;|$1%uFMj{?}^f!hEMM8KIVOgMXAZz==AQC2JjB0cZqE7K;8*}>j>F|i-#BR_idE) zb3}rxzVF2ZqjW|bFcevQq{vvprBN8U;(`~8wL>BE<8-5)0`U+@KSTO1cwYb9_35nHJBBvNJtTMC=jHO< z?%=ymIk=VE5;q$w_tjnT$Y^`(5azXE*K2X>PAlMm6mdyUV2%w=p9?Y)M6wvvX=K+) zG%#R$JT?X>rkVyE*3L}EHHwvEkOss_%#Hj&{vR^@S9(YR;a2@sy$9?N538pna0aHP zhNfBRQ;K1&%!U9;iZtTa+x@n8H;nEsJ;>-&kk8M}-R^_uHqSlX)NEQ?9r!dR_v@|s zM<4#+XY#FIixBH-`JhOqxP>m0X1TS>Ou=Rd@B$6 zgmaL8Ch~^%F^Jg}tuQlfRX;C5)*N1tMVDaUrz%?T0Yw&!X7j%NGZ@;7QU&DqU<(3% z(+Du1lKhkfu?y16FXMF@Jey*{ReyfMeo5+25P=Ox`wIFjn(5Gzwi!5D+oJG4hC@b znK2fq)dJs5ujZSIsnteucyp&}ciQn0g@0p3B-i66A#${DV1v%dh3}er5g!_YdvPcG zYcT|Yc`O(fhgHR)L#aM;j`U*_0Nz?1eo>90#zoMYQuE)l&bRRpIfz^&D?~18&c+AM zMD&oY5IRU*#0!$CbrCnnU4$-D7x9X8iq}XSgf8+YfwRN~<)SZ{ztTcpB7Xn%`>%56 zo&N3m$L6n<&l=fV{B7WQT|TgM00e6oOC+eSW%hdo%l6HNDZ(0g9X~rCY8@X<(=l;l z1tBdUr35h})gev_SkGWv03ng=5mO3)N(62Tl18{es1v|^16~TUM)D#26d42@z_Nnv z1l6M#jd!nid}(QC9^8GVs6d1f^L;=P2H;961%S7 z3g0T;`X8IT-C4OI0Tj?bz4D7L#7S0Kg2am$qJp9bD2j&0TToFbP^AG0Z#Q!?wHUol zmpc+HO@xFveM|WRCC+4j8P^hxpfR@7jOH2Ih)2;F*HVq7F}72U<{8__NA(P9$Vbx{ z+vrF2jB4md)fn6eM)eG@6ry^^HWE?1gB#`l8D$ucE7`yrlPlFkHn0UX86u8osj$H| zv8D0?Y;se1Lo~TkWdm-4rOpOj@uu^`YtFVDL(NcLsHNmCM2HRv$ zp$W7Jo6ZZYl{SecTq|uNO}tcGaZY%tya1Ves=XzOz8z* zA*cS^2{NYE23>_rt)&(3yuFuM`S;M1oLr~p@uQcQD?bg+?)dHc*P@OE$rY7VxPSc` zsJ?i$ycK(9Q`eeOfme4Tebx1^uH`xZ-tOkNZt}1FE+bEd{51aNO4!kT_&eYH%Fesl zh+5ulqA%(MTlqiL?Z4RHe%w3lmz(8V6wyxkI#a#cJ|bnGy~OsE(W5ENafKgZJXFgo zv%#b>anpw5zBkQ3%uKLh&&+exU0O$pMPD@>D9t~=h-++G))Y{i$YN-I8>VW3NvA(&qobPUDopDp&b9ghsfDs&En0<&= zjHtA!SADPzKZ{QMrDWEcF>1`!q@*5kGcVn+hna5_4}o^(BFpj`frXwIXtxI8`~t=b z%n%BuOdK{MLN#nQs|fA>#2*i$C$js+H>DK-y5>h_c8+<;ue?9|vG2P51rTeoBWsYF zqn@Jy%>4kUY!CpqL=Bj80YH8B&<-u$77%L>jCrd)kcyC9MzI4K+;hUQMO^9p z8y9Mi0QiPX0&YWuQEU$cNQNi*kQOWl5?XTohecQ!Ns*HH2G0Wnk=Z-2ftA{vouQod z9W4PZXfjk%CZL2yAln#gB&e0@SH#DYohd0eAdfC!am9><@;ro9)CA6A8zkmJ=rKTA z9fJ&T-jPum=He0L3d9+EAw+U97jPl_QdKJ{H?WK}oCQ;aUIcfp#z8GmJhH76UT zYZ_f{<-Mi@v|2{E3z#f3<*lND6aq#{EQnk_-`|q|to65tJHhNBn{;5^Dp%hD;?*I9;{96C@feQv_Bv%Z{ zNCqiARLV#d5|H{J^DP0Jt5IPUc>qtAhg-w%utrAbk8{|gpRI&i_kPp4TmMXKzZASB zbx;NSdHOjv^DY|$1`DMzTcKafx2gNxt;G(2efDqFk-Ys?;iOD)d;YEa*1!`jo zz2PM0TWeXOafqJ>_5bdu5!WZPMdz(Ue4sQ;Ee}k^#|lJ}RMRdyl*+LiCh0oU}v1r66RXQQVhVjd)Ty)D{v1I05^C2JrW~CWkPA156NP|4kU2OatM%~s-RhfJL7&0< zGM>^Wf`c|K=|}{-*)EtO<~bh!K7H2I5~~*!3eet7K6Z@Sr4$e&p|-0k?4Rk{74Ejx zr-YX~8jGTQdl^7jyj*RGh-z_`_I9c6pT=AKT#e4jN<4TnRqMh&d3OKo)eC(;^dC0w zMOZU^L`V1E6uGyvcR<^CWbZxw=il-+Q=YDw?nV6GUMs8cteJr5Y{*nR15>r5qIX(e z8QEaWmju(rKKlkh>q12pdlY*)DqOFRqFA|&oIn1-6BZE6Fq*NDK5P53N#zxJL*)eK z(4h@+&vbhJF`3)i;+m(tFY#z!|M0;*Uc1UAw2p6_7Gn(XMx*_-?It608m!NeYiq89 zy9i>Irx7HvX??^;Xc#Oh=nh?WMCD51L>I%LB26z%wL;&l(aiYH3HzHcR;qNuwCU#q zr+3H1Z&tj2s6Ghorj1O=+jaHFLzl3$>(3rl>zY*_*f6leEq-P4xa{HF(4hzAtcf=T z<)p3uNYKBecwQ+~m|Y7(=w8pbqrH--6R@#6@Q#D1f3cO5r*S~oR! zygDTB3eR}|M`_&t?GX&v@pVshaYoap_tPhWO5eV9_>yCrD1Pg}n@yXdZ!iD!(|Pps z;XC~tY>CZ`xFc~{RT?oN@jP;gUbk9cm$Px>+H}mcNQc8*7}DWqSeE)>jVm&7ZEh#) zE(IS;pL69n?`n<=E(m`3sWXcE#IizO#qsf#Y|BXl50lzE8>Q4ksMw?`3A5M6cqx`SiDdKX-X9HQ$dO7_fdxTN_ z^-mdLK~=C=`0@Gkv|489G5@ZBGgrdYj*6Oo-imbZlevEa&_8mPqT;vz$vZ3X>JA5$ z8wl*TS~*{&blwf!MYC+JisBQ$58%e^Q%EfWAjwR!>2CNY^xNPtGCud(NC)n-6-7B7Ly$KWW|~}2YrmDu zZ;2#nZPk}~bwJ^$(u_X3c*_MKyVJ%y(LsKfb4&*$TVmZ zdp97l%USwUYGye3gDekw8z=3<5OH(CxSt;c&?l?DFe7|loWS;b_b;obTmO3N6)NQ>-oADM= zXMY-X?!L7pRf>rq>()=qToX@NOWxQ>ZGC^V;q6M)zn9p1MWoKVp4WOkmT>P(pPuDI ze)73T0d8&^q!(QAXYZ~4+FzaJ%XV(*;V+}l4d!7OLdCId-9o_p=p=MvA2 zm)~xdA)Z|c3TPES@U;;p_s;Zs4)+#m^Io^#*kH_u3B9W}2NN%Ln9xKb7Jgi$9{zdo zV!qa-uYsef=V7U-7C}BK*d)KfoaWq-0`B)eVitK@SVf$>af9{V5n3E*ezo(7=WE#o zWmU_$ZB?837i{pA$}ZR~>6!DR<_^Y(|Djs3<;F>y^Og6=_DkV!m`7!9$=zafWUH3$i$hmUIhTtx zW`N^WhZR11CI0w1AJ(kB#v88YI5qX(k(84z8jgj1{{Fc)?7$l%F|%3HW%S6I zxj{WxqoFdA+fvtP6F&joVFN$7=q>*>3AO1K+qirwkkoFvwC}~+50xdJnTcnolW8^`*{PcTyi>6Z z8~B>VlJ4s*Hq;KO3HU?+;RBpg9A=ItJO^oY0UyRo2xTg zQjYJs1CCoOM*Z5>|7yp~K%RMLbnWf!)4a>P>06SYE|pw(J?CFF^`P7-?UO-4Sa|dE za}viN%LdaAOSEi%m;3v}X~}8Tt-CWN{S}A#-0uEU&HlEnH|CM&d|dU)epLP>?*C4E z)pD#1148c)LU(QHR_Ngq+aC&JDg&Ny4z_f52Nq9;cn0o#JfQZNVs}Wj>ee3sZs}Aq zD{ZB-LvQ=Msu3eR;aK#YLyGtwb(HVSq!9hD*ZvDf1TzZeHMQTljn~>Hj#jedW=x-q zmcN=nm55z43NOcmdkQY|o{>+w^792Lf^iJltS0kkHm)@OalCLQ;?KWA>Kf;GuemTA z>K#0!WwAp#<-0KPcC==6gCO%42!LdAk#H~VXK`kyulMS;Un1ea(zZ7;+TBg5?wi;% zl?32kqg_FGzAs<1IB4GBjM3i+aqh{XC z)t*4i?UV`pE?t`a_=|G-@r3~y+_n8PBe#YPi&xwRhTFUX_LYX~<~}SBBPwg;vq~CH zSYm=4Gakjxo=O_dKB#tgt#GtLuh2S_V?j7^g>p2zcT4*@yxEFl$YXc9eSt!FrrBfU zckq`(UMkx?WPs4Kv}kDWetmaCnEPaSUZ0~@jLNik8e8WR)-R^uD?($Xogl&e=knQ; zD8n`Sg_*W)Q7QIdt#%5xSTTlISX=pud(=#d%~@&Q<_EawzjDQY*!I4wIe@JATYDD$ z?iuHy2Y%=&XRd`G@BNhGo1RAx3^EbDF8+KT4KUEJ+25%%pKlUXZ98Jrl!cE<}tj%&g0(>?Q!MmUog z&PF2kT`|hxjf>&fJFFI-Q0@zED17dUzwkk)VKZR7#l8h70f?T0t2ww97H$uj7_GMzP&4z8b1i_9U zBMn>XcT65`j?!o3MSzq~UkDG6et2ukTj>b+WLv+c*bsJkh&TQ9#JUappv2Cqi2uCc zpPN?unt62V)6D0EHb(*{?0@2fN;k73eu(JBjNa>Xbd`$pjGvLGjj&2HTf)BNW*u#+ zUggdYGMZjLF5Hh@4C{C5fge*XXkA%yV`NORui9UHGilI3TX{lT`4WqGCrp;QL-T}%CYRY8>=;)Gncc+$!Zg}?S2!HGrcTGnbJIo2n=k8-DwDBiX~7=q zsAv+SL=h1d&p1wB`Z>%&-xk#F0!}nYoq$p(2|f{J zeufr*C5^CW8oLOR*OVFk>#m`ZSe~~9f0Ni5togFzWVT}bM)V%cK_Tlp;I@gN6%*m} zKaOA4!cT^w7~V?r#Aj>eyZJ*`!GhEHG3=IDMZ}a0!%=A%y>9|*KBK*(g4=dY!Ad~+ zncCRK&Hh`5YTnnk2DS**f;j~21=VYN#MaO7XV;KVdSLZqQNQ`S?g)0p!0X1MzRX0O zSUY%(dk{h_f)ZU*A;v!lQg5g`CS8)XjV{Lp4X%|&xLF!s&LGBWm*RF7(sAjqFYZ)Z z{?)W7olJuUl%SFcL%4}<_-C` zjCHDX-n}_Q_Mmey=U{he2F0U2&X&LLS;XERLztpFW5Z`gR)IeDDnhl-isAisF)Dja zbGzWgw}`!+$85PSAN+AaU2ylmz6a?AGgy^1HLh<0l_)M>&OZ{;q{da-2FAn)4sH`1 zJcT^#;ZI0dgVHip*L}hq#c>n-n=W8G%+6|6&yxSDV1E}0eQ_0^JSEujlz07<(BzuX zWCEqKCR57xPGTVr(TGs`C|711_%w$0ZmNmH-5z#R` z?LMoc16JEuuZx`}JlNPiD?1&9VUV)G|GI$M$!IEP@0Q{!pH_$8<|$ikEA-c&Pw`y^ zpXZ|L#=++=SZSsPR96G)#jYP$yL9>jjt>OvWTkxu{VTxIKGaTD%4c}3qkqj8rqY={ z)bWA8640OL-c-4Yg{s2c4Xx3AOt5tw_}_H?XYvIr#Z*ASGvMs0Q098$QW#iLJ4?e{ znz9=k38@^j%Q5yHP~_z{XWKGXz^RDv+cF@NFrQ z^aZ(KFyEfxc#Txn>Fb=niVw(Wp`E0J=R@sjkzK423a?s^D50G_?6>3WeT=W1(AONy z-xl~{a{iGAc`|!pZ7TE$Z-@i!S;Kor`5boOXw!T-o36psqZZUS?x~^PG$Tm|6BH4} zDPQL~`&+`+8M|^O*6Ko3LBm_m$f6gDEHs?rp`B-C=emz&knfx!SXaHk=`9~4EeM!N zjN$F<-o#2EV~`C%{-*28p;p-@P>S0YioI^Qt7cLV2!_&b3;q+?sugN%Pm$I=<9t$B zb5K~*!2XJ!LF2yBCdtKw>+8{PWfg%AtbuyQ9E`RWW(8hjWw50%wqq^{Q5ivCHR>ur z>4aX6yNn^7Af-}vKpL8ptYcU)tf+!OE51~p`v{62i>d6mL$pPxDoT^?O>7CMZ_~bT z^se70M6U-_H*AU$27YwCxEd||J=|Y=c@gJX_N=%dX^i6(OA#wdB7|UW3keU;jc*mA z#?~raaq7Q@V^%75q054uv`B}c6wTo!TWrO!Avkjv&27bSFc=;UeUGcu!tV|)XXh8P zap{?ax9x~^&){5fdnfW-aZ(fIAKEHo{1pDi=a zu^M}^hPp@#RcN7Aub&aM#?U9hFIbD)S&R3+PYS|cuV`(8;%`T43Txf({2 zFto^J0Y$I`2&gPa|FFL~_(_5Ln(pN%L_@Sot2;Zc~ zW`8fE#{WGz)mn&o?Z4L^!USJX#~&>ZQ|1c)4#MT88J89x*ly;SbTnG!Oqk*VV40b# z8<9AuerI(oZDaNhu^4uZz>LZ`tNN6-=zzIrm?FwD2rx`JvQ|YA-<;khsho$$SM5dK zeGb>W#yhH;dF1?g9n`03(#b(R8FKy>>Uf)~~o9`%LKU z4}wli!Df^bvwUp+g&_(dOOb~$g?e`Ot(+yd&*7l{)6+vAu$#$lD{lI?4E!KF*y?dK z$wnfH@ZM4E9{JBXRhknHP+|rxhGk044dUbpA)~mu)x^!pc{nT{AICkaN(uAOB4Zxm zH6U{w|AdWU5+1*XQc;|rYll_*3XqII!lHKpEqS$ktc=mT_p^-n`TcVZX$#>mFi#h0 z;_FVhKdrZyNil~~<($_)L*8cP_7N+!9La1&A)MR;#DT&8Zhs0{FcDzqW#>w z+OR$UB8dl9!iM7^us^^pdNTZdw)54@6!%$?X zvkTc4a!Po3%XAyA4xhOjD%(&G9bh|#Y5wcjlmXGutEk1%+n9mYdxTp^DM5`-sSsLR+Qf5NYN7*XWgyd@}pZ zq;NJSE_2`c2m6o)Q~U8EpMhsRC;JIyjS+eKTntTHK25z~NmG>zur)28qT%6c{JiE;W)^R=?DQ6cJ)l+#A1yyKTKVs`)G!F*4VF`vX7NV zgv}IPM}=gNj|+ml3=$bFmDqln$uevMYiUL>ET{7(j8+bMhtWqDq0LAcWvd>2y+^Ql zY*}g|f|So%6k8y~ymn{_Vxu+?QTxu@D5Kh`#H}6i%}sGl+QaO|4UMtUkqKNaa~8 zW%6D$q8VcgNipHHJQ2D8SHJL~LaI9I@Q556d{`!0^d^=t};VbG}DgOl7sdjcv&-gal*UaQHk? zXeebE0-tk}W6JWlwD@`tXigIPJ)ApYz4PgT?dIJ(Y7T=Je;#!GBYdqO<&#y0Xn#8* znX|QVZwIU6es?MsfsSbL7A(}vd&#?d;`?5QXkvInf;K%l+BN1hr-?emhjQPTp`C?) z)H9GCoteA=k-$G8D66^tsg)r?H@BNX<9*b6yh^@ek2Ob3F?r^&seXtiWF-_|D5o*q zU~On|G$-hg5VW0F*)W92%XQx2Y)NCsi3W$+_qfE-`lv0E%-r1GU>gI`5c}5}3Pnv> zN0h&=;6fCbxrflWEa!g=R8{vP3T2FK&&M=Y_f;F&p09eD(q{$1lqW~$MxoEq#}I>yG?@08KI^y;{FVEscXHP32Iq;(L(*A{ zBy&GSX9m+MLd>~*f$(WxNF04XQ=d{BVGC0~P8%(BL+^}Pw%25yrg+ViClO7sIk=r6 z&*?xKYa`)|GdXdL$ztfr0s%vNf`S7&c*D-ZPX zn%d>X++@P~B-w20e4Q59Tz!oe(Om6B^J@;hibhT?4iuR>Uqj2&lUdwX#DP>((i!wl z3?qTPRKQ{P3WLaL!YXtHG5#4+5P=c!R~^E)-8eH`_8r@V$MqB8WD*`p9?4{Pchv|mMh2WGi4GpJT@GaGSJxKUs=NErLy$pX0%i0b)%kQmr<%D*umUVT5nhsBLVkHeTLZgcmWgPS8^&`o9W; z2vSQa$!x0?LC;cz>Ig!emeL@QBNCp1u?yr0Fm|47A~at``w1Ia=xjiVSNR>7^t}pcp&A#Rh^Z1;45&Ke&-mJkVDpxg&e{e;VF4_i9LLLH* zz+0S1dekp?GyE8E5qz~K!il87THzAF0pJVYm}5Etn}Q`HRe*E+NBmm4C5j($Gmcs`!32z-1c}uJv*2!QT z+ulahws6C$fx7W0F`x#S!^O;HhSF_2yS_LH`!F)AQ<-T&E|uUXhU!8KQYW+SzQBQM zS?~!6$ar#>SJ??%Oho#Fk#_}lRLz1GxDM9194uf+_f5s8VY99SeVDCx=g4VMSwrAw zhIrpEI8_GQR-8e1lmy=JFSnsCgLfyeuL*ZKdP#(Dz@te1pg??oD{3g^r!lyI-?Wp0 zSkxXn00a^?MA1`Lcl*9VR>wayk!sDjV}&U@iPlQh9u^Q*<(!E^YJ^DDREGo) z4NyBKcxcCr&_1QE(RtM_gO!n%fJ%L~X{I)1JYpH+qpH|QcCkDbCD#;kz%0KGgQX%7a&j_=V&T!){8rxn98Vb7+s6X?Hh zDeTjN?O22>t!V#2KBJ&Lg?nc)qP(W%t|EQ*C3K{IkQ3UJ*K|%Fwi@q(Q5ZtH3gs8z zc;U{DNhJ>BmI8brv&n&mFr+22shN&sLdRO@vS9cdp{Y;5&mkkN-E?%i<=Q0#EB;!6 z2d}A*jnSZ_w6HO~(=wxuzb;@Rc`@s4g&VMdP6QWt!_!>1@#?x<}NT}H++%k z8j-0l)kjb;dEnP(MybG*UH#=XIe;ME#;sX$b5RDr$3J!FIFUOoRBcPTIL*^7`P1d! zgt12$??;7=4vgzV#KuHS$CCHtr-=8fMJu_P;NOS9l7_zeh!|}*?S9A9OQ|@xh_v7J z@xzA4og44k^lj*Qfe#sAJ9e0M-36o#n8jU$=@bu5;RjR(i$lb%6i=g=jb$J~6Ruw* zROgOeqYj7_Ts`RY&QQil*>PBt4HN{fe&mr(cptlMlWtIjV@U; zmqyKBsZ5HZ9xqk{$Y_3ZETBfzFjlijA`LF8Gqj$`K$<8CGVC2dHsI_ zjDsrgk=r;q&q0+DxEaIZARyHZf6B}81XZTu6}dUSfYkqEsb5xXC1&U28}u`Q4%k!v z#k0sHn06ODWxg$Hp3yYR^`~{I-Av9DU0^+wSR&asa`;T%EQJ_PMI%ueT{LR>6CP`x z%qG$p5y?3VnV%w(l@>EGXM#y?ZF(xSlhZyKLH97J^thAgVA3bb4obRf#%FkmZbS;J z{!J5Y2J?U)*V;B2M91ky9HBIn+z!jr7VDDdm|n)6w$#?tlj!i- z+dB%cbsh2ko%*2S@bkL^vZ)8|+q4cgS41aiBz9O18e+2Fhcwzc&sZBcdMOlq%$Pqu zts}fLN!}&AGDY@v{@hq}(D`$-8XEku58KBNFmv8P?Z1oLH_;!1^G|&Ec{b<5#>S8F z_a%Haom&o##o+dJ7WD^f{wk8jQ0{DW3OM&p>}AKnD8^k)=N&6||GV~k?Rg*eczO%2 zq;yn>(^%2KaL@O=)6Xo>@p(u7cLVCH|*?%L8Q01%e$&Or@u@9nm0u_KHDFSp;j1 z;m}_lp1hyB81A3O?jmic3IwUOvik!n5|3|bN?Xa*({SqyJk`+tRwLtr$BhfaX>ogH zB(?J=5dEf)~h>YXQB5sN1o=H|KM9rT%fCk9;w@A z-qS*U@mE|RE+>7UJ5F~fT7EIuLho~q{DW_jdP6I5f!8hc<~)xCe*164R4#WR1QT0uk^_gQ$K3=q!vWYcQaop*wLm#DnAA#I)gmYO&W>0)KhIyGs;^1SZRfh4}lRw zPuD~-A(U@T&a8Zo9(23I%CM%X)_C-V{vZ|2*5tBdLdYfTQ6@f*Ezhzc>ZOuYYc%Er z-$}N;yabYMU-b>z-H;S!4{s|i?Oif3m-g;0kV-|(`~FD+zSh_3-TO$%)V+6jnmo-R z>K@dhpcbAi+oXAM@@>+hIh7btbBkCi9dYX1a$Gtjj7$HI@Z(>h^>SwhBC- z1{**?0TnmF9YbMqa8r&b|hKq_uk{44o0`Xf5Cv(Z3JtM_DNw_ zj*(kkR_w+EvHEF_wz^P@LjJ{Pbcn>BjMRdiZQS0*h))KrI2Mrl#ouo=Jxz^o4}8%V zdU7h000?NkCH7IImh9OrJO3Ln`1e~~&q?FkbN>z4u{E|kQcLNqIqbgyvy9r1J{J#6 zlj(f#3-Dy9lHtqN;@|kaA2+*#>Rr%Fcdn{JMWwCe=5^rh{{Y($t^=cdr^RDAkKZEB zPK$SjWsmxqx64e(d!%tp-0%mc#S=J>HBg@IGQYwOoC?^ zlQU{*o~kjCemg9nF~kN8JPpF`=KdG`xiOsDE0C) z6C9Si^kV1E>sNNu7RIbp;sPVepG-Wb5>u>Bn{T;(e7CIZTF>(wj;)na+zb-6#qYGx zOZL}p0o6(&ZW^hMIrBjnhB0-!okiJ^knl+3l;_LsznTx6I<=g)JvQM{@~N}tTk!YB z2l@H#;$4vbhvj=Vf0l9l}yd(!pxF73uMN|6;}<}bHT9Nvri z@H@HCGtuNm;lu^;p;D=n>d)KkotFp$DJ!pq{-{-dVL9b6f`d4&?YCvKk5}|wsb6`@ z2sX;eoc>xkaZ1AD`tRhI&%IXuGemi+_Q&h)Ut*eq-PbXm|A}l*(!1~X-ja$$dF6i< z-kvD5u3`g+_C&sVc>-_zzM#EfKXxIk97RVRf{mxTof)P@ebafS0Y)@y*Zpob^i^yEuJKfCCTzTmc4!s9iyv*5N)RQ8JFF5qc1s+Oa68r(L4-NjKm z13Ya+8S|wTfz4Fx?=`jO1d}Q37+-oHuzAJtIbZt!7wNZHT}XeVAd+G4nJ&Ex@$}EN z4b;5fx@rfUw|yzV-x$@3xJ@xBt_$a~7}odX#iYo;{v;St6aMH* zs3=5#ReID3`}*L}MgA@~i;d}Qm-%y9!SIMFT2n8}c|G(w_UYY(Vp=}4q<|e*gZ;=( zb`FX7G03}F5xN;&Iu&uPFF^R&qBl`Epfu-GLga@fDzn=@WbiQAvn^fXcJU>|jQG@J zKTvyEe9qOP*;&q2wYfz|SovQoZ@Yg5$4^XiN=eqX(7}$@#=7q874UooZ?@Le zR7Qk<42t?;T%i2qe zWyT(H#C~ z%vxJA!0?4Gn9$IenZb93RE1n<=cXHIbcj_*XrJBj%-QRDyOXRoO19u8`>@qk3TI|!VIq6=e>ZWyF?4=og zyXL0Aes#g<0xb}{zgC?`NEM8Bl6L@=%%C#DFsFK)mJFWaK@U|tgQn!&S5wjn+ktD` zwgrS9APbfZQETW9Cz;|D3>p|TC203lZDS3o;u#}N9j<5pW3EZiOdQ>vF zji=U$dPGnZNUu7k5jFy5T(t%48DKLQ!*u+E@&mW=rDw5Upt(@#HMJg;3(&w(TXxJP z)PXS!$1&_V;Hf~Giv5X70FUyDI#EvvM+KKx9n%ThfXm#X1*|S04HhyT2T>2eqx{RW z*iynA|MFT<56T_r=M*hF<`G)KLWbiw_B`-LaG8p&L%jj_@w_`xk%Yqn%~fI=VGCf* z^?%+I$bn0~qDZFB9_! zonRG%IF7Xf(ghEw*m_h7sIbaD1HkwOJ>+^&fl7Nsu;7ONAy4uRmf7b3zTgv)*OmXW zFxaA>*OJZ-${fL1hPdG8;vGkU=zTpMOgvF&cxYu~>#e z20QF6`xc2IoL5v%ZiY(z~|vO=uBHO`8JQq`FA;7?l^i3 zzazbg?em?du;R|T(l5zBb^eKKr;caSZ(4fJwSm$mZ>;9*{B zC;16MRbaiUolXz~9Jr|qXk9=O{K(WEB>xK@=3CFAO9``l>$TJ#vMbQWaayj-B{YD^ zjLI>zCGbL^PDR&}UxRyiPMze(1Z9ExYGoQ>GhoGaT0rXn;$Skf@()yUFlTtVGLO&!Rxm2Z(N;jJz=w*iCntl@JM^98X9RVD&uV2lVF%#E9bQ1| z0dimkvvQCe2x{?tX3=GYMZVA4a1Yr9XyWKC2jvp#!8k_H80{PoC6K4mev%Wwojkox z@*{$hKz=nSjUWP8aP<~wX8=(!jv4fa><8}T%g@rj5GMKZYkEDXF9ct3BWS`EUzO=Z z{Y0GuYQZ{=_?q}E;t%Q!umLzI*bJ?LjTo~H&s^NLgl(7)K(YipBngQ+MH|PpQ4E@^ zZh34ic+)C((a^`Ff7BaNGZ(#*Xh*cWXaQ^N7% zvou$rgtk|P--37ZMIL*thho+%wlJ*2@FiFoF{&Cbq&B?l+)`M#_KQPZ+R)M+AnH&W zc0stAO;r5BFay+I>yv*`=ebW3eDRi<2wKY2syOs0)Kr8e4s`>0QeySR!jUcP`iVdg z{2SCZVqpOqjqkvhcD?XyR>=LvF=kXiO@`cDhz1m9q2OGcUK>|;0@|Z3S}QKQsp5oC zXj!D&^SEaIkID}vQnrTbd&5gfD!@c)_IHk&E|4IMQse{(keA5ySm4se}&<8BVmyYb4S3$!fik9rz0-@`Iz4PG}~ISb{fDupw;` zGma#A`_y#&zo4QJcIdxYr6{(1%~z?&9?pv}lUGw+EHS$r?UforAs*GlW=AaP19u59 zLyR|nnlSGGFPO&=)jObFp~xMtRm~2YI^&NZlG{~Jd7t`>O7tqfJzCLhbM{Tek3hx3 z`xdv4d^oRnLvQ!xe4SEBJLQgk+cHCeBJ|w`Nwj%VQU9}h_DJB~KL&!UsQ4K#m8&ID zywg%cS|S$tnSbuwVl&;s!&B!PWZ?}$YxceTZ-o!dRG?z6Uc^79?} z+2sMPmoHahuG#A1dY&boRCxCwuRces_~lCBHIy!H=vm51h13Th>nF9^U#=|OshM3~ z^7$@1X+Rf*w$G50X=JS&AQTVqUV`!*P+o%@G|da@oFQwF3DlQh4TS2Lfzt)`Pe89~ z3GaMB@rpBVWEcA6{Eeu}Z!Y&=R=#JI)H@CPYB#Fg8J%A~FSptle0zYfGk$1UyRqnw z{KE2Gxh+k>_Xg^B#t-|RX{=6t@U_0W(#7v3yO~WpnFBcCf#H|nA_rWA%AVo{K}Nl! zk#%x_t}tPS2AAE+rfKE?NPi{6^<@P9w!7}vb1hBd$7#$@b;CGLc>#IH-DTy)znrPaca!{czXLvOd)oA@KYHM~t&@g0DU ztKR|MHsRe7LRB5|IZsrL@9ifX+9o`)1TR^Rp8&fz3a9?v^yU!|eqw?q9iYF$BwP{& z<(2j}sZ9sdFU){S^zF2-;SBVuLc80WJDU zqJu<{H~S-}L~Y`JOo>9N+nb=&?M-j?pBeM>AKQ;;VyDn}JVTwVGy3Llj`V$)dL?Oc z38&F-c<^k4zQg8s`$>}OTSNTc+I~B5v1L5{)5arFn2+0z>fkgkk4>HEy0if*?$`-q zF!FNY@UUK<5Z%8rZO9N9TUeq`0A#x!`{!v=9H!2-prmgLuQHc8aY9n#6%##m|9lsc zTR!%-mm33rgol&TWQ3Ml%GGc*?~a-WM8v)??Vdm2c`s+s_;*sQv#7C~T*uCh+gVQI zIpn+VI;t}Q+uS$gn(&Z~a^Qg*#XB9X1-Di&U97E!8pFR9n^1Lheo8FUh}G3?MFXz=##UNY?2(U=#;T-_7nM4xDZ?uop^ zt>LF4E-1H#`|#iHOO5EE<+}c9^A3qsMn?NPe4QeG7`e@B^Po|9c;zEUW~5cw2OiiZ zrM_1Q+H>9YsNGU~#jnGyZyM2`&i+_fQ`b!1E`hyz>I<&%b>uI#TJl^nM=>?U=GB`cL@!Je2_;RMgkGxVIatUM;i0Y{AeD6C4V7{y*IPK zb)di4GMDrxbhaRIl?4lk3Zc0EVPRkj;Ck&Yu+wvQM{*whxcf=rizH#*G#MIw_F>Rc z11jPew6@(&@|>vS3jZ=pWDrbxv%$7u+hkK`@ct>}!dUE0+}Bj%ACdix7y~2Gu8Yq4 z)3Q?yJDmfLJKY1nBc*1SWfc+Gw z5v9Ng^LsC^KQm#hjre!P1Yv8(^K)<#ZnO4aFr3_kr&yo! zSAWjF3v%^}Z;e6j{?c4@6fm>Y?015B9|gX?hX?jul5;bRJ?qbvFx+pUIL!E=1_T6w z?fFl!CCcL`Gd9x})3S0rx~*-C zV3;cAx9ighlEi+M;t>iHsG;1x5n7={iIqT~B{kEfD5}xcslM=t`XX(EReyD#7^N9ZVmw2=IF@(KyQt)m}0!6viN&;~( zUT1@qS83E)FBh}J`Q+gDP6>kJg7;%cV1lpMNi+-iGR|0L8 zaR-w@fBB2itZ@vc0@-Dh;STYqLHq#_Kk3+tBK=NsiV8X*SPYXU?45ctpq@P@{5Q@8 zs))9IMoO>}UBAsCNmRo2AZ)$X#uL_%Wws8GW&0q@WFgDC4#cwnBLOOj56=?5C>Dy$ z2|r8;{}G^W3*Z-pGRi{H8KL65@FAC=!a*7dWv&TD`-EmK!VO$PGZ&c!+U`T$H4-+( zAvFKLpb_Um*l(fVk;gWPaxnDsKM|>!qa{z8HJ)+&A2HOV>%;FnFX5q?(S+fwX4^`+ z9a}s))l#ouWv_iqcb2{Mu{bEg`sbiI`u_CVvn%N10b%5@vTC+Yye%~;;IVFg*i+}S zMDf57cS)HWdBn~q3rzfB>{qDc$PRi%hcKs zDLoPXH#vdjCG0?!$nLH=D9H`2=8CzG4fk(bm$f>Jm(R0m01t1 z+C9eF)hUM<7ZNVc)3(*9ly_YnhN^3M6jk*t?8H_|GoDsDDPEsiI)hJ@S~M2#%Ia0?$OOYZV&vZoo5~puika#7P!JQy*yeqtR;CrCHlHE z`%MD&(^hH1SHb+pV%MUP?*TQTqYdfvFSfXR*&1nh^)B;k8kTf3fL?cCGrvAe8(;FqV6!aAjlkvm-Qtzv{)jL9si=>WuCVH6%eMOk*yxxH zb@n3j*A`hGtFf?>Ij885Y9I>QCKNqo`?sYjvQM(e7D3NGZLaG>)T}v_Gp% zxI((*-JRa*uF;#5u}CbFnTgG{*#RsV+f>cI(-(ESksrI4IMiIgV=-@{fdkq(9@a%3 zT-JqtMokF5zw8piu)C~41{IoFLI^8KMlh4(SM5|2d`2v*;*`eC&PLb7DJhrg=vfl| z4&k1we1$&r53VF=TjInpl5M?7`N|pQP@jJW^?41b&v)5pyb0ceNv7zu21s-r?D~p( zN52!Tt%SY<1q$``Kv4$;3MXY!4DJmD)5?(OQtB%EKLsKlH0BG9>Wmt1t2-g}WV|T& zNkwn>9>=?>Jh&xeqHaUfwLJ>R+YIA_vxc+&mQ7pn@{l`k`ph;Que1}{myt5+6lOwjT*DT{WY7Bha#ox|04Y1?b&XVNQz zdY#2ir62SC3DsbqqxevAP2M?ZOI^+bkm@bR3Dn(6Iu`yQVz$-vb5Xq}-KsFO%!CJxa1bm8YE*t~DLfTD`5^^287lJfFIq-Gfs}P+V!~$Pe zehKNgK_$ko7jz8bKMB#sLu^QMXoSyg1--5_39)HI5NH_iDqjwwC9h*+Ar|yHzd59& zy-uejtP6$1BEU~!A-=a2!hrm5WpYi2@CYg)bj?dg`1Y8`b5aetbC-M~FI<*CI-HqY zyZ$Qxa%Y-xT-J&0n+Ti!{F-`uiz>7oa+mo0&F`{M_mlwFN6Qp6>6;;WNJQ6q z5+^BG5aQC}B<~quGmq|l>p?C@x@BY!Wl|}uo4p#-Hw!*eF*-LzlUTS2#fv|2sMZsW zI6!(Yp|gmrY2xN=rfJgE#;b03X|J|>SI_7nctMsArdrwwJF z#AXj=6A<}Bs!miCHvQBqz+o}zGXqPsk!>b?3Tz$V5WVxaPmzTYzGV+UK|w8CoHLJ` z-5Zn+gc6!JbF}+i2X%!Z>dBAzsdvBLO9yJ?+Kj-(URJBFa5bWCBORUD8alwKWYZO1 z0RienU7@+UOf%B1PV_?(Z0bid`r8@4y0B(+iXx)= z1eSZz@YVS>qoWj&A7b!kYmQOc@}n~p5wSW^i6mI=Zo^lQj&_}Bm7U@5^yNoONigPt zuq;uEh;*Ik(InUk!S%Drzsr)^c^E{I*X5RwWD**Bo2Klwh3V*JDB z^h4D+1+nY*grvelV*bTVmwL#KQSjHlhnEb8#|%LAClj+M20#9-8yTj!W`UTJBevMr zL^soc%T5ik$sm;hFfvSN%>ptdr`BSRj71{5Vq*jegcmWQzf^#a2si)7vPG^e69q06|YnaEA5p48GFHgjL-HitfK} z&0ce3KgV#T?>0g24nY5Ehnt|o1JJ*3m71XAXZ#??Clg6=H9`@q1`!m4h}CxQHX^v0 zKCSFX3bNmbv1iBpvt3Iqq1DUzGYp4W6Nm9r7Wk?Es72*0qTR#b9-rYJf3@Loj{>;I z|AV$1p0L*b!~bp@)PUvqj&s(Ll^?g({X^_to0fr}^BE!8rT5t?Wo01=b6C>~{Plk# ze*UnwY;!U2b3KEVT`DiYRg@1_to;NOpxaz5{aj_RuK#q-VSfN&GF;ase8EO#Ik#eM ze1J33hOuNJ{;l&Po@v<1vU#~Wbz~sc>9A3ntt#^69JZ^7-G8Jh$H^i+%@*bRk}~(N zR{nbO9X29YC?&_o+atSM=6n-uc-4ExVlGQwdQ1+f2ht<4ckT?yy8 z&%A z5^GPGMJax26+-QM8CTF2U8<0gkm*;b6t#1+X^~3}9@=V#kOWUcGu2kz-LUn_e7*EG)m4zlV4 zzh)+W!65fTrf#C6gjO}w`oLAMg*RN>RgF^=jYF#%hbS7Ceg{431NXlc z`g98tw-*v;0_hW{nFJB_ZvJ2;mC>df!P9-@j>k>yb4PBr84Zty&GC4ec2&Pb~R&-0@*tbq?+w75$hxMU|Nx8`L8XR+aW1u{%qg9eJlFt z_N{2=8xz~Z_0bn}sE%)zL&2*7U`jwJy-o)`0kk5N0C*$V-vmOxiJDNP1i%`>9AgOm zl-kNo^h7Quf;Fp;n$Sm2=%6Na(8A$#@uL(CU@HFffo&VXwtZl^S3-8ikVZ+hSNdpS zLzJ)~T37=mtbrCjN!$B@wl{QL?a&h1suBFe1k!jDC9Fu%P-z6O0uiUwUfo0sLsvC$ zec9$o1={AJ_6-)W3S9Y@D4g6}zj1?A z_v7slH6WW`ZV7l`we_Q5VB2oc1-`lqw?d4$O>VY8Jwpok<3?Q{WN2->B}SYf&6;f! zvSM$W25@Ng4&cmS-_ z1XdaVS2cmFfa`@OFmeEVU~>B#%C`P>jdFB%2k9Y|_H=UlSIV{q`g2=!or0RpJ;=%t z$VOahXW{YY-MX~#TchQ+;tli5b7DL0u9E~Ej_e5Be_Ccl?(q^2-cRA2*E#AdFSoM2 z#D3293s<3Z2T6aW72OS$bbtsh4gXov_9}4CkDZ4Pvpc@;BjnDjX$?E z3x>|ABoQMrSt-*IlZ^Y`>|d3U2pD^%-E+*1z2xbG;w&JqGw{*`$Nculc8|PvvSU?# zd%I&5wtc}7ncF_%$gobNwXazuMz*g_wG(;^iZ*iFpWRJc@TfWm^{T2qhxMw$pF?;d zznmj^G5qhU&95C!ELisT9!BJ|#_m%`=KZ}B*%e>M#~kthxf`>EhHs*2TWIzc`ag0T zjFC7cDBts1}RoyQu3Q>**f%TU&RAl??Q7+Ln%xFub2CuRd_AJq&Po`BKa z1Q5KR!rt3|6J`=1(wbw`dq@Zji)Zk{$C43 zVPnLI^ko2sacMR}0GkYy{h5WLFft_?In##Sd5je-mKqx-=6key++tTcRIfJ=+M=0^GpnreaapWM4%3YEMM^ z6Sro&#ZSM*!i00-==jLXspBz;oS8fUkSRk(4q}d8g zr@;t*rhEx5+g$^)f`WPk>(+RTaiER!pen(-MV{`jpp^5V_kwjZJjPWZmGhw2f^`!- z-IbtGS=&oR0A5V7~=(sFML$I!k$G8-PI|n)=Sl7bST@1212ihxG z_l?K62(%#sVhGgXc)ANgDKem60(BKU#swf18BnW0T@g=rK4|nTs92!x6OZvH5b7-G zoj_d{Pj@cp_*qbZKwTP-aSjM~2J}#%?k!JuHpuD>$V8wnhQ~Myv~e1wBv2Q|)BORI zavF3(pzbA)@q3WUX%N3a-E*GqbkL|YXqCUtm&Z5_gpvjg^VdD)=}rM1mj>1I*SYZ+ zCxdXOKzaOi&OF`kKvt(f(foCGJjQQ98&V)7f1MRicLFFy3S`S)XU1b34^oi=>GRha z^K{38MkPUV{B_rPjAKA3Nzf7gI&GfrD9~|9&^G=$H6G(g5KaO#$5(fSr#l>EB?0Q; ztGmc!90uAr3990&JIB-g29$CV^q#No6p!(1kjhEWYrZ;hp6(FP=n2phzPh74#xFsr z6QH|%bq9F5gF(knfHe5(_V5@7fpFrWGkkS?Jlz2xD{;_XzB(QrWy&qs)s7^N%caRbOc#yACAlRN)vxvvmJis_#-RF*Y z)>&cQgM6t1!3MmVSvE%kyf!<*_vgFwR!@F%_3QBmD9J zpQ=FcF<#9u9$TFN;}7a|V{wPm!lw@K?G^~$&a3&H#}*b~oUZO;B%UQL+_ax>j6Zl` zhvrirTcrTw6m|Md@u^e75BBpF@CWzq&~)apl@Bm}r|xq@T=JCg&i#C7{^05znpQlv zvH`{k>h$a44pPD&_wn8256;}7Y0P6Q9bg=*?xQcBB`K`Ck5808ICO`mHjnLz0OKfi zx}Nxygz(H>z9qh3&mEdqcx;aa7>BF-=!#292*2FRSHl-{Qt17SW{ zzTo{kH2HXJw+9#psQajkONtBc6yC)Y+)3jNq6gOd)@R^sR_#)1VMLWLk?>iN~|2mteDiawW{% zaK>v{HDVVGpqsCFM@aZz^4=&j|7les;y0~w`o^M{>-pi(nq?J>8;g`JlcVzL#^UZR z^Owq(8;fHjn^+n-L%vwCqRIhEZ6ez!6f2f*njgvHmx^i5o~_o4s$D^Yjl|KJn3|zv zLeS4f;*U+!vMXq;k@$1VBm_+~5(hTTk*=W0Mj~;`Bm~Vg5_>jH<*uMP#7MQrMT8Bh zU8h~P+-b8Ds>(vO`~9*zrTmJ`yMopltp_);3td5!M(gn{lMqC2BzA9_$GU=8jl`Nw ztT#-Ex!=z|*??+?P=W5;=XYz%yb9g7&oAo61hfWFlJ(AW$Iy&i{L%*-;PgC$8Jd9WVPMTk>&RMN)qK}>NH;)`w4IjVM zL^52h_T5;1xKSwQ@BL=Hf707%(mQ;$`qoCF7~bzF-X&~2^|v>LKGsXWZ@;m80H5DX z`kT~D#~h|3h3ROtka%eTsyrRkzmTX(02liY=lS2Q@gMGGI)+o)4JqyOl=id%sLN;g zvrlj{ESy^AKWxWQKF#gdAV_p#EITmZY5dj0zF7=JD1(%-VGh=hRN(6D8Ccr1jR4zK zjw>3+eU!NxJ%g8>!3V9uU2mxU*r@!z;cd*x5AV=R;#R!H?rAeGFJ@dL_a7qnYcM`t z)`UE){b^Tw^)$S{X-=Zk+_J+QJe~j38J)#=6v~*-K;1c38mRzxm4l1MVIN7*qG$4D zXYzyA?znEK{Xmu9|I#@|tIGR1*^4H#zO|=g@tBQO?y&5Xd^K=0TcohWG6Az__Ms+X z@nGd(HkIj&5cjJYIcDldb4Ez|c~>faq<(ZJX;4p9(ylFa_7F9x4=O9Or~}Rj3BUZ2 z5mP_EGViFGu_Z^+tQT@E0E+9+QSdGAFK%W40~t;#wh1uO71b>C z0Yuv8C@xYWI392(wr;w0x7=}??#wMWt!2|~xaEGcg?_P#Hs5laZMmOsp|{+Xv(z{? z;f5Fd!2_b(*aGX%2#Hl#J6_A-e!x7NN+;&p-k(p8PPP|ia@yNw$Z0oqDLU@*}mv86oYLJTh|2@4bH+N0*wWlSLV(-3q0J4m8m8 z$t;}(gGbmZuaNuQg}NMK-W1a^rbb0BirM!#Q|%X2Aq{`wla7gV_cIR<*BI0)gvvt}@YaSD=?AV8~C0=oQ$bF$>7-xbHMoOe+v-cgU zGSp@7o(cC#pekBST{uFKc&qsH?$1b@=wydJm<`bf2zaj372SizBPG(ZY3xH)+PXCI zOgJ)uNU)sZJ2IA&tT=zyH{H#C9rl%b8M0Bj&KYU?gLw*fRpWD>Lzjp50JR{8Q5U*@ zupEzNa(mE4jEszITK#3~E~hz~2^bu?LEF1<^D98wR47~L3^Z9FB5os?6Ys+x)+jak zdS?0dg7>=KSm<1(;<3@TLxOM;JJzU%zOV)!ZFknv1y}!mh>p@)97$@P1 zN5tl6)h&)P-b~J1IB`17pBrXX5lD$re3^(7dvm-zkn&RTO(Kr?>Ug;(J8mX?T52h$ zti_}h%t2WTsjj6X!eNk_aa=KOilRI9CVnq_n!!13zYLXAD^go&T8|k7M{j>1-w(X} z;O2QxNXIR)6PV5+H&0+XOC9CW)`+K-O28L0UHXk80tLNw6cHWjD9&s zGG+Qf)fYq0@PGG%*1V5EKJ*EW0%|vu`M+krsW7hj1+-a|rhR1j+Huqheu`8nH8cBS ztyGYAC}w6>ib>YwECz8avN*?Cg09(YGDp+0mmSJ}K`K&wUh@`i_7g?|mt7je4++ut z`0XDGodwJE#}e^QF87R@I5plwmUY$}oQfYbMN(zyB{uN-?&RZ4)HM4^MKF?@!VxIx4+%=LB z$IS11q5ltF@~E8K_RVLb@~htGUF~N$dIH~WE2wu@Jx_`+tNRo1srH`qI5r_9A?W&T z)iT3n{B+{<#J)TD&#^27(q5@WyZ_k26xWquqco)54_G00knjF+ z^LqNQwzbTmNK^LdIla672UsSbAX4np?U8n{>y*qah$F*fQ7_LwZawoH><#;Le`Jh* z+_YXXB%5jSBeG=UG&S=!?E2p)`vX*?1#X4_?Bs}K^#j__xEBoG!wEMltGLlIj4|!A z?b8CLmox9Gp4k;wPcaQ9>q)SCqBzb)u%lg&@O3>cW@bId`3gqi2W0nLW@x$%bk+*}#p&{@oTI)pZf$3=qw;~ZDgF6x@0+8-1Re_e&Ify$2MuFcF4Fhmj=jQ?6fW`a>T{>A|j5-cse$toXhGKmFkWl78#4z0S)W zgm69u{rsd)4L9^N?6%UK2UULuO8$5ARS-WM=-q91^yj}sHC0aYY zU%88(WVY{e2;o~6{&iJ*J@ME-0e_&%QKBcmXaz3__rU$dm9@7re8BJ0c=l>y&)z~U zZH!XjqHw+FNvn`ooRS^GCw`-Vj*3BzqS6&+JC$>KN0m|)$s7eFaCdvH3jbMSmW(9p zlQuY6ik{M!pr_Jj7qe!jPayY`Pc!_<>RDl z#1qJPWdG`;wNF!*W-c|mw7SI5?1=5F{#&or2d5VAZnz-4-Km5Fx|_XQk`)>ETvRX+ zouQfW?za&Ql1h6$i)P~x%A|bq5AI&I{f_sz4^Oo_dHOW0U*#iy^h$0+SyUY>D~4AHQO7>y)?V? zo}0l_w+VU2kCgNWZQS(lWE>YT6J~)Zlz>Fi8dicLhvlR=tWhsfT*|YM9B>Nqm zxYrSTfvgYNInyRL7Gde{dsC#GUm8A5a7S`)F2H1S?CiLV8)-A@8uG{w+h0tx^#CV6 za0sI|nWJ>4J1qUrZCfO_hiTMaE>2CC->#r1Xt(oK#GwQl1lSQy(2lDVr0!WOzBAwt z>L0-RP2g^YkX?31U+p>a7Z9}z07`5t;5J@UU&I4rPmy=7I?|&QBrnpbpzxFYP|>5hFZ4@!N1;QtS>T z{a1$jM)fs4W5lKTd-MYVC?YsIHkht^*gK{>MY2U-^J&b)zk>Qngr!I}Dt`MC8$2Va zVYu%@><$2WeE%l&1_1q;Y!B?KR;ejfQbC#@*jK6~0Ij&i1MEv#YA6jqww5zJv-lRj z#2Asq+tVtTAW3YGoF>USe)P+#I_@;>dOd&lD@9E5Yw_>)0bR#{## zAv5mkl0rSdp2sStB*3B-Q{KX)9k0k@PC8zZ!x&b$-{WXkxZ813wBIWo7k;hz^vc8@ za8koIrQ@&mfK!fdI+Zq^Szx2~^lL(CK(xFM5c6QAaYISJzIRPJCQy2YAi76k<`59m zA-n9JAy?A!OWncY$;BXDx0AX-*W7-0@g9BnIz>?XN6a93aK;hW22V?@NyF=2Tsw=2 zc4!pkS6CBP+V^Ve1a=l19SCfeQ+lW7e zks_Oa+K30@e`6gu*W>Y~Yv%Vh;yd7ZYv$KE*F*6!44FHe>;I*sW+6#H{IlFM$TJ10 z0vDm#UvFu&8a!OO9fds8pDNIn%6m^)a4MDeld|A7>o;B@5VC2X@`mJiI2P zTq>G9Nf}`HL`z|tKUt?m_S;4(TjYvTtw?#5T_d6Akg8^sHC#bzzLgrnYxeB$-i9RF zM8x5FT!;*TG+#8k#wZY_I?V2J@efvZ$|Xw_b_Dg?5~fvv6b>P~UBq4}Kh7neF6>C$ z^rG?ruk;?5+84@Ca>=rBq{RFNF$TNj*-)&g@@M3c<)Qao?Zz|XKYKz`FkX7l;o*iP z{I4#t`HkI#<06Jf!*M-N}`^G9zn~zSI zh0RCkh+#16la<(J65=a|%;d0GUFI9Atc4MPJiNew!Qr9l{_H7PN?|tbK~4Vr8H$B( ziP#;I-h2(T1~TA>^^NRfRjrE+uT^@4@%G%*d3-EKxgFEYQSQe`v%M3z5p3^ITtg=599NV@y3I{pAHT~{rjF-vl;`lJ z8{UifTWs$i7$*j42$RDkWpTUK#*4XzlyOTY$(2EZZe1h)3$OS8>m*`jk1Y~${vW>H ze#%1B9XyU3Z5HHpDDFaro#?$?anV?h!@F+K{+mYpzY~pk@|Nx$oYov$5_osis04?F za>r+-p?KngRodXn*VV9QCx2G!J2+v|yRnk`O9dy!8I-QWzFi$7Hw}`-)JP0>Vh}lv z>rI?s+=p}>dpk~}8a7%B8KP+|v+7y?U(m23QphMRh{kqj`P+;ORgu8|A=fzl zZ^*&_C6@8uk%RwBEaSf;2mhB?#(zT&{;#o&|3?gBXcpcE^J{~5Bac*iAE5vGpqF!M zG2B_!tign#**C<6{Ee|ao>@{)3Q^J?<$qBUvS~LljJ?K zcM`p$%pI-Wtv!(eD$`0|@P`t~A)I?wKgPcUMA{4I>9Oc<6KYmgT@a@G6Mc*b%ah&s zWx|NMKZxb^L<#d}@VgZI{vv@QIvEHX_TIG|qT@l<0rp}GB z7L#~3*{8OUE5c8XX9J~6?@21c*9T9wGESvo7xwFZL&c{3Es=QZRqg+O5Q%%Yh{Q(! zib#A4_kST0?rzA@&803@#irUw-@5Vyxj#)`FTw)uua{m z_^h@l1)yTw*hlI}s|NWn(dOxG1ULyl_F#QUy)>^4U5qI+nN}Nt{fz5{a=af)QaO)t zXJX;Et1e$;+>Lh`Az=}$ueErm5=S}W;j@@y^XZ?gl0S`}eDERsY-RVmD|f0MaUW#1 zWwR8MFIJsJICx|e<63VbC1Q_J=1ET1(JB0LjmQVJDqJzxPBvqMGaSNGwq+4H= z?$%yyG3<+?4YeKGzFr=tF$$Smg&d)*r1ku&1$K%yTOk%JM)*;lh%^_!hJ=26W7ku&d(q5{ixy@xqjpo|8ifm zB(+ABL)|w*BR0$XY9NPe)N2B*Z(Bcsnj-WNCd6f;X3h4REL=m4cFq2pJIEYA8OmAT zrD9|0*KbNLumoLprt)HKk0=iT12Myd+0GLK&$^s4Q!a=`ehU@vibVj1M5-(2c zT-^5Fwc?)cSo5yM$w!psLJ_t-GiL@uHR=KGFhAnhau58iqW}*p!W83SZ#j945caM0 z$hq_+%n(e6`>!2%pf({Th5H4;m}>UR*Q*RkEN6JKMuS@R0&6yn=AX|S< z)pu)92k1~S;3=DTz4xMGFLSv1uPp;)+a7s_O*yOQe*0tm+-4UNO`o|pj#|I_d*pV7 zUpyie%Z`(ly))x+fj~-5?+Ux(H)M^occ&ITsq@H2vSvnEKYigWq1u_E_Ak!x(gL~j zIn`(a8ebhqt2HIbc#o5pZvPr_t6oOu(tiC)euVDr@g9oD)vma@#0=tV2!$Nf*d)qe ziIMPU(krN%P&#~|D^KOT)2%Nd_kGhkKe`)EKT%5lhP-b>C=GL(dN&o{B69>AWiBZc z9TEm!6GysEl^?-MVdHV<*S>}gMi1&+Ly+jEh1LZr#4Fs1$=y@CV-$6XZ&!8KbX${8 zBHDcRBV(sJqZOTS?{Ih55?U-T5;ch@kuFmOM-Wnoc$G*Mf{$UEjP+2>p9q6*)i+;w zL_FDx8-h8o<*7m?m_w|P&zL5T29;pPjiL~SU@e@xi;xn|5f*qD7RuHdfZ21!Sx&{6 z7N*l8#DRN`Ds-0{#tvFc|IRtFkY0?5Vwe8gWWR8j&g?~emA}9BG!lVfjfruY6ZSEK z+C;^z-=`&#HfbjsRSZ&Q{!y-Kv}*IMRL!1LRL*)8_nMjJQ3379v_>9S(O|g9#2h}l z#umqixCSj&3{RZ6Ip;`CSiOjos`*B|Y#mUUZ9c5rl)naS_VSsT6@H=~9I{_}DGrM6uvK}B9-s4_i+phrB!_7VXk05w?0882o>H?zi5yDD5{+H8X=A57b&>^^-bU!Z(%!P#uL zDf&Pn>Abf7g`nLPaaLdGf$WE!CF5cA?TG6WFTl9U=Yv8khqhVotdkd2Nvhv}Nab`r zd5=m(T`yQgyRH;uH8=5Kr^vZ4()C_oH(7VabLAaYyc04 z;>9W$S`{qLq#9w3wP92{tP}}7Rskbz^!UW_4qrIt&z`Zm%1tBe_)<7qTcXjc^!%&B zq7XDCxt!0z{MLHOAIF~d-vthjuT6@*!w9n~SdP zrKyf~@cCm<&AqDcPrgr#XI<~$t4``9TK~Q$*BbAc`i3Ef@HtB8_!4%Qu+Spcvb zlOu1r5$oeGr_yw+{CE5TPwi9h6FiC%e7oz8RUU)$mx+LW--i6Y`4a-AjyyP+O9=6S zTwTP+JjC+k>U@%#zFEBipM350RUqcJe+)?ohNBm0-San6v#e9`qYa$ zoP&0Ju!iOY6w(Oz-Z zQcdlSx;PZczvw4sHFzb%`nbuNqj5gEdhCBlh1R=GiVMFau@0!HM+c@3<$0XkSz%pO z;aHvbslS%%ve=Pf8lt{CdE~5OoJM*;0E7?~by9fjN0mZ+@M~waqe?%G7QN-y+ZCRE zMn=azKBU@-8AuY+dQ_6>=(~fHq(5f}<>oSkhA}N1Eh?mh%WdPl+{LwU`Ex(H(e>oy zpUbaj>8GAF4yfil-WPA07a%{NDp!|cEB+KaWb<|-3Tlq?tt_7t&(qzV4Etzy`9@m3 zRN}zZ5u>nIlZJ?$nil+{SJq)6h4HG@yGTc^a`l`SF5a-77?j-kD7QajiD-D@b{C0f%T!kb-quY)ecH*Gja%V` zlabbgUVeR(v+wpr9J=IBLC}oZw8|@#0E>{E)d~91HRqH9W&P$*_xs-}?k~Ik-s6=F z1CK~={Y%P9F>wRN@^aksjWvjWsPE?QGY>~&9zOgOC3mx$tNK9kn)=U1Til2B2E)hp z+`PK!s$*aIV($(;$_z7daQk!8(D4cV{iR6(tO8x<^s^X4w7SSqp`jN~ZESZ9UY7ec z_eta8vn!6oi`zURRYZ0m^o4B%-T9|gT@|nHtqzjC1pd;1ulxaSvYG8vAU(P7ZS4`b z;j@yQ*7A#XTNjBOE3w}%d(~#`uA{E}p4~~_O?!L7+i8mKbA>M}tEXF+WgL81veJH| zc>?avYVU=TCoU6rH5WB4KqhP%@04~(t_UCq#AZExjgKD#?qpnIU~@qkYbkwq^(2FE6H6UJRCsBv4!W@*0+R5$%1XRdS~^=2xx)*FN|qtDs2Tcik!e zpI=Pq|JX?AEnBISP19@qb=T%mQ)~FNmkPEz$=l?}oI+BsN#V-Vs-)gG$H+cnx7z~O z!GW1L?a<5Hm!x<^N=)FgF3~DWf23s^{Js=%@+&U(8(!!)m}-k^>ECbidC!Np3xNjK zCT-d#*JbLbU)xB)i;6e4XuVk})q5I%s$1T*+1JX{jrB~$4EhRgak;QZ%0l1Ytho>4 zMkR*7^0gZp&r)xL&2F&@AAXTc--u~E5kDdE?crx$u_M2${q1-?8!0E+ea^YvI`9l^ zFO*6CqQ(fU{m_5@>9L$|2~B5Qy(zVX7&-dKgX-+Bm=$Pm({|O_VcoQ891`^a6)}hm zzOEblX0`2`jA4sR%l3no_G7G%C=&uQJKFq8Bxi4Ci@*Zd^yb+nPfzw$>1m~0$fv`R z#A(sYlT%*$K;X9+s9N#a-@F|nx4ECs2$?1RMKa17>oIH;7k=?e#3Sa=<2h^10HEaX zyVqLOK4*`qET(|Jq6>`lhg<5;w7>a+gdR=oa$4wF z7$4cI19w`}FuDJk2kJokt?zpx^v=Y07hlD>?*^YWu?1|-NjJYk__PS@GY{0H@1ujh zPkhrqi+n%3Zb%bQt-bY`2g{^C`kZCnOfU1L&C68|o?qs?&$Hkq%6##b{^7@4EPzvM z9&9Bevg{5%u9l|VI~hs3283_WFF!*`9L)E(gfbOB-weR0yon?pS~|i zJ3m*(gT0B3Huwsl{uIa-mxo|_a?0_Qe?7$kWYGiwf*}Z2runSDP)zF~pgpF0!qhWX z#b)R3ygShP?AnauerigG;J88Q?@UEw_p_|7PI}jO?@l_i^5{4(pxM@Jgaezed+o@H zfiBAvzwhN)QaeVWnuOU%;*%mD?~p&saEN$yyVE;k;`W+O?d{IQbMSlQaORE5Luj+~ z@ar;ZS72`6<9S9HPsH9Gom>=p8_LZL2)xzWe6;ov>hoq0_uCqj`57a3mZ4o)3!fZU zbM=$am@GvU8n16%C1wFN6BhuQB%bd~@5hHYg^3NWv}!{OE?_L)dn_eW;aSJ-XZ?y- z0G&ZYsd2yZjGz27L9aK3=PFhLWZ!IBv|*R`httsuNEeYWX@-Ehof_gMLaCT--YR8NZpIyNjqXjUH-DWA2Eqc}FAkjCRhjI{&f`xpAR&x`@vF=*9!6PP-@ z(%0cOwSYB<+0&;;fEHnlOFnry8F{HKsFx}vrWmqu-YigrTB)(oJGY(4)u zXaBhbxNj>o)xP$^*V>{^k@J)7a<$I>?>4)!z|PEMIBseTwh~#%tHaGt(0`bAjO@gX zA6_JM6MgDfa;*uv*n0QVni8CCAAFny?_vA%%#H&+UStIu8IOkmqbe7>kfb=Ywlfh| zAFbFeYpXSP+VY#;V}3~3%$CafoB_Y@N#EA(U-J~1R@Q^x&P0jbO8ev=&t+DR>yzHaCU7lbg;mJ&H72n6gq zeUXLXimfv@IPuIwtTUtaDqR)ncDJcxzqCkjJTSmeQu`nJGghr5H$`axroi1g8M%WY z5nvW2el@BbQpd9l*>YOIyZwhYk4dO+#7yhv* z8;T|#XIW~$_V>|F0KMphX^=OMSG^8-xM*?Rwi zkbbMnzS-y5e=GCBh@KuYWr)H_#aM~g<4bz zOd?unM<>{hp?+O0ss$WKRcu@fh~vD}#%Oi>2U}pYuER7xKu$QT?px5imZw+3*uVb_ zOfLEg2(x;;FPB>EfEf-(?AGwQ`>{B{~k60l{9?1$W2PqSF8lKNr#OA~sW@7}tm<|&QFT*PcM(ZbUuZu;sMgDc zHqUHa{+R__<&-uDt7{mQfpY-&^kR^%F+r`gWFWW8hp6*1!Gl14M<9wfYj482_vSEsxm3c@o*JLfF z!T~YcN9>VqPVNu9?0U1KnmY-kMy9b zr$)4DbEf@vcY9y2P2>i<)x!K3OkWpHmyDV_`gI1NZ#+z|=|Lfm;JsUD!yPn!hFSvj zD)2WZZcVM7ra?waj<39S7=hb}y`R*YsoZ$Ex_S?_J)9Iz*L{U><&SLxQ&z)_a^djd z5jz7U$&zikZwL>F`Qot2h>Ti8pu-hZt=Y=gn+nLXYVNQjTStIopW~sDK}rU+cuN=X zJVXefKFp-_dtp@2LPcyqDVSjtlPqLKI=v|-oIpy1Wf-j;oF8(JEOMFjAv{QR1YU=LF7G-z}#-d zJ@=PHadi)MVc)puPf`WFo8hr3IbFayM&|oG4(wlP+%l2G+q{{HG?Gty0Z10JgG^O$z=6~@e{MN zd*|WR>8Xcnh*7NJ>q_bO5$-$-LJ14Isg_o!Dmc?`nxxq>apYmj&P)olow7582}sL3 zuKVvdV7LGB-(Oik1IN>9{d&E@-wsv<7jtLq;RHWt>Q+ytN&!c zj0`#1xT|>p;#_k9_^Pqa!F4C?TL%%gOhWowM(Azitn!aE5})OHNV4U5)+|B^T|p(7 z5Lpp7$M>QZ+KbNEPHF)sFvD~tlt7pz(;lwY*r4Vlvs0jhHFS^NwWN=vV<>d*U=V?+ zn7Ndgjq!X8vsNpzKDenTZQ9`-SZfLhZ2NUK=aK;NW^BcDzB8&k+O(?@&?dZkmH2?2 z--pG1rV%{1(V&OoJci&3iJpj!LtM4Tg|plRxCifoqK1AR1kU(O*&y>(6SwkGUWc6= zKi7;>0uq^bm>>Nk^IJxi{*@utHwa8n{vpU0HOtLTcMYO;F}o6hp0xkoPMc-^Rm%He zKktI39HH}wn^@kmr{@6g!e1{;YF;J?r*U@a;{tiI?udLA{I25TD_7<&)uUqUyKPQW zPUtfH!Q(&Lb{x>7tqj1r?PG^)pD^1N@7sF*ytc2?oMqmD%&!oCaa@>hkxrf8p}9wd z=fH%+EkDb%cX#O?JW(9u{=23PgI_+ePVwvQ9qXNs-Wkb{dUc(g z_i4)IKs$!-&f&8SgK?;WXBxGq*2;h0txY&X7btAj&NT)8%2=2yo8k>k*jIDmP6jZo zwS%K;yzd3HvKjNgIR-V>D@c&$!Iy0-JuD@ zeVl0f@;XA}{h$=Qo)Wvcsr37+KJ0zjuP=7Z4;H$)p12ij`RRZaA{5AY@fiJ$Zv&9O z^~L5IYIkeS!D$!q^osA&weSZ?yn_(&+j79^|89*VjFWMO;b4u%ch&B%z0+Yl{XTjx z@?p};KEmlw=>g0mmdqoju*_R=LX>tDZtfi&|E3qAU{(_!E0oZLR!Yy)lXw|6UkN5hYClf785-mNb}$6D^G;992vow@=s<_ zLhR67g>*Al{aVdI32mS^)BCBtkHP~{&M<99`lFkz=I1z|JfQnVjp=6ib1fmOIsK); zG7^Ke48s!5t^g;XFvG~@KpEsb#4h(7oLt=$GT`jC`g$Sx;~l~IkU_99Y{-^{$G=6LNzrYY*Vw#@(}mD{@)iOk#xa7r!$e^*1nLNcW08E;dM4TtThkIg?eD%N^#AW-l!r z#9_*ZlU7krK3^UphKBEC3BoKfPwrXlhMM_|e^}dTw5(A7ld$pg6=>!M`wv6Mw*Kshw@x8Af3ta zNR%P)KKNtq%v#;<9I=b^b+YT&^FK@0ct!RrW^&D3hVnaM&nu^{9+{hbi1q9pY<74m zFSc8H%yUIG`&&mx1~MVxLDONYoi?3E!d(YLwMnqRWC`OR$QNPDGcWq_4aMz8G10r(XAwH` zy!Cd->9&4HT~X*glN<%I3e)jm@TyyB^Tf+-MZY5c6sjmsYS{%SZa|sey>XPV7`*Q4 zt}KEGM*08X>m8so37&r8*tTukwzJvTwr$&XvaxM!tc`8kwsW)lfA9O<^PcbCbNc+I zx~sbSnV#->W~RHUIC~4vKIN(~KC+P1-xvZ+f0C$z)ht%yL+7z})Kq9ihysH78*@_I z;_h5gegL`mlbdEY%=s2QtilpAOck=@#4*!=P1?Dd&cX^~c*-#p%y8C3?}nldl9hJr z7?e3h7%N2>J*T{jlqb&>wy#|H zw%UyD&*O61Sxi~Lm)KTz6~V(;Rz3+<|Ds>IIvsMVe0p8fe#w8iu&i%b*I?Mi z#m)zv4ety{I;kCqTe>>2Gn3ss`QU>Ap9|W4hpd>%Zq8$ESh~{KxN#dcc9AuFd^k($ zsg|_?vjy*m2NoPEJpFn1D^?IF+`c;z>~Jl{I3T-q#_@jO7Yz4L=q3%|@R}3t9^s>i z;N+7PS45qVZHxL`Y)@;b=$|h=ZrCvCCT%xBN7J@#j6g?BGmFcM&ZuB&!D^24$rZfe zCsaaTt0xH*h&)PL-lLZb_t|jq`7P;Fr<^{h*>OVA9S{aLRHBXV09)~vhhx1I@kCX; z{Zdd`=M7dthaIC+qF47h>VNVYG30wVdjQFFx!>56Q-@M886)yMI!5sV?_CFPO;BrM z{jUU*0cg3Qxf^k5Y7=@={fatYjdOImbqMFSi?_s?a)*duMnMzS$)7!vp~7rSyPpOY zh`qN!mhsMnKp`LCsQI5p>Ym9YlM14M7e0tRx{UB^;LdgAB0ag1vZ9T0TJerCZ)aOl zonl=e>1L?81Q=(2ZZZ~YIgH3e_<7Tcm5~s{e%w;aqY@ML1MOf3sRNg&^|vY7n!!r9 zSV+8oh+OO;mi-|r#}6$vT!>lVEc_WOT7)N0{otm7J8>Lsh-m(Y$O132)R`tf(hyM_ zFLangMFNY5Kwce|(+_6?iYO}_Cqrbe(nqL=!dM}W_=ki3ZbxIc+dO?vR@Qr>uDr-W zE2p}DxCCC;J4fdM_~L4d{;M;1;y^$4nyU8YoWFeBz2w&jTIBgKGMXop&%sLdmy#U} zD)Pn|wODr3Mz4>7ntpBzOGlAD0`H1M4ib=cP4&;+@K>ph>6atdf|P#HOauh*tY3vult^%OiqjSi!TVcsYC$ zbswzlX*8)dU1gV7vB#MOt9k9X!kj;M8<3o)#fZx$2s3aB2V1O27>e$dMr0c~cJOt< z&eU)uBuS_D$M>*OpX4GqR9^#7LeJrlD2*>)?ic=p3lu4^9#lb!VboKYI2~ z)_iA1(B6PUptN$YyN;E@n2OgL*J98fMdM|HsK{Re&Q12`k*#_Aq8Mze_-4QD#pZ2S zL?t+GwLu(|jSDZA1nWSZMF$Y=yXd`S6mY&X@I{mPn zo3NomC;Zk1;SLZdgzK9wIaAwoKlT-GPpqR~ze0O|Lg380{Wj0VQQ&YeSk;BIv(+Nd={*lv7Bn2@nc=@xPSb? zZ}~J_JFvo(AeUs{wY#;0pf3Up*RMUQ0d&`Sy6L#wbKm&$RQ1+lNuU`rg9$gj$*TE8 zr~;7H>+E>BnN2^La7IWpz{wf3V|99s8@=KuD#L`@lz`MJV=|)t6YC_q<<+?*K}Kd& zO_@0odR5lH#&2PdRqNsf6i*9<6Cv=KEt7uv6mb99^SC1!u)NFe$Os`pQijdt-gbs*4?*>>`kj0jwyjFh))Rj(2K`)hbUkZJe zB8^u|Q0{>G&Io<3FgBqUDh`br8x5T+3@8R!1v>v#yp$1X#*z=N4F zHwt;_(`A&+PUzKd!v_9$g4G*9l-`~`noJJ5z8F9(SxPJ3!%t&x&ulNCf;eTr+<_$w zie>Fuqz-|Xu=E&DY)(CafpEzS5(IT1)NsE)gxGuQfSGXtxgxT9%S9D4a~p2-7a~=P ze1qW0>EU>pz&!+M`c9KTPEHm|523i7TdW?2e5zpr#HNB$!$A$n`*kI->gMD?@-IOq zqCNrso+&|l>MvBBKG4Wj@=;EidV60qqOpGfTEViM5oXBv>Sf*nK*^>Y?ey48;LIh( zW>rdFj)ySOZ`Mh*mfQ^ABodX)G-=pB$@!np@6wh5>*=uwc)}6wj+f@Xre66UO~ffa z;LE=>7cO4Abpk1S9Y4Onm%hdi(r0~F*?(1h9+iK!oqkqN>0bfcJg!c*;O)FJLZ)p z>ap1T=GhLeWRel_{ew^T0SxN}M;BY?<4FPLkr6I;L^Nz5i+~*ZvNkoVCiZdln?4;md`qVM=jJ9c&^*I$ZnyTe~! zs9)sCkt6cmr4d?WdUT~Ehs-kSacrXt^?j2Bz4_)zfL31hX$oOZG;hupz~A>zoX9{! z`)Mk;{pTDSU>gnjkCDK^;my$e-;AV3rY!kR`LHBxj$7=ls?Rv<(PWe$Q)GMbHeoPG z%h2|6^$z{^m@cT(PoQUfMCGHLTv$QLtW^D)DZ1g_?st?&-cjhl6&^tD7@L9O!=*$) zVIHbbC@OF)2izdk(vT;(dE%he!J?EN3VuKnFdj=eGVrY+ILe0r`qP4|78Y2Jrhw7-7!)o1W3 z0P)X)l&+B^YYsY%Y@2U$u-uDQ@*)ZVK=J0rwdC}%nBnFEwkiQs&yQ}<`i#{nR}i zqiJ2{eNi0_$^Y)w-vLO%NT+I?{4!oIc2*Z3%;ghU4RMe%<_4>0g6gfEG-7wJpaZ%U zeJtOx0i@;w-Lkkb%d?fafwd&g%V13g#qy(m;&#OgIbzI-`nvi8u}}tMp9L5aG(3-l z?h**mLYF`{iNX-1V!+5$Xo{Mqml-rg`zCdoajd69t=;(6ExSi3+uoXs(~(nhYsVmQ zpWz3y=o&WdphiGSHffvh;)$btfxf5PsZC@Ruge)s!lH`Z2Dc&kNg8#I9F_w7+kQ$oAUa1ES5x8~6feD0p<=wye zos_la@ZCkte+=hulB3v6e9bH?%cLSLASEH%C1z=T~1 zXoE6Fk<(o?6_G%T|1pZ2bR`RqD1q?(`VQ+g3IQWH%iqIoG`$iA!~E+&lC{D!NDoXh zT{H`|AuJ9le#r|7z6}ETF+ns&y+=%@T7CcIUH_>3_Gn3(&<294X_$KV(z4r8kvK6` zWX!ft>R9iGl1Zu^jli$ zknOfzsIP-qe3Zi@+%TnlN@}Xe{#&)k;PoHT8-6&)+G)LChnumTD&=_CnyM6Oa8)Y!y z`)C{bJ%Bacn5p;lKErJK=?UvMlGkF@Z(t@TR94Xg>U7i%(BP-*ve&Elj*16pyA1VE;Z3g4mduTo`jT8J;OMB8p-pCyCHx0dc~Y&I=bvZuSgQ-Iz`GrZIO9Oo-5J*!uT1}!qbM^7`CV%q!dXNrtu z^X_oqWOR@ug-@YGcwu1{jHl8gQOe$-@jwIY1%b^+pHXEa{oCtU#xkeFALn`1Gc5E> za+Z4E14h*q=db#(MH`m)qyW`^fk`)u-(h616yv z`M(6~eQcIhqm`0%fP5*dL3*h%;)EAug>he8&>4PL3_*@@2u67F)~SM*SF1`}9v?kk zVG}-bOwW~gE?7nk8Vk>U(2;s*fMSTbyw$z-+FhwD2)YR!FnHh+stf`f2%=mO>~=>z z6tG68vn~2FfbK_W*WHCx*R-3#npCO@&)c8qpQW=mxiXlxwI5453ozm_XQ}H45^k=9 zqk&rfF)jQ!|e3?sUSjmNmzY=0wbX7S~8VHZ*T)%Hmkop@HpR z-e9#j9ljr$4}mr+%9c6&={gKp-sC5Fe1+uQ(VNmj8gVX16aJb7H{YwhzoZ|0)IIVt zbB%?^aqTr*=|(%5si%_^B%h@Ur-r-7@B4uq#2`RYM{&t{OXGq{I=tjz@SEkssdKjC zFkceo94Shds|giwUVnli;_;;77b7>}3hDW6u}@}N^M`q1S+)|tAOJW1euCUu*?xEl z7kU`*n-!ft-9d?stSjOS9{%23lZOmxA-EjoOo|W1i~k9S(wu1W?j#0Fwzc3K*|iNl z%KS59uf#>c;bDd7_DvmNi1bpUqGQ~6w*8&l?Mo33|gw1b88 zq9ti-k73Hnd&;HAslm)gokZsenKH~_uWR-0wUD#)f^xi9KGBPk=xtfV{v5f<14=Z^ z0zq}R%(-~1qG?kEAxrPia=kKG*5$SSp;zs-;4)~1k#dc-ODXQ?Un2mhnR|SiOa;fp z+P(`NB6qvA@J+2Z1UEh)1jmIbuw2oUnlYrnG~D26Op~Uf^04;p>jHROx4Qj{RvD(= zQc3r1uY9M?b42)~=OXNB>(ynwTSm?a_->OWzexELf7-*2dzj!06w z0{v{Tnr)*Z8e=Dt&v$>SCMCryM*gp4qJa0GbeM-XwDvcdfc{r1=EfTu!u!TzZob_+ z#GKe?uYpi-KS8rf11Wgj;NuvL-#uOKyveNAc*Oj+ek-S7vcEAh?9b z5Q5@p(}(5RPtNZ8XOfDZuFoVz7Htg^EvYdOvYDFfQAGH_;p|rSc*I%a&OG@ti|n~9 z+c_6VeNtccve(Upx~Mn-9wcU2Akm4r_DC#p0Yj409FS0=KPbK_yI+u#%$%Byw)@MV z13zSetN9iU=h{*j(emGZ^v^ojt_;NH|JbC^-jAMz@ML@p!%c46ogl9OpKXSJ9h$6N zOn!B@YEE;=(#J~uPJ=FcEZ`x^WyRor>nD0-1CY1Ub*btciL6J^fzyp#1FwN6FZTZL zQs<24*^JH)wMUwEpq5&;JeAx4mPWF?0#r9chQho}V&9&sgKd{;fwj&|Jj^;A_LY}Y znIw6y9ND>?czIEsby-&JnR&a(vM*iJfbWhu>ZQpY53%`oDsfWy3o!Jm-AHuKGY8mg zMruq#bQV&fn2Mos-IKVd9lA=rcU8d-C%q6n3YPRw%b>}ul^Rxm&_!ZXBA*v6kJXCT zr5e`M(xYhp;_Vh4x^r4|1>c!;j_^3v0}Tb7)UHvc9UT;fxT`%fq_5Qs3=VYFOI%&e2ZyU|70L$24Dxj-IqHwl0~^fMvu;9u&iXiaLzd@D9FA2 z(r%I_bn_+*|24jzxI16W@?iA+N}TP;5FLUx7gpjIu~Oe@bdxv;EzN(2YOL;LLFpE% zNh*WVO~7Lo<)G01yvqrTi@`2RYoUC}ga7X4ro1Hu>ELYup2-K?OB%9WXnaw^&Kke#%w!{_-a>KteulY zGkWk{m3X>2`?-NxeM%u|gnE>om87vb2_vjQ^)B2V6VDf)dm8nm(dB#LOVG%_k?Qzm z8M@Z=uGX!EO8raEnbp*~Y>8mOIco61O_ldiV!<%>KK#?=hmX1ZOXOY3QHz9z2mi)d zEc~#duNCM6Rn`VmMSh@f%QH<~bvEjV2z8Kveo&d)^STv<3(+kH>CtzRP2)D>_(2 z+lHE^r6`Gh(w(j~n*6t=nZz}2xX)X3?5QzlgExd`t{Ym%+tip8D+{YlXhcict^W3D zYU2yH?2T!}K6391BlH*bBlEd-eh^A(6T2 zlg36Ex)OLYYT78!2~N`ALz$_uKS=!sMHRtqe2lEQ9z`a+b~2a=ks16bZuLH0Sm64O zl#Myb%c4ZY01^FK@)PO48SIL2IT5xIumzd~OZ|_v5B_=VnpzWo;6=A!=YmC`aWnU@ zCUx5gqFQebS-B9UB*vfk&RzLRwK7}YW#k5@Wp+%$2B(l9MOrjI8>p zglj!y@_IR0dcQFWu*eskou<7Tn%?P5(pUDs=)nz6d!GU@wh%`}O*QsH=^5V>Y?>a< zKDL;r9bM=E{Y-m~-k0W7O`drag`I-0%{@vYS0fuPq?1_h=dyKW`PssYoExFXEx5JM z?7gfdd7}F2jS<}0Yyg$$1d}`O(D9Ua0-e)J9d}=RWUmTSi%DBAm z8s_-@W^8>wKmT<5dY1uhk@MlRho{>6rmsd~r1^Ym-Q77mcA#4@0OP{Fkyh?9VUY|m}XwB=Xr{&;!%^1}ao z{mlNt8hu{s{(RQF`@B;eyY|j-2&9;v_BlZdR8!Z8!>Na1MkxeU3wZ{nnBXpyoZw%` z+<#%30M1Gy*FxX9W#Z2d*5ycG45X3S82z=TM?zX)K9Btzw$cS9h7 zM*PO!-sgW4XQd&JFduR`F19fTZ6Bd7o4<&Bs}tMkkQ8jW6vvysr~@>hM9BmXLv43< zjD*<;xj@5q`dyVkF+brFnL%M<4%^O~st>p^WW5ZyVU&jUn&?ufa_q7KAT@o_m@}_J z!S=Ne{m-y5Q#xj!4FR-fm-zTgohluL0a_MtH-G0%ci@iN_Deujq{ele3(CUUjyP;wOWZu2<;R7SUK|^y?4w zAMO&h*(n!SpPQGpR&HCD^H!}bp3{b3Um7rh#&3y&{Dz7DIYb&)V65HC?Z*8!K1-wy znXCH{gN`6X<5XcxiMe3c_yNL^J$KxzV?zdE8$~*%a6(wu!-*oh6l#5HyrIx|Qhw11?g{gJoma zgixA<3v~Kiu4W^UiP^0LL>6gZX|ZXV4_ZvYhWnQPU5K9oTfw875-tDpRg)>e>TEPiSl>O{RBUnvOS=nUmDt8glA(;A)l>8s$lFdr(=#u`*_d{1V zZ&a@I>smiVd*OeRP$#zV#1#MXYP8swwEw8@_89_%{!0FbJ$p$4Px*174}yAP+Y3Q8 zyA^<_RM-tlTq@xUE%qb+6D=y2=z|tRkdy{nrLE9-FEQzF(f<{A{x($fU7zB=p;YRx zrtI_Yp{e|;$q-O}-vV)Nl>CY2pIte-MRZO3EfCq$lKXEyR2cU=Yy_H|byKb<{=Iaa zYJaDM#mY79@g_X)qIQqB2Adajdw>0o=Cn2q_GZg(i{{JCQ3e{1^BNngdaI9?T&D4q zsxLI9kcE2Xs0$Br`{B9zhY@A46I)o?QkdB-ER7$Sh25-;xlB^NmS%#+NuP_;0izTj zRe7Mv_Dxpa+sXDVR&EIe_urmmzOO?Qy^h~EIS3v1xyWaf_)nPRpRjrJ_f(X8)f9%N zO1y6gK~p08*M!XMmd1fv9ruXvxBhN7!0&9o+~j}bndXo5Z>@{pzti@6m_B@4xqaJ5 zGc^+|+ERp%EytU66D}1G$%(wdl9FhLJzz_*vAPg1+74F{m?8@U=Qk0G`h_Fb`3T#9 za%QF>oc*O)H5<0ZG?x`yW3KfK^NZKW#hOX~;cDU5=LhN8 zm*K1}dS)Nlhf9N_^{g#B_Y&F1;tC4eNz11_$-g|^hszy_>q(1l*FN3H<00tztgWq1 z&o}uNFZ+6N*m*H)>&q7-@_O-MZ~M(M;V#_Tw1Nt~Uz-SVmFRwm{ZqJg8Jn8q^R@$u zGiy7N&QrLR!0ay3O-ktU7gWBp{mTD9hYg!cb;XJ;%P8JQ+NW6bl@_v&=p!Xa?K>+} z`M-s?)?SPob~fcsT1W=|2TYDllIZ??rEP2bX2^{1Q+}j`r*{-?F#*;|ztSQj{8q_? z?RUOl!wxy4;#zB%)=ixZNvveU=9{ZnvGQAHRry%n13FEe01I2N&4fj$sF(=3s=DM_ zyW6x-zc-xH<+f%MsQlJ}P%&WwJa9Vww=>nO*sQAKe4v|i|F2-ihK;7bSK8%(jC;*m&?bxT^ZG}zp0wyepU&F$qRkimt8{Z~l%w{R$RB18d?{<|&C!Ywk@={TQEEkWT|YX?x+ zla>)wmjAENaM^0g(=zgYZ2-#Rf1vJvhFxkMWY2d1QPl`7kQT5ahxo(ZH`|29r40a} zPF9JfEjEPt?>iVxjHK_F!S{p!0&$k~g+`bs{h$^2@y!4b)NYvwQLHv^ z*ddjE)zqP*{Gbg5mGB+Y|0nzq_lZVO`hEKZ5d7+%HW9WJe$@=iCH$Zjnf~`IaGq^# zyCw$nN0&V(;J9|t24@MrJ}cC@^q?A{wi>y9Us)fd-b-$>jzm5Ic|f@9&8;MnMhZ?! z&y!hCKu=^BSN3N|&W*1yY})HZ1d&A12jo`_sR#cp>L zLE&PbJBol1nU6yS5ZLtBi2?{LriV;%L>8ykws;jhpWQ<->XCU{Jkhwp|0g;RO+@ps zNB-4J@PA+~;=fi309(i<$~}GBb%jL%wa>Z+;%7xaifPj&|ek=tkk?OlQAZ9Ee>>uoJ~eWA0-|Akg34@;#qbaj>hF z!M%VFPGyn|TVEHrhNt>!$(Ni?gs4qAVS^CKa=+j>@oS`!ZXR4cXFg?)I^?)heXd7P z^o*f+xphkJa)#(``ebvPk5nJKbZMps8jtYKkIt%??@m>7ITxF2Jmera>ELmCjl+gH zZFdz+=3k1jBI|UXoV*Ah7 zx^C+l8^9iMs60ThRu)Nlx^Zoj{Htpc1(Lt)NZC+Iy66e;SUxBUMSu00`5tOAX<$kc zxS}sJbg>z zl9$!})=Br8Z(HD5#T0o-G2VYIS7*!G27X%;zbV#Z%Y2MV@ef#Ml$)nk<*#AZv0cPb zgd^44eEBpZ=N2vDs+hMS#3f+7)#*C!=CpSUY2#NkvVX9;d-!OPjw!dxB%}^tLx8@g z`779XTVuq%P&$c91saHebJ;uigL!V^Ee4iGKIHdeJ%ns5inPR0ztaS97qg300hMoj zN{oez`(b@)kByQ&L3kRWApjP6%z5^f=*bCB>5$m`VLTD5rRstc!`IA=KQ-Hru z2p^h;zgQa!6re6vpLvjW_#$a@@@5ZuX-Q{G!c0CYft2^&{rk!2>Au||1figK8G=cF=y%os=%{|^T^e!&vXtV#}RLWjF+vGO#JiTpYgdiBV2$0LSwS3 zRar2Y3SbknMc#~94uE(rLKrw`x9g)EqlFAjBSX9aa$mjU9}@0{iJR6o-9z8*40_j! zSf30%9-l$}yJ7Utjp-+?DbwpI9J^31-_LFzYuK-Q0bW?J#!2I>rbSpq?04~i#mYg% zrWHFla#ZEPGEA<>e5>uR*$9tFzB+2(azjon(R^D2Jp;4dfdNX~dSU>!=?oEJx2(YW zhH9aLn}JHpFt;WRHcuXk zmV&J>p?RRKN(E}TgHd5UW}3~;%n7oR+2SU~Vm^QvTY@*tO6o_^67$>wrvK>+-VdKu ziG(NHdz8**WMLQ#;AUj*kqiL2<=!E1H?nk+62t_6K_LTDeeT3`?~LE7t>|g!zspZ; zya@m&NiyFye(^HL%$Ju}UshL7T}B0IFUhiQ$o_WMF$Hefv~65-J%LK{FX{CH!b$jZ zg3OmCBng0r2JJd)H*=>K!$z71pmrL{jpz^h3HX(wSKpi@iOB4Qo0$b_91j|##_I=? z_-0N9o=pbtLc#FjNb?h?0J2x%M>8#W2i(}VN1mKns-7e?F|1`)JJokG{zgfAo?~%L zw0fqjIk*xSG`mR8j-EtrI{Dk}$((jEj0Y4Hly1xr8^G9gzg2QJR#;0uSVo?wL=*6w zX~m9am_#I*##BjBiWqFQH12|NWGCvac&1kMG+UsP&z85GFVr`BJPXnf&*d)-=P$k9 zPgUyB1<$uHULP0y2D7H#b97-^jB+E0-@~8J$iG-887k9?)mgrh`*K`?+|=0Ppdc40 zK#Bn^%2bb1>uiJ>rkM@pGl@tB54*UbYy`4#>f|r8POyTGOiHh1WN`g2SBlP=OWB}U z^Q-t8tK(x8oCUhgVsMdaW1 z2vPOZKOuUGOpt+lb)&PbjWRmhedJ;2HyioxRTl!x1=VQr!SN%`<0vyf15FEyd%P8p z_3ve|vPqH5i_;8iA?$3%n+ZSm9=0GlG=&lEYss9nxbA~%!yABMVAXuirPevL~7AWdyrgviJpij1^qOyJk`3*Xod8imR)1Ge6R zeR`_tgA2Q;8H2yS#Ql1@R%{xFWA);rX*flGhiwIa3+fWTHg?GshIY}iZPb&7m*qZh z4%o0Ep4!C!g2ef{+1h-L{kmlxxn#>HT`p%x8;{GJ@z)z(PvxP#@}Wl2l+WPTOXPY_B`$n zutrH4V;no6^yS7{arEtTs4WoSyeY23e5L`1LB}}4IKfB}*0skGK&`-sNGL%@Jm*~V z(cP3|N+pGXkM7u~F6`mfrjQu|G(a7Vd+v8QK!YUYUIc#(OSYAl5B~{qyNNg_YJOBX zK?(L^rlNPikO@2O>n@j4Lxn`{{&^o$O{jCeB#yk zY`7T!I&u;Iw1upgie^gG0XrsDcyK<>0QlSC(}dd8w%O&fzW&ZBX@7I;3+b!-R{Q;{ zQ{zI9{@@EAXY=iAYw4?o=J{*P>yyIu;iB^s#v^J0*3N25>UsiRX3gcQAn@&Y`^(L# zc6Jcm$5p6H@H)($>erJTcBO`=hCVx9@iq?44!sQ$C#>w)lJ!K!=$t_oEl(lCB2QrI zA!GUp2-;*`#Z=vOEHwy`Xeh6iJQ>8y{T<~`M$fcMrNR0T%%kQ zHL{|Yg8l-z-LEIZj>=QTc9#Ke69z2nsK~>q3qQC--b2F{pwZIX_NwE+==ky}nknWQ zeWG}T19IX8?g%CdtVm6YFU_bBFo za=+4>zqh;P_QXyHnJdsrP~ZpFupR>=tYV|@qHX)VqASB?D2%oADiq1k$@%R4vtG$-=(}2SFp)dWyVI}s=<{|j}OX70@Tp&-x zX8a1KNMlJoY#=UBG;+i~MhpXR_-@Og+j>mT<`#a!YCfK_hHft2MY zN{Ds!vTnO6OFaZm!LqvnQnYp-5lFIk$Vk^m%t}>!{MEvvC`)lksv>ETbT;Zfzhvss z;&&Eu%Ean1;s%nm%H$2t zJiy)v0Aj#HY1*y=KQwM$YCUSaJc|M)XhpFmhPD@fszF`h2)nwK#NqBg(J2`g0xcwae;pcw3%dL%U!ot}jryt2E&~^aYV$ zre-AdmOPT*yOiu`DNzML&Ua{<+e^+{wlH{8LHiKKZ&9z2`*t*lQSe{!bmy|It#)y0 z(Pv=kMgyUwat?|>dWE%)?8PXyo&+}S!sJKpV5Z0ziSqL95KFSUnb2cjn*CxRy*fhS zy%qt3w9ZjJ4{)!agx&{~=wT9-Y(gjOIle9NJ|x?h~`oM z5?>88?MqbD+#W|U00!oU;g3a20{4ZTYeZ`c=m=Fq7nY4ta*yNvTsU4-L&cSRH`7-& zkcvd#4TeRE4@FHM-mSFe>$1o08}e_H)~HGg#MDiCR+jI$PfY7FY;L$yurZMN4V`^^ z13VICBx_0!ki+W%!Z0O}OBFf;7QH6&A?y`Ow;`ub?$p5(gNI(np`6bhxz?GhEwUqpkB&Ky=W26>(1`0 zFpAyr%xxlcqMC&cBoa3Hgl-2N$q`LaRO&cRsI$2F@VR#q3r>AUum6vyp_AeTIMvOo z?2CgnT3~YH+-n;Uf1LjOxE(S797+G2@ZZR<1Jc8cbow$qrmje*eEiUxujb6f|5EzimiWvKKgRk78;cl> zjL1BY+x|JqM#sL4xRw?uoFv`q^diwexRGrdnUCfeE~Kte^#=`inZ``2`xd9LSYD<; zVC1rUidKn`Nba5?QoB3jNVBAqM(kW@TGxNOfdn1F$k*~XnNG3R)$>q%OB+pXX85uNazeCc*Z>cn5OOq+*GDmQH1^7;H65`ZP@_Bx-T6-wd+|$?X|{kfIC88%2oM=g>K;jXm-XzE!?`~06n>mSrl8j z32(a$xM~?Mr-s&Zz9d(C$6k)sz5+iSjOjbRAd7R(zkDt>KffKJ}3g{wUt^1icgm zNan^T(y$5ems*>Vp7j{|({{{_Q^Rs7pbr!B2fW7rRD^+dWDnFRCMdP;$Jv&adn(kK zC!f5vrOz%I%1Ze)(LDbGFvT{)@#ulIpDBNSg|_g$sErUjpjqWD;-UwHU(OCO#i(RA z>yN2Z{zj(#qs@wrC#o;y&QW~&)4-+e!E8JJYms#AX#G4^H?q{9JV&nbbf?kyr!^WN zgmRM-xyR0ca5TSzc4AMi4y(%k=nYun$Yqw7+W-g@gpc!WEw8@5JAO628dfaXx=y)D zb=w|X2d>)o3N3(d==cOO?S}+>7MrY<^DAUN2x>D>uiaLbHtZ((>mr1re42yV;goM3 zH_?Ns3tZfN=5C&p*7Ss&^JZDFN{Q zr1PlS_iW*pV1dXQyA!PpMjMc3gFQ;I27pK7&;=X?X3e5NM(24{WA4hKi3MtQsA8uL zQ@YjXh_fgYqrFN7XA%p;YH?`YewW=Cqb5h-Dh=E;J_A{6T7eM)b&ef00QaRUl;Mhn z5|gwj@N`+^g%2bppfSu&gN|RY;FRi|IbqWyo3dyWyAhC_D_hpiSd?HItl+9D3*o#| z+{WOKzSuCgMt{WbKw&HbALe*Ajze2Sn;*%}6=3JG1h6g`M$QuL$EgZMJ#9Nat3B`K za-(`j7vJ324sfWRk>z-+{=V2gf)h_=eyDh=xUiN*Nppocasp_415Ae zFZvnEeXq^XWZ7=M~ZP6iezau;i|hSd`WDW_9s zDFvP|)*3V?B`+~Vxxx4x%(87oD}>T7q1e%taU3#;jk8~+pl0UyS5C98c0lC3m3HG~ zX4Re8?}e#5J|cR88kw4)OmN;;^OmU}97U~5-%I!Pv5e{&5Z}v$qj`s&5-(It8eAt5P1%Rd2VpRYL@y*3_Za654&k z=hrGRzw+U4D91%Tnl`#vOOuV_s$-$wAU3J z0le-mfSz&3>{t>wY3Gsr$m55ULy^A>i_r3<@>M@sz2X6er_m&2zr4X`jU_#xMFUt;wW;>zaqLXK&U5=N;JF=jXE0 z>xy1I^O<#;=j6DYaF&A}8ka`&wz=^roSFuH{l_(~_M79HSVEU>bT?3iVU>`s2&a$H zRjD#91yX`pJVB&irP~D!Nn%n}GznFH(lYju@0QPafhT|zT@8Daa%vK>obQLM;q)Dz z9#}RcAqIdu58gBpKy|u6XtU#TiI%hlYR}Oy26M>|xV(OYpiYz#vhmWhTO|5AFmxr_ z$;gWA0$`vRxCFBj-Tja5;(`qaEg6rGjSZwF#RM!h2ghSFZoTR)*pr_HhVQIZ4v2}B z1(!aiNV71dZXcDU(-6|ROaz-31`t>sJEf^idLTU)cS}LSV3fM|cU|f}ja>eKmONyG zZZi6|gF%23gk^?SA{{@4QxsjE#6N6KF~I;n#(1$jaN;MSAlW935PTJ|o?ekt7(s^h z{2tN>;E+sGk6~;?rw`~uLq&6l(-?9?`)}lOR&ZqUQ4&-VR5^{}#tBmtIY4d+H!=(N z>7o31&Ye!cDD?JwOXnIYa-alw8xuZ0W?I*;o^t05B8EuLL{06|ERY0yM#PpWq`0AO zU~Gkfa`FAwT)+#6&53(R#@1#K?8p+Wlx{y95E!sHkwo%HR-3xkjJGbFa|%HCQP2ig zr3>u`Cqn>bBWGH-rB@m9Kx6cKj}qf)h?}6c`LCi&A$|bt>vy$q7m8%&_K%8h@gQ?V zJBP;XNb=eoo2CjjRd?*SwjuNsn8r{z=?jp~*^N1Sjh8Rh@H21XyabwL#U+Po3OETEsci={=QN23N&%bl zUWSq^m0T8xPNlRGtE@Yg7LELZGnG2xz6fb|U;(1ZR{{4Q)Un6TyReaGd#2p++Q6soNVe1UO3{ z3A6{CETF*Yizj-7VBEeDDzUmAX(=&Sd{pi^wg{7xq>;eMo2NQ?tL_jA^}W`1Q!S5% zgo9mLE_EI_F1!hc`waDyeGJ28tg$OXxmH#Iot9NAaVZ!gj0Hz-3Pl1aX-$lZJ}R*{ zYh3VS>DFFvxfqY(tZFCsNG@wXCvyfhoE{8lL1yC^Cyh}FE?$)9Z=vr{WpcCGF_a5}p=c$1v@$hz(_LHu$hZCaJ zS~aKwl1{M$eUn;>KSY5|R7@EvG#V#_Kw;dvES7ozmz1}usM4#C!Q&2Fp?(0;PDS-+ z>)G-4!4dS^7nstkN8@l>4lqy^>{3ysS%_$f@+!uJ2#+`HL$H6lR*$x!&fR%v$amwE zyPNe~5e_kY(;`>%O1ikg58H)AVwK?^Ma^F-d+d+4jou$h`1z>8*bGfDRrZrb_>@G$ z+!(|}-RGXzxByqOJElW?!A+bvg>Z-qiov7O!@Q=RsadMTFxweex^6f&m`EU`N;aqU7+fOGAdsA`l(4t(j~X`nhh0+uOt@5W zUw2~eD(ni$74riQT0fo=sTmmUXXP?_*YVquRDndeq1aGdn^PH#X#)<5??DAiuF%ar zs&jpjPN4U0R6ITom7Uboe7=8RgD*B^MstDofo_hG7m^_I3EMLOf@`9iCR2Fc^hr8G z;>Yu+lPKLxgaIn<%!(59HWCoV+_Bg$O+kwq=U^-OCv_c($0R)Sue~`KpJRV{j`0E_ zvyamr42A-|`2YkGtHwJXb__7c1^{W$Mm|om{M48#G5v8S&_5uE*s&NGu>zw~ zG0@!vJA1eozSFpzy*q=2JTxv}suZw5Q9>KqgqJmOu4>PoH2d0UpL}@~7ez2B_W^Y8 zF7V`uNfp0SC731asP0NN!z6>I0U=1 zKpvhav){-VBo#-$U}y({urVIh7M-7Ko6B*yQ7Ue<-6}fS?O_XiG)+*08$}vC>oNOq zX(c?aGw~hgA;ML7DkXpfcAqsc#&^#D$Z86nPlYJUO;_UbdgYdYTb^>Z(gi66;aQ6fK8 z6bBqoLJW9zjhd6Z-%2MLDingphnpmj&J7;7`5@D0AW<}VNLIyiU(N*wGlh`bY6N?J@%9*0;Ph{l#c;}swB|v| znJRAzzVodP)nAY?+V9GIe~u`W#b5u?+u9lR*|<1a3Yg%C)gXlpmw}1U_6QcL0srbg zmGjnxBFMu1oA$e3`{mqIB?E#U)SuX)^2r4*CAI@R_U|$!&fs`H9j2U2n%80F2-aQQ#XA&teI)`O`SxPGK)Lio2ch(_RzUMC=&`Tud%UI&yQCfr7~Af z+wcz7c}*;wlN_tBhlu(y(3G-~@M_fQM@GCvA@^y*UX|~bJrQ0^`kx$G*&99q8%)Qx zMq;65f)3lt)X+fj58KfFmJs;U{kN0(WiUVJOb)f$#>4r71z*jJ zfRGydqx9{kjw=>wtZM1VhwdGmj5K`1mB^v!zG#S!;3*K^oQaKo?O2}|qN{MH>z9N%^plM`ezcsfI;k5s zf`IGe{Y~~!&_uDTHtDXQjD_GpinK8A3K&g_@abmGnPT1AW<9Yw(fR3rO>!;{T1zfVi1+n zTzC5e7#f`td^x_6zhd2Y=`vWTUyChjrC=!phs;6yrO)-2 zcb7`@c|L5(fq*LePq#L@DQ0uUOJ;9C1f(uhnrh@u_09?PTByJKF1pt4)l{coB=7EM zY-kwlaOVkI15TfGn7wzmJ?s(DKYF1pe%75N)l2BRkcI~(JvJalcBW-tx7EvO->cC$ z?(N=4;@{f7gN*;%;})ULi#QAILD0JEh&|oEjfssm2Z7ml)ZVX|6Hw+#*3*hyJ#vd^ zGV@kmj-X5DG}xvK*NEEndbhw< zFEK$P1`?&4Wb+!^t<=>S)+siAW1@&_CksxU`i~jw6Ds?CkF*OK@43JkmpW;=qll|y zmbZu6;uf3^=paorKr_{%x|Qf0GFW3OR+sJU&*q^ZMhNbUiD!35AwmR5D|qUiMxlQd z3)kTmD`bmF?a&I^tVz|-B*AY2Fgtt9)nos8tY%Iu!Oo-tLo1s0YUYsq?n5e8OjS#A zo#}&E2A@O&@Ak7O7R=1di;>)%9&)ZtU`f3?{RRsB?nLCzkzoODaaSj&Ch9 zwx`B2mzg6HrV$h-HXfx;PA`czNio>I ze?WI`LakK}DD}F^wsTsWH!u$MtlHbUbEfl=-X1()4vyZCIg^aGd@?*g91t7hvt?fJ z@tp3z4w0%HC|k50%x22g5`zNPo;RxMwJl{k>>^?ae0$$M(4JozgqkuhG8oeanYd~#?o@}*Yr+bA+z0&9aOb+}V@@-tO)Imjb9zD#kM-)Qsw+M6lO|A zT+l#gKZr-^~(XLZy>-NKGTW}hP=GAS}Q%@Cc%sRam>^3dwCV8*^4@ZOQs(bm}T z)IC<_;tR^oEL_x57eh9@G5;+}hhcg11ZR+~@ns=ejl`QaiM#iKPZ)o}+}pl)iOLBh z{FF=#zCcz>W?eGvgvT4Bts97~_%)a&4-m9TUO5GmD3+RnU{{dR!xHK+QOz0W_l7hvsZ7J5}T$-#*W z?LFG%wIgmH-qrF6p^9?0`T1&pVKSAscr@?H^ z>~;RRe|9W5Y4TuW#?-=txXB`e?+q5F)%fP&_yFHXBL<>1Z-lC2{q}TR*=y|sKXtRB zTRR~ZX-WRlI#REeSY#shcT{&))vcXR26y26-{|C9oQB_;%Y@SRS_>6&!7`^Lx@}AO zKIV)7j3#l^HY(WdYez@>LA696^FY91mj3<)wBFB}XCji#hDVEk{(yH7%T39(>#kHZ zcDLc?WWnwI+JGU_7I5-@@^VKvi(uVu*_pY}O194JfU&5y5IA)!so&4ZVZT6i`><4G z!AFeVc(zW5>(lszwV5fII?*aC7Jn(|9V;)LmA_lcyvL|YMXMmFs>)P8w2m#kGgZoK zm8I1Nt^?X+7%2+#AxgMw=UbA+j$CUU>|zCsz5zDptK*-rxQ_**6Zyv?->?o)Lp7pRV z-(i)Y_9*k|iKClkw*Q7>0`9@EYrKw~{toUT0c9>U`OfkD;UfAL?2ij3j&$tE%Ki!N zOdWhjy6$wIcd_D@w$nT7$JHOOKdgj{O>5Y)H-~|MR4=!$p|Q|ckMD!4wdS|ukFmc# z$e&sJx-)NTyDZQ2O1u(CsIpiMY2v0;C2RIujaV6Y5mrK$v;*t)Gn`etHYwMt1Y3Ng z+_1^=UYG~tQ1)6BXp7rr_9{Vi!2Fax90x&jbjTE5C&f4iy8Y65ICGh_YP_;&CF=@# zIKuqVDG)mR5EV~$sxTT5{&pHgMbx8B3Qb&0VwpBy2ejPbJACe-4Ek68S_N@??rDG zC@LLli}V<14!mXh1#oBQ#D(%cmH+tJ6~c~y{;44Z7W6jIjwWEI>~=zVN{f%2x&1&#&cX^fq_Rn$!|v?9_>?@n z!SvECj*FbRwq=)neVFe00KPMQe{p=(`T|~daJ@fX$9Vs*p-a9p@)5XO*mgeA$z;U^^&wHN;4v7&c*^5* zYUX;{qq}cK>{YkY!+8h)o2^iN{Y1<|xi)`Ez{fVvVvOdu$2u0b)sEMx_*mE73u#%bP=n%*|#Qn?UBXp$lcB)mW^0vii%rJ6Cr zpNd_PFvauOBifWe|9tigYZYszFwD$B7aCZzyl!pCcJB+Qa^r#QZ52Hrp2v4w_b{Wd zHe=4)o1LimM+FXph52g0?X`=SoBik!StD>rE)fU*J?kj$PPiJPkKw2jh!&&9Y-!-% zvD#jw$HBRo8E?GC-`|jSv`$@M8KVE^`|S=|cRNB(2{u9)DFbX3tO=%R_xl%(mylKk zY*5=Xv-O{S>zf`P%xXBf#F75K{#kiR6(a(5#Jt&(ShGXmB7q9>TcXqia`ZL6Ax*Cq zYOuG;n;4Wc72rJkkn-8LN0U|V3-2y=u?qNYhJ? zOX@ejveiFQLO`$;O+f9QH8<0ktz~zSh9u2Yg1ZuLHiwATDxG%hM1Cws4TN)rlQ3On zSSz4H$8BhJAU|kn6LF03jBvXF``AiWNpl$~#oa5++V&`Acs` znQ9G4WqGEog+HVPr_M65Q;h^4+@0!VjETpy*jaaV1EW>S5s2q1^0nhjC5tLWd}CVh zS8kXFrn1^-AU#G+5vS&jU{JB9+jA6n%4S+P*}`nD{fo*Br+~v}m}lUX1?~K3!nhgU z;P!1C17GdM!qB4v9aHZN;uI%iRBC$;;SG8*a}Rc$=MRB80R}Zu(WIWq?X%DWpV~%Z z70ctU{j_FE)!bM)XBRh!Xc3nx8>Ts7b@g?5ajP#C4VH&3(F~AN@cFH0{Xt)C0PoyA zApgm?d%JA98t_B|_+Y99I8ONHNY#GYG8gK_TQxyGv{zC4P}9$>bbAZkqWve(3loPB z9f$D8$Mxs9pFzkEA+Rad-ykci&kFLAiVxIpiT-;JNW*zIUIJ{s^CrxOs!2IwQ}Q0> zd8N6IzIl-a^f?8t8o1n9LK;MvWpF|y4i2~p2l~8~l#~*kn6O+B6j&>rK~B8^QJ~lm zlYBu>9^x7tOF+3?Zr*e7lvbc4{I*PS_SQbe_3>^_UM|2nT+TC2tv^JCTg+(U4)obf zG=4RP(8J6?+#KXj+HMV0gP~kPAdtj3FpdL|L7ww9z9|S8Xgk>8hiBnm5_EmWnr)zj z-)Y&PZbEvG+;%2vS^pqnEc*G!#D&-k+CcxL+`>)LUnlHZ0K4zm@1gJlWmuRvUVW)i7N+~M7*@MuklyoMabk3 zwm@jq%tND#e4=E})DmA#{!;=wP+&W0j^5a9@4!+qpvK^(TA4yYjD~jJpDTJBwWohq zO?L2aD`k&wu*(?JZS}d+S5#xNk2`3-W?b7Lt?q(qp0ZhEwKOu>Mrc?E8HHz(H!F`F{DypyWTdKQH^pxz(WI-WlU}#AD>Mf;AAO z3W3p#zdsZ^bZ_~l!QVEx^K8`u)6pLf_5-4CNB@?7j6@}dE*e@Yl>I6cB%J1^MnGp# z3ye@Q*~d50&pL+2c+fL;YwIy%1_te_evTwLiN~UCCGWDtfC{M2CmoSxH=iSa|L>c- z)Sj}%8bQIEcd#DYk+vX{*{Z=>se=`7CZ>`>ZZek|D@T|>A!K8O0=`b@ELzsM{_{Z~ zLE!=Gah@xe#|O{D@v^OnA9^^;i{B2)562&8DOcIMlZoL#B9?+a!Kz^vHg`Qe-Scwn zJ>@AlO{u<2Ko$9=z?z7szd@d`lSLe!+ak^_qVKsDhsVAA_yAMl4JsYRNYvxOnBp15 zuL>MnxSvy6w72YCIxsblP1Z`w63_vr$IsYX{?^b7`RATHs5Sw$3Y5VyM5*k2s_I=I zS^^yyl;3;oI*!q^#N)IhO~X9{C^_WUGSbq9KIXv82+hvmCdCj2aSpMyiNx36Vf17Hz`j1H_<7n$3vi0%|_5RQ!O^tDy$|5d7E{ zp`4&VT0~^dYy6vGdkgca3I0kEdlnVZGVIh1MlI7tl6P82ahtd6{}_QYhD-h-5Dj(F z$TQ{%uDAPjq?5&Klb9zkcb*4=t{QiQx`wh4w~Y6OH# z>0!AKt4e9uhk6m!G}Z+_vWu()zQTlUUr;y`X1hG-o(%;@k?>kMI^&0?$0HWlBPmW- z75F^wT_*Cm%l{JT zY=rCU%HXGSIF`=_@w?Sm=ra#z$RPO_JEk)>_WQKnO_`Cn9!&2w)UDnxaXvm~fOLv! z5ZZirmt(Rq8Y#MrSNqbM_t*eYb&jnH3L|#@tfn41x3eX&#eByJ9c$S#=xwE>41)PZ zJpyw0&s#Q4lyY0-w5_MclQdIRGosMDDIlbAh% zb?ldO@N{*@eGTP_mw>J%Z^H1EUG)yfOw(g=Bq11nUOnF7P@w8=QX_T@UiCfF;xD}~ ziV=WwPfOQVWa%GF-CiH>&R5-OM8HpoSvRYD^p#;-hSKz*&nJNEur~90YDQILfy?Lo zZKo~SmjIBNhP?y$T4AEd^>H|F?Dckfewe!IRRCWseByr!6wn+~q99AA%)Ai2xVUI> z_wN0aO$Ow_p=00<#^3V@{#M*FWcQ-oN*DUhuTaz8jr>o%He)Y#jSDsJtvu*Rk2L7OH#<>e3>`IdS4g) z-IlMBSZe4f2F7N3;{1H#PqdbG^>YMzmECizga0Hk)TM6h6M_t?2{!E#%~^OaKDf6YE{19j|L*~0PPEx zY(B3gjITm>;7@0pQhml$Cn0!8Yv4W!CO+3>Jv!JZL~icux_5##I~+`v4cE*^Qajay z;hWt4os(!(_DLl6Osc3be~mLvu0-_$?{0_3ny^0(_l37hk+2Md-^je>y%{)}+!MbF-`MwM zoCIb&>@fV?b2)UB23c-yZ7LyW};QNxX6ix2+X!ax7@xxdhKl;JLin$eb% z2j8wRlTf^t^DPM`;#qgvc`+`ToWtC|2EIO;t^KvgVWC9;q>y-OeBz8p|2Kg0oy}e= z*rw&Kz0~GFCxlGoP6(wA_?F;T5d=*u|3J2M^%6~UZw#pj7NZFi!B%c+hQ4P0fKC8dl~08t4i3TIdW6TQLUkPh^bkGVic%Q!A?n zqDoUBik1+we3q=szy(q8t0~iWX2ApQFj67Q8UqyY_q;w*;Uy~X!D4T!OMfpI?h-NM z#>HLlE&509zz%91Bb+XClNnu?GsZXWt8P-8Dq5w#3SLewsfL7;vXca_ug|9GcWlUqJWQfH^1kM&;wyS-V<+9 zyKNzOZ5Z9Cl-AtBFvaQ)U+%+Wu9%c}KNS0s8|#aE8>)?F}K zZ@;H}*p8>5hM#R1F)Aug<{-+IO7A(!Y)biueO^a!2Wt{=%x6ySL<^Do=kC{44H(6f zWV&v$2NFDmv65^bH;{!E0P^z%zdYK_m#R?}@d9%1QKiZJ%4BCC!S$NN+ID|iC-%Ab z5=Sx$OP!(94BpUM1=t)O8`T*`K8ybBt~EOyl8P(Ge);kfT~<%t1m$UUhAF$gv)ab< zk7YwBw||>G;Xbe^s{Jkm_HJJ=cRkuJFdN*aikO(4hP?8P^M|u+Gj}e6f09hrYHj7k zQl;-kZG|hjC)(pxP}_Zy6=)+Xe~ueg4GX`gN&&UY?>tThoy8nZ=|prFL=Sq06)`9{ zqYvPkQ=PwZf81$M2~siM@^QNB*WM>=dAz+3K2~zSo|o`?-)!&g;C%qg;@`GA)!whK z3wYnocjvLAj682oyxSi-&#IQZy6=V`YrQ#LPji-(&Z{J;p%J(4P17y+Y`AwG=-HnT z+Nn87JfH$C;*+_a+Jb>O=is))dIZ`}yx$^M$Bm*l-;XoAZ+0h*y5CYArxT+$nPA(1 zW(pnGlFcv3=j+&sZ(-_>8{!7Qfm#*3LIdF6WuQ~WVK(?+0Z3w_mNajc`Aa0cqkiVas zV?Weh>*xag?F)*F%}_G*YCe)mivZ|>sog1manAegtAz+6$ z$OrTx4`_Bje$X3*CWNUs@N4|{vM-1ZKPQUy?GgyZoNpq+P#0AS_kNsqb7dvR?vL_deQ`K-mK(D>>Nd%JOiH7X?3Rt zXQDRq7tl(mA(4F~Utbd?f7z)rK|{Yrj8n_oe)en@P_qHnZ$&7Q`D35*cFaAR;Adl7 zuw3=UmeG+osNe59Lb#Qls{G9t;jLfz%D9i`AP-irqYq`Y)TgN=mC2M4IPm){IhEG< zJ}_7^q}qeP_fANNnEka)SCQJSo{v8+&y*3HyhB}LNhS2VyueSV<44UdvDo9T#`dzKxtju{rminBQ@fUuY!JhZpJbC=@z? z%Lc}8V@}uWOgOL#@~g|(J zwXt%yc~K-;TrW$j+v4bypUViD>P(lt!EH*!{4hr@*7&GKvFT@r#9rdd=B);OoWWZc zDYfk}5t1g~{cxH6QahR?T{p6t@E-4puRM4l<0eV&+2V21(&L<5>D!5VdNaFeH~Q5u z5VFP`B@~OHOP_#X0CmCEpG?j@L^Jz=+g1rG$vlaKh4qTtW;8Eb)qPuBOi`!BpPP6r z=PamwDT`2F)XYt{Rw6#Pc!w;z_fG=t$qtI%$D5*wnM1mi_$o|IP^=i&<`Rl5Y)qn@ zEl#A(IU+1E<9D;S|B;qUm<12xL%hOHAIs2BSc^tpT_3qtpR^&fQ(c{a?n&#NyX*L= zKxAy3f^$@sq&W`nq>^>k<5%6R2Ph(# zvmryb_$toVQ?xXR zl?*)0^il>+2$V{Ft4;u03XR0L;Wl1Z~DX}EHT~&H-sS=5@Hkykw1EET z4E*&66hq!b-E zZ_O6<`8Wlh>Jm_#n(71UbOis5sCY@4DVTZKOAs;Z)F^LGg!Wq|xrqLEd=OvW-2(t6 zt0NTWlB9K%xAUGm9bp}xI-fK`Ebl0mv-4g|%BmKszJRb|dv3pwi2@93; znlqqkM$Y^A?aBN|Z)#)sL;QjCfLOI`B*O?f(AQu~Ns#LCzUy5Ge@stt8v?Y}Mc&EQ zzutG*^$qz=b98fRsN(NWeqmT_aH$yXzha-Ha$ZUhv4kG8nx#VIV`Hl{nL6>dpnt4wbW6kdii+VC3Dd)3 z(hX}81I8p8m|hqkLC0zvyeIkpi2u;3zp_{`6{8`E$t4^U>Hk?NHTsuk!z2xXNft)@{?{NlqkxIDt4|RgIj8cu2j40(>Xa z0;m}6gu!aY`;;--I6%;_hVKLC%uKHO{@02VlrEWY zhz}!FtF%wn#Vq9rAaWi|%cz@GoNP!C8eJu(Sc+jI$nk~?_6D)qUDVHY=xon5xmm(`{#D1QCksS{G>xwZe-p+w z;D)p>J@NsAchmQrO`SKh?=I@&clC3!yPo-&3E0&Y2#2oE@+V>SF{w%C9r$r`eRM&s z{^th%QJU2QtMEsn)IsU+0afM=L8;Loz}G=#RQp-eCGY7>^-=w#|CH_YcLlNiW$UH` zY^z@nwO-?=d@Jn{%+)yzyMv&YS=y(#E4_=e6Ul21OeU>&0_w7AAX_Zl&P9|Y4=svI z)3grIQ~AKs^L@I^`T%hR+VHUn$j!9Vm2Lx&p00s%7do=;agyr5%WA^UXu)ec!e3P2 znk)elH^{OCon7I#T;RD|Lmc&tSYy9_wS29C`m%PXvbzy^073ykmlKgTisNH%5PbH2LWXR8Ada-@J*iU=1udti?N3cX6-cVh#fnWZ%o=O)O>&@@VPrsuJH+_9=vQ{E9BV>Fp9bzr+)?HYyD!M zDa)-a?5AR2ho!(4i+H72ah^@^`}6HN)#8NR;f5ph$)Q~gaOV9SJ!_Ow8CmlAbgMv# zi6!_2%uWu~nXyl|w#50fWc~Je0Ids%6i{b=@0P!4wnL(RBTGlO=TwZ=)0RG4hKJJ* zNhU+BuX$f%s>Sd8%adgf<)lI%ZJ(Df!w$ktNc#bl<1_6S){>qeK4ldT zv(}a#)4eXhfuv=xn!aMlj5p!UnX5Z}Ym)AvIC>*$O?e6`b?UQQ0CDH!%V0~dXPGt^ zjOzv?!VRFV;8OZI!K6kC<1iiP7?MSGm_={`^A~N@edT&W@4M&o_kV25j10^J`|#8T zAz*5Y7`sZQ{=(V6Q`!bmeaH=FpD`nJ&?Kpk^`UvK&ib$;IsV5S?UX6rQjHHITv~)o zC=Hbji2L@K`$#3=%-&eVCL9bn*V606Ve@U5&Ew=RJNVtk!AbMtZ#XNmn6_~ZF1u6?avM_Z-i_zY@r!78psowc!h zc$FseUmc}o4`wfuALY&Rc!BYKPxa+56+hUCemLr17kxGp#J5r<7v@_l_p~iQ>Tdlp?_nXdKV-NjC**nTL9aZ6-GAY^i!qbk|;PwW<53rS?=C* z$)4&|ha@e*AMX(DA7D$}W{u^ZgV*Yw6xa8Of7K>Kt(P{m)Hi)_dN}*m{XOnIk%Nkr z#dse+?$@+eoNN=gPYQpyMJxWuK=8)(@fcQc)xg>IFNIaQr#YZHoEKw>G#YGr0#<{_nBH{+PIBFTzm zB3J9ue9mPvnSkWJNGE5`ioe7>(97j*7VyM0WS#3sMPCdGJ5-A4FEx&TB%qhk;436# zfj(&PdNXjQpr(q%D;sAXIc8{WfgPS5B%*z|+CgsdS)hnnpz%(2BU=fjGN5cAE&2jV zUz4((rH@%-B^|;}L$m#q6@`PgGl-MfsRX_(4eT~*B_43o@H4g>MbWz{7YI@e7OO#I zJHH;<4$(Ayy}CP>6Ay9c6VI_ZqpE{>@B^kEc-8Uio`z+=fU_IN+1vaZ5b4%#^IRio zYi%!i?<&I2qeAZP3hb=o&)xB>g9PwlYgQ9<+Y8P`g;Hwh`DU z%7j%Y3oD;fnaHQpipnDFwjANcd=tTFIif}6MdW!k6OcaQA1e< zXV~71Z0212sdb_O`~iF;1V#vqAQ%BKf&uly``dg>Jj!>uxzGq6B_sN~(LtgpQS?}P zTzxLn?r9?4t;147ACBW6<$)S&-*Dh+fo_EU-@<`${G<3r?3FpVJfpApkNl^Bv*7vg z0(e0@=wKLN1pjmSKTS!9D&*{qI&5s&sz@X{9#&VrB5ja+x~Em&}*N za^}bJCCXyA6TC-1Bb|OqDvce9bUG-UNq_(U9_piq=%bI)$LZq_@P+up1e!j`^sZm0 zj#p>cfOXa`yAO7@6!*Ao`73YZ^ib)(`+m=V7wqgjo%o*V60&^>m=HAnF(H|hNK2-t z(pTy4y40h*)}y?s*-obWx^$HFx(=V=zQafl{{M3P&mbM7rM+B<53`wo-y6HS{zZ58 zO!cfqHpxtva}X6L1RN0LG;(~s3S(%IVra2^@O6{G>t@d61B9JjSon7@w8>p8Gt}_G z&I&hXYM|boofUrM*l^1He(2A~av7#sb%Op512<;AOSaicphn<tXyWO~{3 zV4ZR%ZX>@L4vV&p;ZwKZcJa;a>Bo;##b zo$Cscj^)Dy{R)!J@&GkVHx1j3Y}78o{f4EM z%48huBWr2N;?rk+@ERy|?Mseq)p3)-6aO;)hFxXHpwqFG!LDzszIv6c;zjd9lHuvQL|{j(nv@M?SZ7-@vrTG~rhj3IY^>h@q|qL) zKMO(9?h6$h1D1AHBg1|N52M`W1KlNT-dcJLgST9berKyt7`oUbWspS%8b&C+Kj529A0*>r?;I0WT7)~KM0!~ zUXHKd8+fZ9o!e{e9$Eif0!RXk15g5#16Tr_1Gc*T8Tc9H89R*R>#aVRPikHN6$W2ViPvCM zY}y?n6Hmb)**!+8BfQrQz9}k?kMrP;!abeL>xS@mFbkk3#kYK{*PQ6_juZAB$1TI?+QbkM(1grlHCaFWhZ@{CG)rB z-f^j5Ch`k?>Pg2!SjPg~CnYIZp6YJ7L;TSQ7A-EsLEW>kIOc}kB-ZzX!+@AX);BA7 zzO{pNV$UqmHA4}`T>Vf8S=7HM{7R547U3-8S$1I9px=}3M6zPCcTE<%zR=@1D-)Y{ z!-Ja)weBidO|>&(5bn$#_k9wQxTlc$DC*M;D2N^}_!i+8k#1fiVIwG)_#QR?s8i$! z3A|`!tT52d9Z+cm$|Uax2NJW30y?tFp~wxVukymnXoPT%j)J-Vv4>G7;bRq0u;kTJ zZKIGoMJ6(Pp-BwL!5G!+oAB35v&hxkk2GK#kLmX1>JMiL<}8xxFEb18&&ZoMLpyvy%Gk^L!0nRq9m!> zXC+4@N6z0$tAm-)jQ6dJVYHo41~%cMH0P+blOw$-8}DN(p!Up7^lN6054XCkeF;N2 zmDfTU7H~}ZsD`rruo@uf3zw31QMHhIVJ%fP-ciz(C zaM#rY(ZX599Zhva&y;x>I1X}iX8oAKw91d~ElQ!)$p7M-Rde>D{B zBp15PHV9BbS!XtdG+kJIuU)4OUm^E?&bMV3OwdJdQ1rYP%Xhxky?oCP@8FG!xC^yc#|GA#GytptW z(CXxkezbs}RchW?fiBVOxGYuNC!Gr_>_jYwERySOD3LbD>8>cUG|YW|GSO*fUVMgc z9wfS0%tK_JB%w<>etXfh;N*`mNxX2dfhKuNa84z0Z9@$_5pPm3>RW)6EKoOulnRveOf4Uxd)B9)t$$@8k z-YOz8XMlmI+$BV=OV^HymxJPeyJreY26{Tkhe0uJ%Ef=nf&=A~JDyn=v(b>+CgYdgfA#PLNY=M9z6b%)# zyqR#ma`5wxY8co^dRD0M-V#^-=o*{A=jM-pLt{f$?2#1p$r}5|xV!3fn?p@hte#PBQ0`*b4P{T$O`7jDs5uh_^U`O zU1D$ho@B0iu}0w>wZw;}to)-*YExr(A%m9pP~M!ocFpSVX(6_k!y7*gGvlrgSAdmz zr0eERx0!Qr=hD^4eJ=Zx=_;yaz~w>Drk&~#6eXC@9T=YYZC#nG}S z32Nef&I)wsgw1zbmU8{mP_X!fAsUeJcB`+k|_iDFrD*pC9sV_ zzg~D1&|-8y|Y8-9j-I3{JKFR;-xUSkSFjJ=r8Z4q+@GR|Tzr z3n9N9vXE4@W4OsmEqR8%)&VBC?k{w12Crv&Zbc-y_c%p?@xzst5m3_yonS_a zJwZPRv8=T;CYPzQe;Q@Hlu;a`&D$#KR*Ai_^Z;{hYQ=sJs9rwG!2WT`DW8T33FWp% zt%-tY1&cE#G{fyHO|GEr^FC3*8k6O1L|NA5?zfn)wPAfZNgv+VKN^v-@d1m*z*b?U zZ+%wd^a{--rL+nefkcy9GmR4Z`uMZ^_w3{z`ug?atam@b8l(lS?yBz@tOdRfr%%QI z3h!fb4M8TDkt#_ypBnl|gZx0i9c{d4mUHzK$4d6*{lBImFKz9Npr6;1Fd!QlOLh7c z+msu?8BF?-v8zPnV$#N&rP_=U zDf;^Wvkz_;k<$w{b@5k8-m>H;CFPRnepdk{N9n*e6-e5vjvJLr-a1!h+cioe_kRUDl5GX760xm*!68U!S-40*s#K&W1lMXZ^(Xu>5l*k!I8{^ zAP9vp|3$;?on3SHGO#CJ#X ze9UAH=z_`FGu8rG-K$?zYng`HrwoI35Cv-|q6)hhsa~qj7#Ze-EVUQNt{BH~NAQ!q`uzO`#u)w1Q)T&F&NJLcdy6CI zJyaO4EjPSo9@4|Lkh`Vy$#wYBj>i;Z=tm=|kDa5V)E0xN_MVvHue-%%? z9-$eXTt^f+@*y3kVi8rSA;y26kDP$*h+of)~mg^@ioev&stqPH9FIMsw zn{-1RtS{ASWH+(iCpsBVyyqr6?92ZHrtg%kZc{~%EYu3R>iP~E_0n5(()2FwjC>#7 zsW~`+qpfW2aT2GU3@gg) z^RdTSga_oNu)sg(Uh%IVPssJ-CcUO`*$7BglqSto4+Y52||Pmkz1p+$AzN1m-^1%izES$Aex2rr>#dr0|$D zU;{rAb9Pp)?YaP0R`3Xi6Agahet}&wO(#*WWgNj=jv66&H;JbS134@zlb)-XB5(7KP~8Or0N{J{^-4w^k6vx=j(kQe(5oS zd@4ux5}rKEr0=+&_4|=657ORph8BTs1sQqdSZ)A={Q>J!QgK+*=@_X4K73mZCxSyW zM};>MjyUh!tm?J&P3Y_s3Z~ORxzcXeUIi>a-bm56`xB$d0ux!|@te4>2}+f7d>S3s zLb*n#Q0s!0^HIn{kL};xOa7L;FO&pvpBHA6%pVI%K_>qIRj0Dv8ngU6`15ntB#c84 z4Gg3-*~{FUah;bbK zgVEN=tH&6`hx1pY8CVg21HMj5Z5K@eYjPaKDym8}=u(bEIYIKx&+$;+7m zak~Vvg;FLIB`y!SL`xSvTZ@)BTv`7cg_WKqxO8m9y?hIL6(Izcd#g}fA;jXu{UH?7 zV18V$g0N~QR0?8WTrZ>SjV`#QUvsGwI2`>iBK4^feho@JpzwJLJh{%~c6sk)DMB^A ziwJxGV=-zdH#|Q{}hvgP&F~X5N#RCOtc3++uK*^&Ibmh@r zexF+Jf#KPC^!~9y*ZcM?-JEKLM|cF2v3=vE_IV$1+3V(wfU%V7 zoUaRfqVoDbRJ~J_ZB48O+O}=mwr$(CZQI?uZQC|?+qSveHg5mtoN>p!56Mb0lbRXz zFl$xSNIw6)X|2Rs@@`q#Y9b`_{OM zi)`u3D2(760eSS@81F*!Mw$qV%=kna39=4 z9ufRm_CLOHhGc+yw-4^EGza`3cL+4M$87mxh+3^NnOswUk`bS65b8!fs6ns~c13zO z4fk6w(DzHjyH(#IJE_9=S?@uJQQa=?}@#PWoNbMy}gm$)pJk}t->B;t>y><;gkXPoXwOkO$0&)?|WF11NW4dH4lGHXiTHsXW( z0~THIwnNm?Em)gAF81<<>FJscmPH^mJA1Z1ua;jU&;@V>)I9m8Ra48)%85K4lZ0`| zV|hHO7{fM9ymQkeS1=XRB$==?i9EQ)z5bG=?63=97l7e5Kk($BdT-DN2dsK8>K~{9 z>VZ3;M(C?9fSMrCuSTK(phg%^4G^r;;B6Or>gHh={w7!riC_)%H;kd{$&C~7?;gN2 zLcehi)0F|Ffx-4-1vvCF4Bf{lPS=J^S0~SVCHob2gsMve_T^Lp(} zRHiVSDvYWk$5!eVHK%3jRI`?+@ESh_cuc~2`)5FNH73Y`lEl#fj z!kfOXc6lzW>gh=N>X{RWU~jD}3pfA56bl(N=ANactZ9Nj7tx>U1s{6-(OXH!f2#3R z&N07l+_|PKo~}lv$k(2x*ucteyq?qpTloVlIdxr9rdHt?$h$j ze=6ri)May6V);5h!@1<6-rN8ri1cZuPgfj0GGsSfJPuoTTv)nvIZB#qU&`!WFyV^) z7Q66|^~S2(*e2Eyi?Rn8CoJ`gc4~;qW?-BehX~3LVVr^n2tL6$NzD>G<)q3^pT|Es z1phUc5htY|{XqSRVfr_n=*741p4%rxeA6m>uP0r6y#loSCZt=>|9{097xtTM2(zmY zYd;Rs_k<%jZ;9=ihi>WTW0C5kj5Hm(0f4nM^NiSmT#Pa-nMDwB-`l8hOq89+77Y3qLK%!MfqShdy)+V4nqSlsAKzvbr)(_HAu_P@k z7mKKR=;^v^uKlvJR9}F9-iZ-QR zV7QS=C?&)JLEp@xIU{#!6XR-9^ESlPzVUxy-&UIB{O417C}H1gNViP`d%2T~mi13| zrG`+}mFuP4$gLJ}XV3IJUF?~HlEKz_C-b?x=W^5{vL)TOiLzbrF*^03x2sM_1zCfA z1g#KQSR`l@UnnEQT@QqN66;F1-g@)p{QeaD5}@*^C+*t}&w1?eCU{=fhPmzO<{dx3 z58sKNgUX_HY!r2w9Ew_PHaFWo-(t=>zp_|MWp5b2WSvK~zW&mAEbbFEO<62f+;8s) z4vWDo+}BDfr|piqqqW^|KN1}>(!a`df~-6|w;oV(NYR*KK!1S-B|IW04N$Ro=AH{k z2R;AVmoehBN-2n+(N{f0Kl)_m`peAH4;(Nf_R|YBMkW)@wfH8tse>M{x)fsk1)=j2 zJ}VXMFql|~vPNPAQ<6CVCpVH!j|R~p4~X#889~G+XQYZAfb5QnFd*aM%P2yck^+hs zJtKY}D$Gz3tq`fi>k;1oh1NKFos%Eob8k>c15FAfRunA1KT7sw$SrfSHH~Ot0oedr z=4M0}M8;6Vv+6QW{L8ZRgq0dfmAs^6jycyZOs@7UP9Q|8Ayjm_$L&a_tpb>lhj&Y$ z%7seE#VYE0b^`q3i@_{WUy9rpb3X=s!~J~xGzV7X4tx_k(0{hhKHZ!Fs1YRSZ%&_CqiTfe8zH`0CyV#iT%L@SfKGJ{P9Hwgw@U@@sZ=1mt zFr2J-IUZ7W16#n6~{|d`iD+25bUpm7(B<6GZ<%3!pwM23>YkLZ2XR#RdyBK~(aBP+7o)L9jd zO^m@kbTqXvXZz@w z4wth4v(9C#CM( zgxNh<`yEh{j0kxO5mj(;O8+X5k?Tg|nW!JlRb#?VeYxUZ=};OYRd?~Mg?pQ&I2GaY zt+y0&`?}nFo2ip{6GJDxHL6!`wvq9to4J0)@>T>V2fMX_kn@r^ag`E_FFu-sp5h+d zXz}?VF&>=B&F5!K*`LR224|vYnaxBxh^HuZ-6^%o(Dr4I!COi7xR$q#lmp4(wh5|Z z8y@P}GB+LaXxqWxLm==@{0!`$N8L`W*9n~%U^Gfsnt#tY z{3V9 zeuDw!3-klt;s)Wpp~6CuG^syi2@XW~3Yea(W3F5-#wHxf_T#3Dtw6y6sl1s@F^ybe zre(I_=2&kNv9G&It;yMOzS93+uI>_j-AqpBVNTn*UDIJjA4dm|b2op**HbIzrXqAj z4)!~l+OtwgR$ANgvfkc;yDsO`Cu`j-m`dkCzs^Y`#%g7{n_mJ1)E@R2TccCIFW$^h zy2MCBTI~idBl|TVX_X?!s*ZUG6hpv!qz=g@By?H!tty$^(~7BzZ8CvZQmwbud29Mn z5n@Y2bu{O{LgOD7`CG;r-%SIMEi!Sumv;l317g^nrU|*2;ZVE z$OXLURb2_GPFGdqi6H=IZKGQnrWduA5mJ1~$+2tp-HUy@iVL@<*pxhxfVes?s#}0D zr7`!p@ONe|jA!{q8I&1z6A(##kz6hoH zUVc`k_t|55NA;f=-MAew#?LcQJw05+NPLGZ$b5VINa&ML>(dy_7qKC+YG+LIiH%MJ zCCJO|eLb9#8i#y^DTrlmEpp0f#&@ar=XemGhM<1ga&4O$*x6*QW7SYm*oQmRqUPGE z+Aq2o;Fppt456Y2CRd{xX+Argo`XK_@71RpDe4d0$GDqJXb7z>eddN2DKEXOXg(~E z{VXO>d8!ukvb1gPHkk$1$ujJlV06$-)*i#{SCcN(;^K_2FruW}S;-)70w?lB#?K0b~2{l`Mw+Kn}KAePxN#nHmox%O4pNuvg=)9;5& zBFC>E`IIMs0>MnJPo*-Y!=NVIlA|SEom#&Vl{bc!8BMvl->d9&^@czDXW@sP>$NL? zeTyrk;&!!_ePjO5Hl%>sAB;76ZgNx>1Ff6;=3R3jYm+^kT}{jqhx&fps82r|$umau z#NpgUHvlApXmlaslR#%@UIoZCz?Ff5{sP${ZJt|$zjSpoTt?WCj6qj8 zb2wWLxmH5v*SuC?lVXJFH35Y1$6oR*5qs5&=>bQQ2Tjb0zy@7gm^C~*M0?ugY{1z? zxS2)jB0Q2s1bl`rd;$TvWw|D&NXCu}%CCB%B1W=)C0FMRnD9z&Ps%P}gLs4Upr5Il zMJ>M#{inv0GG5_R>QBH8qz#OqRf2FMb8_5y+9k;t8hc_jAXun8l%|YFjTXp%*n>iR zn^-Y;&FFK|U_LbdHF;<*VPV8;^RUm^_7%e(!KKXon?B{iSVj>hn^C2>ty{*9k&1*3 zJD%s7Q$+b|1rZQS(4wR{5-|b%bp)^`Vp7=eal-Q6fEQOUfWv2yDm!!+-WPD9`N|gx zl|ijD-;sYi+ydIp&ayx-BQPXCDG*d8(il+*FEO(sDOO5QUr<2}{Mu{<=f@3GMk8L0 zquZ~J4JvTNwC}vahmeDDHm3kbVqtk~BsP^B&gUi@@Dcxom^QhLuS5FJJs5jND{irK z^99G03?h*L=5Mw!;hw&&h=WxIET>`p-5L|bNN>5KQb9PPJOAm^!qLPvp!X~>l`w&) z$7?#3FwThRZe%H(yIK~81=)O0WS9fp=t;DOMyLlozSTX7Gq{B&`mAg>WEJYsWsLTb z5ef$fHp3llhR8mxCf&t(-N?nH#SKn9*#~+&1B2MXwqXn@Y)n?b+(}nc+kHFi{Fq2# zSf(nvQ2hn#o`@T#FW%v4Ty)-x*6Z6c0>8UM>X;lPr*?5|s3<=K&y zrZ{V!O>50rJ=j=t-H-L&Hy9P6{Bj2xRG5#jR~G<5pPz&KcOwT!*wNap{b0fjtq&0O za$uHk)WPEoHRosrB>0(NMK&8o8(E#5@6)f%hv*WZZukCo<0bM*kB*~_IX_8gP#{eI z=hHJ7<6nT5fj2pul;$NuR+kE0IQ6v>t6_tss$iKs0#cHPS$}!SDlx)WE0=%5e!z%< zQvn>M00`8#4gROq2mv&jYiIqi4B?&w${{ZBkJhE@L)nlkJ_|2TgI`d8qo=M0Z9N+r zbca?pG;V-b3?@0TYM5rMs$-X|wR7JL3m*H_;B@o;C5Ir}gA{+Z;g)SS@T3D!3}X~` z#%5Z>=hoYex;Vsh4Ob29y>IUw$Zn6QiZ*A)uo|rkc;u0_1(7cqVPa)6R!*$rAy&u{ zT$QSDreQxT@{r(UpkYbwi~Y-=b7Q`vk%vS-*ja8U)KN-6$%KrDk`4LR3%v=T9e&%} zC3RNu(N0OjjPCyNtbEldW|K!#r`7;Fk1Y1FToHpkqnUPMFM-NXTxigd5!AGVDdV^|GKF|4>BQP4a(Q61&JIDur~O+k20*VzKry^> zubK8wp`Z0OB}hX*0G5%y6*IQI`y&(E@lZ&mMqPURRf#r^1XP4Mi6lz>Zz8tyB82}P zuQh+1TwI_Gb1D7AVr6FTfVe%hcqMKeph37fx%E}0yY2ixK2Lv1xb zlWvvvsz1B7H||}~Pe0r0vroTG$bOu^emcH?bbfyN%70F=0p_G5zyj`d68$QG(47OJ z=cjVs{Sgw!Ak>dVtx;cE3Wv>BM#F`|8+}*l6(o2b>fyS8`y8}k>v#S23jqCOcAs2P`C^GFk(;Xa~R{d zd6(6s0tHHbJg@uJEdng}4flgNap5}$!Q9sZ0+ED)7hzNz9>}921l>lTC1H%C`O+m~ zmIYG4g#-T0d$&Xki5sE|)k-3Rr3{3(dp#?o!4`=r4+s=dfCLsVj|$|_utdg<>?9c9 z7fm>quG2ls??2lG{CGO&gNqmz+ZU7LHj`bMQB|TLnQ}E+v{^ks9k%D0;+v1_Lq*Y< zYJbQ}q}qXg!!12zjG#h5E8KnEH_gFvSi=Ryvn(YD(=RUzH% zS0Gu<6<4y0RV=IspL8{<|11R{^j^6T1X7+$csHy)4|oBmpkR$fxeQkKJ^z3XI9^6a zx`t>X?TGeFAu&s^>nu)hw-?K9t4vx25HCJL{8gIyEiy~~n)QjA4F542v7Ln4e-B=z6R@WBSs zW9fNCNwlEd!a~|9{s`>7rmSX~cxaJZOycn`*f1hEL{%dMX@aVgPV*8>yoLm(p$X~c zm4@N|2VED@*HN%Ot1$c+Mvak!4%dA^B|cXK;e8*w*6ZHdWw|& zBVvp?5YVOxv9Fcv5^F^jm85250Gzr*5A@Bh5H{T8RK?~&odCB)f6k7etoR9B_GQWl z)1Q&#axFk%Q;#4sGXTTNbAmt%XMmt90I|_6Eh8eGElfjO`B|B{fRQfhwZPRJ)QRH} ze_N9M7Cm(9aLW$~!0dcb!?6{sR3czELkD3(ww4cpDoLnrP=R15{BZki4ZTQYLPgfV z=iOL!Lfw0KpXnV5tP>pZ-fUS54I|4OL`6&?61x&>;?YP4d zKIdDIksO$RJmC?$i*1E$jjg;5Td&CCG;KR( zSR-xPhK}VhFso|kFq@~3GMHmVLa`gq4iIdZk#cpmvG6LMFa}DbX>PHx2Pr9P9&R4> z8hi^HnB32LHlyfMR~?ed!@6Fh;{xm#n1+L4_ER$xd_;!0(YL6_^{gQ@P$`J%_#hE0 zdu_Ds_h2V;kdU9vlst`joV|!Cam&RT|MIy`!ki~EU@DLf&PliUerY&cxKxHP2?2P_f1IW|jD}ZQhF{Zc&wdj?d+56G^XPaKdm7?$2 zysNac3=6(}J1kW%xoNAa0W*giCG^i!>+w|x>(S)qqA_Hx4>tZ$=Z|cC6lTf`sujuCfU1fOY#6HFkAu_&PJVTx|fi$ zv(O?ea^^YREq<~sYf%MjNk=+&Xa%P+?bWCg#l_T5pyi|<;m@fF)j8H1f7#)k|4-fO z>(}=ib^n|M!Y2=U5dZXKmgulNPRBE6&uG`N6i>n6r0F{xUw2mz74&TZ&=6#nuz_to zOcOVqG6s`93zqSwv8y@2R)QRkVDv~6@gds)M1SSyV*$;|3(CZJ)Gpi$+=-GTr=wSw z{f<`3m#(L-aocGK(}Y)lwUtmgaTuF}Vn-mE7H^KO9~_1%A{4c!(`?X8|FtZKZh%^Jp<>XdGHYMiw(lt;#hQC_rE~?H$;Xe*usWID+P|~ei#KTDmU14 z)rbJs_jm+ne~>8(Vwc!0@=knaE3Y%KDKD|~XdtNzHa9zXwP4a^ofyJoK_%eQJlCFg z6IWioMVV^#G|)N{$y|SACce*RsTK8v_Ghmepk454*kbAXF%uBhlvX?Oe<$Zn9ZcK(des3m%(I%H|d~FY>N)i?vhw zMQS>WP-B?@h#fs}M^F$m{TqS;f*yMf4WvS^FYdcs80jnF^YuBoc5~U&dJP0T1ngt{ zL`ij<@dd!`O8JN34@zNl2du6txO~Dg2b{}?H?f2qolfC9zIfXsoRfqv zP@*v`VvQ5ISOK4%1;F|OVsD=u#N?w19FWUQ0e=og0vn4xSiFlwT6+NsboA)(E4b@F zcNc$T1M%_*opY5=Ou$;8y`E-Y@p%(poR|EMMAfDUf7IJ5$5P}zUBBxZFEfAg4*!tl zcGYyVqLJIgh0FWAE)5h+l^RBGvn(oRR_|Ck*6iNu9$FP+n|?)5O?E-9;n)Vc1wP~1 zMyirHH$&NiRX*LmGQ4R&MP7qm$SWz|?&+Ir03%iXo#X9SBU`KbEJ$;E^?U?cwR!R0 z7>_#!D%Cmy|8LE&*0qfs20KR<8~W8eoSKz1r zwL`FTw*R%=;h<~hBX@eJc5~#~F?c?oa5`u>x|y>XJO+L8K&>akvl$RpbKK~) zMRp6})=6cb6jSCv+dXsZOrxpIu<5>3xdVrP>m2;l&w3G`G4vg9ies+z?lIc_I7GVP zU&k0#!?6JFC{)|!xgmFs;L8{vbJpzX(?Oir9(H#p_4_&H#p^2$I(QX6Y(`PdTZoX_ zq%^f}`527csG3SKV_e&+<_`6@`(*fNMf+wSAehkZPWf9OxW<305;5DQXOH%YP^x=3 z;S73PITW|F%62;&jNaNRL1F^j_8T55o^1UwnOm4Cb~baDb#SbV^Z)ZpM4h18>3cMarer8%`}a<6gL zsKLVcuYXGc070P8Bwabm8b#R1eK<^?c}-bA(pNPcLw3cEYIJc zs`dg#tIw`Fs|A)Nm_N$raA_MxZj9*lt3`CCJS~O}Q0>ncf3+8U%d35=XA!sszy0mg z4H{y3M%(eZoYviqmhp=XMmNA3F1lsei(2kLZfEn5mBmNM8bkXKBL;^@I+Noymm~XL ziuSsR51kUNi%v&J2A!O%X)1)Mop*4Q$w1YZ8r?DX=Y!PP_`nH=6AYpJ!hXCFSzyc7 zybO^Ef*hkqQ$7(d+=MNZicU1U%zRjiDGi&Upm}w8r}Z9|6zXZPj_*gtzXc(jR`zI@}cVDF)ntvndp12 z*t3Y=LhJuw=CT2VA<#d3)Vs^KUR%36JhdNmhGOlaJ#p<$+MHw{u~$9I-cF)A>FI1Q zw`4u7;j;Tir#xw1ZvJ8$m`|ksH)1v-Sn*keo`_|$qdoo9Xq>-#IJ)p=xKni-WxJek zMuTOImJQevFG3lxBHr$ZZ5^)aT;pt3whubX+)fSEh$_MR z1EsGs5rWw!erz8{rGv&8q1w$|e!(b8>xRa7=hza$`V zq4x%l{yU^jtWYLm7%qZ4)&-hR6^i;sWG1lfUo@BpJ=p^V=zLdiL>l(NC#v%VPv-y) zi?MQ0dAM4Dd{++}?go01rG_-YY79{w;uHnpM?cb~y&MgIs;qH1qux+P>Dp`!*7bPu zLb>nEe)>VUEO2@j#@NwpeaP;+M@Ir_+brFInH6+JYC^Cbjy)>F1^@ruoa-vuW3waq zvH1_LFwBtan>;P#yC)dBn0g*^rIHG2mC+u!)M!WvVlA3pr91D(D6_Hju<=26A)_*(rNc`fJr89D=6?H8SoDXuMPp6P02n)I> zyZnQL=GBmw4-2OcT|OV+qJrb1!$=aa>%Hlwn}#MM(?Jy!1$pY!3dGs8I%%>(enk6Iv#xl?Y=JMaL+p(x?dK|B%-e zOTyG-E^Sd8bipY}%1lCABv~)aKuSCqZW*E7`cagjBy zEIHEB4y(Ng?9xu9C1&5L;mo$=a0wH94}!In2OpM`6hD(o>8h9^A_)f}m{LTu@>->r zBqFLLF744!DK509R7NQf&l&l{^F0o~R}`vr*4h7{%Fq?F#YDm()pXss=<&%wqrii< zTf*Ms@^>y5&O2rxoN%n-eLTy+ts|C;@v52Rq6tolQKsi&^;_Q0`(^zb!BPv^ef%~G zYG=j+Qpyc)c%MgI1d(P>JSGh2I-}xF%k4#3QBO3L5+tT=&>yledf<|!z`xAfxu|tyzd0bk)bd>5k#P2<8)(j!-z(E1~emi4@Mkg#UUeN!$Dxc30$ZrqkRX3={pmA*Rw)N^-n6gs`Y-hF>rxklvL_co~ut_ zrRt0-tu!9}?$)@dAgV8u=w3H@v16gUwltek6$9g$M7M>eVg0@bZqzMqnexf!c&Im( zxe)6awlB=RpG@kqFF@a#F%;jrv$I&?1xU^Q=H*w<3iEWxE3BLX;#!)!JbL^#wX~o! z4DgM5(4Z?i{QhG~IP#?n_s==pS@&A7NkK>wQ((-l)U8$@(m>NCijvO-jjrD|67s6q0Sh$ZnJX5^-Y+wluoNzuOBj)<*AisAfTg zhGxxGz{N4N9z0Nvq6U_6x~o<^qjn$Oj64|A$Q;$=fZ#kM#%l?lVtb&i1VSiIM@1SX z5}?>#4V`s5t|+R1O^e1-pY7I_158C4$w@cJ)3hIsDuC}AC&!H;o-#~Hk27}RVDNFX zvHW^T`fWwbL`=h8B!};1*qjI=!FahpixDb`4qDIa)1VMg|1ql#Wx(z4wE)5VI+Q4e zBHa6nRyG9-oB~AT&5D8c6=E`<4ry#41(M*|^H;QIOniSa7HDmzt_4dm=J$&3MH_68 z+75&=&SPFyak!dv<#s~u---xH{$6MYT`YreUsOrCQD+-%EQMJ5aTMe50cHirQupr> zqR0U$Q4ooEuT*il(F&4sZq|oVKy$cf9Rv~%|5H`KRt)rq#2|jMr9Uj7U!80^veScr zQ?7uE7%PL5<9Lh_B*3MSz;Oc#i4QLn10@>#5OsX@vuFSTf)ldY#TWOQ#~iPxT*b;d z!7|23VQvqy+|=}i+zo^n{sjR&@C3002B%*DVfle8mk=m6{Dxt-oAUqSmDvt4$wLNg z_i9hTkN~)OFm;hL^?*1%6lqHalF>7tADUG_Q`eAU!$_BZYTPB0vj1_Pv~v2XD0F@6 zP#8a19rY|)9hZXs?4GvQ5Y()#d2owlls+ARV4$m-R29ub>%LTMn2`W%<{YLKYgJPl zKk?)0&7@P?p(8l>JoRgUs;CiqwQ@RDM1bt-Lo8QydbmCxS&l5uc5{x<#cA#`X6nnN z0hX$4)7{x=0!4|Z7YPzI_~Gixpu1iZ>TG&%1lfJ?E8L0<*``IK4&+9)f%cD=06JQw zj@O`MZ>*96jiE$b-2_Yv{5F`p|Sn zJN2RGb{RMdHE%o&g=$@X+Tt9G>`?S>c3PRc_d_(GJ~1*!9?+Yd*6DJl`{Inp*wKF8 z>b6;?3u<+gB-VAD);3MWm(>u=5k2)cxh{^0fzOoib2IF4v|~FsWMXnX3E?Bo_M4m{ zt>$+ks^SJEK@PVtSa2oxH*qbqz|fcUFg`~oe#iOOcHVYiC44>Lb_Ak+M#BiPJLa-0 zpNc=)lp@7cOjcR%bT@fsqWW_{WN zcF7JsM*&0O0EQlhd`)E9?C7<~6k4z0rIc?Uoc?9N-wewQRs|sj?PTK}-#s@Ow$CND zZk%}hQ$G9his#YsT^5 zb2KBi%3a}&IW_B!|0W7wELf(*;y&sHM`Dk)cdtwrLD^cSzIo{J=2ZSzV0WY@n{sPw z2VAjq=bHM@(v>-u1#E`w;|+Sl?o7^9_zpK9Iud8;uxHINZciIXpsbsupSXKFk;KSp zKKQn#Y&sLzHLjOcp?-IUeud(`OGaIOE$cmx;*qyy`(JaKv}WsQId-;ZXd1e`IVRdV zE9Oj==lj8n5L>hHZ*7^+k5g}YH!Fs+$*?crT(ag(jaIjulCO->ba8*wli$O)8_+eciA?}c58p@y2Xy};bLzScer5TipLAzCa6V*>MMVU z2>u>fii2+OkKjleh%4=iYyN;TOa7K^o8e>}(HdYm@1IfhDB(Z}*R*ju`*JKlYuMQ3{_GCgb*Rz6o( z^@o1Td1<>oJ$lm3UVhp?ZptoS_!}R39Ig~Nb$b|aIMW6e?QIq8d4_a6#L=(s(LQ~+ zrI-;wM>bvBBHagKH-ExAL!ClDp3$XDvVtc2*$X-cIiW~KC%0-lBw%%Qr&G}K%#3Fj z!w?ukg3v6?@z_C}DGWVZXIYKlZMl)7*uarbPDCHcu@(NPWy={+TUo%41~(5&5@K{W z;#f5#)?o`3T9c{Yb#U@a$fC`=8QH?Dp3@`OBn||FSf_QeZ0SnD*L%`Lj@%`EOp}_r z2wt7C!!*`l9-N1Rqbk{og$|Loa81y(e89NvlS;(4_tMKTqiHwekLxuOOr-0qrhlJ--a?rMNSbbPw(-4?h5%i8PVoj)4N2J^$~uWwS1? zJTN0nPKQ3?8rP#heQ0PRB!+ zrcH=%G6SKfi$as_hc}otc_}`aURAf4sck)(CG9qDM(_npakYy6n5z0A?KM;1pJ_MDdbh9jdlpk#D5H#6_{jDCT)FR@ZliBv;PXpYKc ziy(nOdFpbXX~CUo$w^Qe5Eji%8oGXWzrLJVH?8T&8|+;b{I0?EB3|tC_jPO0Sh(C7 zX}y+nX~X+gHsk;3*M>Go>C!W@^*?mEpeFkef>zh&{PFKGwVMOYXRn)YsVS9jwJ~bb z)F!((I1FN=X8czu&f5$9ICNw-KEE07;qXG0%xw+rz7U;boA(g1^RWh;;YztmTaAZ$ z&9^hH5<6($y^x`j_2ymQdVNOg?Gr<}VfdiC^a}wFW8*ssT^dQp1P^hqRh zVMZ^boL;@6x}sdna?dhja>8DQ7b#ct-^Yihba_baNR}VKYH$Hx5wzm0gMFH>Qd1UBqlYdgR)5ew6 zu5>1LqQ&-QAm~b=g;=c30y^w?LK^HnVX<7xZP=sRn-}Mq?zv_YUM|cxk?wLfoMYF$ z*41%LmVauq&z<~rH*1))qpR)R_RSRt;>EhIg}d^-FD@;Qw=y?3r_alitgOgCKId%3rsiQXnOO{vY6>jPS%Rt;qwRnB!5<417HifmR)0Max7H(z*@hS(XOCs zE-}W1A8Q8IMg<#tMyD+u--Smw==Zkd$L7t?euVWf(a1ED-!)^#17EOnQB38}@n_$a z-TmbBk6w4X$Kubh^-tPH%5>lKkN!S5ZB1I6-RQB~<^E8(Y9d`n_{eA}Lv$QNTG?^! z-KDTC2NAOGk6mB=T+4UYTgL7IwgEM$pU`OMT_+PX0|B@ zEo?K68d&C$Um0UDGXvbCF2gh6=aMGCDW8c zCJeI=sS#SZqFe?lhb*(&9t&%AzopwRp{coW-T(f=RU2$Mn}8nXTB|9<+N3M~|0u(7 zqUS z+c&?o6ESe5b+u1nbqNG?y=3rQ|-4lw4ITNw8|1zD%?0p z{?9~4dd@k(NvTLZAV{gm>!c*55J5@<8@R|({@e8=v(u`gp;OJB|alvu}lnJ zx^$k1tZel(mPpy+bu^W%#p`4tRZ}!wLD>@L#`35YX>rzqH2<4J;qUt$T%;DH9NeUS z@u3-g7o-Chm6LLjaq^Oy^|JGhH6=+)<+UK?6eP7EG&wor{T8sWqx#qQa~K*`_YvxkgpBe}SrM^B!K_>;b9* zWJ!EF)+=~&#oJo-&jWvX`jM=!d(MYGT zrjG z^LH@(zgoZ{8rFdb*0KmjSEHmxHJZOc(h)6TkPRzLge#e3e>dW#|7snEXnb(m_SCV< zN3=ZuJ`x~Y@zWt%!J@UXZqQm=F>0-^8MZUjj@}<^MVkz@r7eZt)UrWuZNZ@bbsBmQl%*Kf;O`vdxa`ojXfxW*)0X#Gz7?^0@$ zqn&!l04LmLlIZ0}rdskvZ|MT?1d}jTC+8kzf}@XBSkONtM_~;t&s|Ur%X1yl$adR} zJh9OaEdQU8=Rf1UNZXlWo!xwq-gcolX{Tts6ovI{9r$~!7=DDbCbkC(q^a$mB1v*f zpm?If3K*WK(ErznxRk=;#S``4z!XRm8xP*YNn-J3e|{Zv<$fLQ{Zhq#PRuPI|6gH_ zNLUkFf%uo%FX{asQ=t7-j}jW$#t2Pq6ND!=2*Q(F1mP&Hfj87Ctb^wiSHSZBOl$zS zR6juqkfZhi0@9%NMS@qTe3~7Ps_Pz@v;LB#5NA7!3nWth0sDM=$pQOmctAF?SJ6EO zIf(eN<4ho_thpSGB^PpM@vo^+3GXxnPLl=#q>^U_(ox4V8yZvvkDTR61@9DkucRMbq4L)iOSK+O zzXJ>x8Bw)d?2TGKuEk6Ks$nuzE!1`NC2q%0B}=v4y~!IXt7%GI_Y;a%>O4lj1MF-= z#pZ6JN?lESLH&A#4cDJ3W*g2Qs#h)5wp*6{x|Y`b23k_LP`A?lW^%`qD0LNe8u^#gd&#xKfv}fLw`Ncu=;~6&{Sy8B%b1XGooJ#dblBN{QPjd?{5Sw;zKl z;(xlR%g=sXx>)?Kf~tu7CrTxeSAlzV)LCe24OJof(LrT|UIJJZlBXb6wbT))Wj$3Q zdhtM|h+g}E3hDhIZ0WCV$DkV7O#rKAI{Lo^Deod9XQq`|O@6+-tafMb^ z`!@YQ?0t7wQ_c3Shyp6bhI9}SL3*zN1O$;HD$=Ei(n9Y&Dov!RC?H7h5;_4wM+5|< zSLwa?&_j|tLBDgpbAIiXfA8~{l{IU<^Uj*td)8h%hU~Ac!@vf|m}IpMGa1GJk!7T* zizeL7;ef)Z{fqX3WZ9uGPMl^xD>f%Xg#`G}Z8$OKV4T(R<>hoZrZK*X1B!E3V~66# zpMF@x9c;A@%lK9mxyl@CU&iDe!}C;*BQ9fX50IQt(T9eg5OIV4MXvHqd9A}_Hsu^p zQ9G^H;r6&sMXo5bbof}6?rrG)q*31@+q!t`a5c5RV(q)qBG=#IBIucl06oKAMRLHo zDb~9+b@Z`aTbd?ox^h|HhKs*n&){M91g&qpYC2v~4^JEyfy3Y5A7Oq@lX4(|m7G~; zr~F5zLWEIs2{?l+yHmS*Q<`0BxjaW1qZKKHGkL-otsWTAO7(rI5c13tcd^`g=(OCk zm^|N?-Ywsrt&$oPt8oI9qLn&Y+|$|N<I2jT$551Wej6P z53O}C7QPGX==HC!FQi2vfA)d7lzatqvD8e>&(iK+B#74%_9TJig8mRY&D7?3 zj~rSlkxu>o#qQexXo{-R1W{RmsQN)vIl6$i81R^ZJgk=5Z0ZE1^_g-1q)0JPn$bOT zzd|^Sk!~v&Z0t972C2=8-Yc|HtYKDfg-a6(hn9 zM1(x8zn3LhQ*M#zxWdv@!=~YIPa0^U!9*xx(J8j@+Q@FZPRQDk z8NAWeM{wX-Wz8SwP@Y|rp7kK;Sh^DT2NngVfhOmPn66EdBq~PmLcAA=i#<@r0rSa=UAI8aLCm@1#kE*K(hU4m?mLpoN-0yPukwWepF2kA@-M zeX1nOG4F^vtnR0)ew}r=NMHgP1b^?Cy^(MVHontzc4|z@3 ziNL#kie9{4ys8%SvuHaTcCyaNb$ljwX4sQ|%{ z+Df3&YKBV#FXOYyspv?|pO$NH#S~SgCFng?0tn@GMUSVY@I0x8fkstypr^Yy;Mj5n zY&GJp@NW5{#XuvazOl^<9=X5{7UB5W-7Gp^{u_N{wbYlE1C8F?1kU$qe@tC!6&T~B zIOhi5?{Q!N5p{r%%lzZ4{n9(I2oulB?Uw(%5oq+|J%}Sd5x_bCOs*D~7WaWE_ZKh? zSOXIY;Lkb+{974xzRcr*wItd0Ai#eJ%&=}P(8zkywPAyaZA92}^(=7iod&b>B51&` z4Sq@L_>P~IT2TA)>kE0x$+Y01K}Nux4Xw-$GNqzri-< zD^Jl%onSYlNE zKO*pq19--NF%EYDqlG-)NQOs>2z>>W(UTCyPr#lfjkh0>0{gNcVEEekUl`XX>3C?R zo+Ng2c|J)2TO40%1%p!S@)$USy16}{f?ABM-<%yP`Xn(KKK9Tj5Tx;4n*YJb&*fQj zXuzs9$K4>|!Kv}XqhdQsd|cgI_%6;yt}q}&cn z?85T8Z3gf0;aK6r$;OA1ZU$of7@G{ABX4^$VEaQr11v!O&*qc`I-_e+hMSMUqHyAE zd8&ZFLf{jEZn+fz|4U<=L7Fbt5mgj^VRUw6bU+UM@~j)>BNmbX{>pdfp>{^$wPj^m zkXuxZS|h}Biv2wgAET+OIYtTNYJ{XS3eWG?W$@>r1RxY+SqIx< z)eK{#{RsyD&jCS1f*?X;5aIs>y7)AM0N3v3F6BxLGdgJPp{{x zzYA>s^>S6{h5t+>r~ zhI8Z#%$a|P@4QBP1O7>ITq|s13?L?@B6#CVrJ~hmum5Q9y^HswC~0rB6xIHCbw8E; z?uQo!#Q!2#{Q-0ZbownCCw0klY)ue_6qN+&xs)y+Hwg#M}A ze-U*w$~he4rFsLmSNEG=9_ywMzsyjRBr&K{xG{DY5}`l%C14wQG4TTU|5h2Q;RQL| zQ|iPEC?^vio+{~U*NwR>{W~s0M_-&%-&UbbF7|JGLYqAKuIGc|BG+0(ZBX;Lrp-Af zp7?IvZ*2F?oue*(a#l1yH=)&UcbXzO$4cT8?on?&%hcCca>jGo{m!(w)Qn!~URnLx zSnlK$wO-kVn%E4#Kp$Z>VluQ5$l!HJm)Z>DWJG4tWgvM1(?#eoVqRP_$JdS`zt_GuTZ8JSvT7l%UcJmyFA z!{Fpk?1x)gx?K=6GVTW^tR-S4fuHx7-tYBIchQ?!IV_UTsMH#%?D&4x`v%3Pd`d#M z^(k)>NebJHt7T@8UD}y3;`daGYvPG@;d9qN!ce(cP zR?`VmsmBQ^%)K|~ZtI<@NP{R`xD)p=Q-^Vfm?Mh#f{{=J7PFG6(W)UNtd|Z^&`8y8 zHKh`7f1J?OceJb0(c{uHQ}YA=`ybhfcb^>!O1NZZ(C^SUBkgel3#3fT2bj49z$&8^YvR& zeHIa%9wnEmeOV)1Q+8Cvpaz3^+Jjxf*scqb(9LX!!uEyS)F>D`pKg;09xK{OSd&6plG7_fkl^=6l zIqcmyJJG++c?*{(qQ!sch6sB*h_LB}7{U|BZKn-8hgr_9`7_#lIG}}jl&DO59h^C;^3Byu;Xe=imP~eZ1u zmE=1Ox-&?JbuLcxFjfx>h`c(f5^ud$%V#k&rIv1 z&bl$6xg>nIhOPS14c&%0<4obMTD#8_^mCNqS$!e+wiX#3`Uzuyl2JpmE zP8ZNGudngQvhwku%ZEP5HPHFrJa&(%Rx+#a8^De97=OPI5S>~pj{@KRZDY*Wx%wl^ z-bYKF;G|&yjO?dVRc%lfyZu`HhgFm03>TZ3ODjwWF_I{eR zvAbLTuu#Q}VvVx$`CgY{{tKjt@GgdR_K9`mFL^zmiB?Msna)g7*$q;!@np9^sUJ^P zBR^YfEE!~Vgq!F3EQ{=B!hkUM<`DQaAFzDRW5B(I4DD7m8`!vq^-O^a@o{OTqE(H{ zWTmfU!De+w61T~6<%P&4sIPH~ag(m;1`RM{;TrtO)>d~hbNyx$r^|-9G%BdA{Ip=T z&Y?%>bknXkX;;zM@95SEpBSqd@a&uK%q4)BNEmqp5yrXCL`oLY}xy=18DyE~pMnS_eSkJ9P z7c?8@8eZKos@+G;#vNAv?20?j_CCbZgNWEKB-Vq7%`c?FgXo@L$gl^IxnIbU2T_n; z2(2ekreBDJCsDIsh@L0Wf?tTIClRrKNUSFjn}0}!C(%9skYP_EbN`SdPog0I5Lz#y zO#cuGFQR7u5IrxV1^*CFFCyZAkXSDwwt$cdFQR(^A;Vro<^dr`UPM6wA++8^nE@dZ z-U-4L@=zSIFiyK~Mo>)aY2U1%nD*1YIYBXW!=Jq#{S-a-;w~$%;=JxE! ztV45q4rCVE+@1@Wg)z71L1y91?fH;d1QzxJ$Sgt&dm&`jSqpm+WEQc7y%;jXpLecc_Gk$sXLHav>%Qze9x}ChNFEwM$G!E=wg$LiRwG%7uh1T$Tz!Le?Qm zwM!xeg(tdF(ueabU-lf(skH>r^@5$20XDE&o8N96$P}571$&o5*TCL>@U2F_nSO;e zIX_fCYv{r#ZQ*>tm4QY*%5a@%z62-eO}y>gjJOM&FF~XE{NEKWD2uq20eof}?s6Y* z7Xkp~zbWVfp@d=zl^Joof_EL3F9=#N_7(QHKVaYtTljxeP>lBY6Q;>&S;rERxPOxr z%uVp$LimqC{cl(fEA9pBFv1hJzI5KSgk*+)`aQ(|y@DE)3ROTQ{r5yD(G_zDtQgFP zL)Q|rAnRrMyJdxM5qMidYVU2*bY`2SZ+#&~rEeWCFq)@&Y}(fdC7|4a(C7wBA2Fje zBi@M@6th4ma?ZQ>tXx0^~DG*uvG)uUlWfX$dE241H~KBGFH$?SyUA%i`Kt zWESirozfKI6+4HIy{}6{A>v9&umN}HcXx0?6cF~41{c0@74oalg3H>q-){%b&;JUm zTiMK%p0`!N5^~6B^F*l3>)oSn$a}m;) zdVMK7AmL~NvyPfFD#7+EPr65^sAgPG)xzhm>Xul^?h-3T84#(Ts0@NbE#aYFUyhK+ z4a-NxJ>Kq4kIH(y*W1%A8TS=?gd)6HEMuE_SAaG_7c#%)W!ep4hvisWZh!1b$xCl> zk_#D*x}}cfTGsa*IB=_+FFa&$X*U&&%JWzS_}?wm(UnEEAc>IS=y|DJb&Lv%aWIo8 z!{eS*f4$JgD<3P9*!}O)yL|0l&l6)~ZY@ZKRK(0nHLKgGq8Mj0r87L#w>4OLtL`0U zM_P^-ANREiZJ78jzle1+eA2Fp>InH7x1?)|$(WaQP{OF96404}86Ff^jeEUSs7x!% zSU2nwDK%6ACNl$=aT?maRhhW#Tzr=(kTkf##?l8#ql_!U3z9JB(AnGz`Jw0{+U}*5 zG#r;8%=muag7Iol-=xsS5M1KRJVTsjNN<&C@v=j#o3)nO15|kX*EY-XLS2M-yQD~t zbf!nMS^we*I35qqIRU%G;yS3FB;fYJU#iR`@MS@8Zr_u(k0)sST2ZhdQjShsyg(MD z)~R^eBi7AUOHCa$;ouKk3zq^xi~)apr2`%Ry4|@^=)de6>*lJprjF|9_=>X}|D`K@ zr(IGqhdj%}+`Rv^@Wv|KGig3PUh_&{RdMn1>)3s7IfQJxBqT>V%Ol9VpG0`$Qoyo* ztedA+?nBgr&aYHf<4d~2^6hdCN@EW}iq3@af~iyNg0ra=C9uI99ZTHEjJS)>!P`|2 z=^tzKfy(A~=LKL?0LGK+g)K;1V<00}oCMj%@TACV4+!*aFIC}3QqcW0_4eq~5yM#t z!UIVo3x!0j7`a!OH2WJ#ANXHZ+Z2PR>EXp`bs#Xd#fFo%5}Z`-mkl0`^v^zWR`Ah| zH1DPqHdJF&)b8^T-gu7C%fA(o%DG$}3yH|fI<(rpQ<1Ws({g3$?Qs5le4iGsfA+Jp z0+~)^P!FYxal2%9?lpLe>C#)zf?J*GoL1jrAu)Mb7ogkED^f(@EvZXykANeC)9QOH zY1I@9Ny^KjgKqm*q`1OcSeBKGS6CIWRB3cI-asy`b*_W;z( zc-IOX|LQ&BdPbcwFbdQNT-<9w3E=}u2s9`m0BW>MY1Kp6^U#yL+AeAc^};49l+%75Q%A3?cyJz}@uG7OHQ*!Plu))#C$Rh?Zl8=s zxVZhmO{fez<|R_Lr{+MhFi>-QeQ9)9bWGH;uUljzPRPpAYrq|2IdK)l*(b6=C%SAE zw;x7_KuAHWu;AoeQAa1E&BAw0_S@-K8m9N)dv11}Rxr15Zv+o&KF7tRb9hbSMJH{O zz#iNxDQ;hlsW;oSMmh-6F^qP)I1R^mldFC~Omv#OE8g2jPPq)!5ETiOC)4azJIHG= z_;wCU{WPdm*{dA$lmcSfw049$!eu3Mt8ij%4{cE9tLOEX4-YU=HK`rR#R1gc#Y~`C z8Tx{#Q016WdGfDZ9KMa+(5y`$obIo|3!uHGiyd1x8SPr#Lr>!2w0QU+9`2TwFt%pc zOxA9@FJU!0=IaMQuKB6!zl|o|DD-6hFakyKWnKayOHgLXR{Jq2x z5OlE(p7*R)fUvb7Ut!2D`v;In<~I;ckJ@YzeI|TcOrBIa34Pa-zN(ML@)6~ye7a{?Qc>&!;3j&3dQXfV_$&YO!hL$Ho=0~XR~>? zbWL+hWR$FAmsPz7bU4>2KIpykypkw9pp5oQyOy^8-8>A@gS`%*GI%H`ZuLNMi-?UP zh6;m?Wd&|w`%56;_iK6I^}X)PJUGeEpyLDZcbB^w32cb#yByN^Bn<%+`hWuSap69< z66P(~|KLJLH8EHS8Gl*~@hvy=ICgB`KA4G}D@0~^JiPaKV!BwXJj3I=Pofei>e2=p z&B=B(Hl~XQfDyR&r;9~?Yq;quySkiL4&$Pe{q^_=8bKa;3z9x1xT0PFFA#^zO=0do zaj;}F|A~X)etY1_wMBhd$?7JUzs#J+<9m-er@*!3udCa?zu)eRl=z@`9;}eMM?&BG zz9+w@JnLID{Kq(|u4Rg607!I;6*r*$mz#U=QN%9z0Aghj+}Z#NfDZYC){BiL{lnYS zXZB|)qcRj5{w$>sf)-4{s0`c+{r%GB0ti5SbFN^rut{R>rT zC>SpaKb`;>Pai*C8-6@|P~7;SUVxzfKj{B#33!RQX2gxib()-N=nFy@yv2>da<=1_ z6A6}6qztV2JXrJLQLyH5_%(L|Yi?uvKY(ljs2zV`kbp_J3^2{(56mcFiX8z=PJl^I zAJXJxVY@}$nT%{Sg#^uCi`b%%{eLoggBvkaJ2*@6cV*yHsja^m*dP-tCb|9#AOl@a zNJJcXn{2=fwZ0t`H|d?50T*`GP#Gxr>Kqmx)*0>9F?1>Ij zgBJQpi)w&lZDU(cC0E4+^BDS2r?!vwsv$Ici*kS$K@_m7(wb4)@pUwJ2$ z0XqxZmLsxuZrxfFnBOj46y1s_m*{|ou z>Sz{t{at$1qjoQ+`I-?-Jof8y-_pn~L)}DO;UAHhaN&SXOl0*&2VDRy5mqsn>^ST) z@c|tx`KG8c{iNMTvAT&L4kbTo-_KaokqN;-0qQq7=eh+s$!7wAWrbSa&-)Re5BYknx3c|8|ic z-#1#TGioSwnarOWlGq%yw`MqiiiMLOi-)HY!X8YYf~9avY_bjC@U+dlWYhghru!1Z z!4-xRMG7eIMGoGHrxU|cXgoLBj*@^v@jojcV4$l{m!C{GF<#+&2^9HA7;I`(1Okg$OkJWyVD@eF;Tb@viXY;?QG`C3qW^REPkc{OK=FU9+}+vya)sfN6l4K( zPX1Dv8np1mB4lw&9DgL-JAzB!FeW&qa7W44SO%DI8#Zq#Qgn)U({(pEJ=jqMeZ!%6 zwL}4^k;fq?*pw5Bv&X@uI$(CcxlWG^NOWJ@+?1eUfgD_^o&pOIh9AVU0UR4T#^d1e zx^cvVoj`C{MGL%ge4k8bG{sQWNzGT)WD|hYSlj=K7=dpiNjIZdk zd77RDB$K=1OM(a9V}|px?miEMNUEgSXwMiXULiZ3-x*BwYH;DMUEPY)39g%N^XSVW z8G!8&0hlKtfK?L!*!W8T)1O4ScrEq*M@YidE?9_v*cDH~;G(w&nlq{(o{e*v(YY;C6-wo~BJq9RWx{1Mq_#f--oy~mY`|Oi7pf8368D5wJRvw?Q(^r=&#_-8Yt0OvJrAsg zFvvyFo8hdmfggOEgG$zuo%gNrtB3a&3&C3wWdy*IorFLX9r#KHtb#Ys_+$@QH&0V# z>FCf#FkY`pLmd;CD;UtzlKNmorRoA-FxBzeTsibCAxyxmVPRNBx?y2DjE@X7!~fFY zDz^@vR$a;fhX+4hm1aKB6vsEg0RZDSlM2p19H;N)``%RXyotUw&XhKANGJMdj6C?| z`%v+ZqRm2ZPX1Ai%Nx)pDb{hm-hv%pucjWfgLO=qdxL7jJ7Tzs+33i7w4LDmRlNHa zC)V;^TdODS#}s2Cd-I^Oej(CF1)iVz>9$H^1DVgS^9!!8ZUQw-_nfhxeZ6ki&zK+X znQ9GPCKBfe@49UJF7n0u6K(5c{fybf+uuFmdSa&PUe%jnk`zH)OLK*Bqr{SW(KK1W z^xI6l2pOR!q^sT15wtT~Y~G30^8HDZUHCdg--ze zmVrY@zy1cS$|=*t=PVt^kWT$A>xWM; z8|d>QPYMcOvtq@X(a6`_ls~n>Ss~}qq(;?f-^s^T0sEnGJT$-% z`p0ng=#Qb~FT^q400x0d`(LJWql9N02g}sV&(yp=nbT#McYAZqYcfh}xbb8J6_cQC z#q*)Z_1@qFtFr&>(5t{d>O7_9Ne1PJ$uUNsFWt(N*Qi?fAZr{Ette=VeExfCLy@LG zDXp`OYhJVNi8*CHe6|%8Lhig39wH~bb#o~BHG&eJV;p?D!%pT&!S|~RxrrP)&)%ZC zc`1K3cO5u3jLb`YB)h;$WEZ!uDFOmi5;TN%Y?ca=?riBf1(wB|7@S?6;SN*2xw-oYesXQ4ftN3Ud08i)OwZcHsJ@OVKLYP1!n(IZW}M(OB2U0N zt}N1wy9TyXk{)k)df};|XD^&BH8$w*(xU^&+?wBNDQ}0}FIKE)(`6W;X>jd({>^6S z?h9f(pl)Q|Cl746-0wtKJy3QaF4G-ASw%JnLD>-zU2_3qKfW*wM#|YdTO+pNWJ7&0 zqj_+e>GeKR1PsdI{feR<{S-e|OLd*h!U?fRQpW&JEU$!})X{nNz$znMRHy(0W}!b}9HK-xT@y9tURB~T23 zEiwVNh>W2lZvps?YA8r6fLZ5yRdeibX0D6lZup!Hn6Hs+RGNX9=XOu)`|leFg4zd= ziV#GKnSrwCwCeO`-OX^ynD3WfI?xxW4_mQ5L&?xCJ+@qGZJ(rf}lWVbf`0% z0#l^JgTZ6a!N^7|4lipJL0J?ACjI5lOJ{)RkDKX2^I4G#CzCThSN6L%A&jg2+7Q?8 zb=d7c9T#vi<2A5SWnh&i3;~-LnDbu-rj-x>;HWPAi$ehS&CK#ecu;#!D}AE%wa=X< z#U%n8Y;g(^{83I2>nN=WisPk~C`W04cq^?W67qAa#q7N}qlgNp#A&>^@rz3!vBAu8 z?&*j28&2Luy3bF@4(rV}J#QlOg|7^Z3UdGU`J zDWSP?$#TchfcBIb9_woiZYITxL*mYJL*hGgL+9esDXT?7=VC~JLPi{y{s~GRr_d}s z#FhILWy0ND!Tiy5teg{#joFTv2>`?0@^4Quy#iw2J}VLuu3ez(T%{}$vV(eFtdtno z-lLqy8mDl?i}&;X;_A_kY`@{d2NYtUV93CnhDAV22297}o%J>3d~fpV!htoEQ%{_R z`uZ{K`eYX`B=`M7=~yj$a0u^0qGLS`mDQxsk2N}>+1XpawEFwn^7{HzG^~~z zKk0e=iq`WG|LEyvsZt#RNX8q@^<73!ghA8eW*&`f(`aO0VcX;IMtq=1JjM*THH)W< zbHD2PXoPnjSm#(hs^vvw$$Zr7E1QcUL+5|0Ig3_zVOy2ykCzUEIgV!c#T4M4m>#9~ z#f(SKh#l8z9eHfyo`)K^%~8i4%h0fCYlla+;35lcr9PS(01w;`H`p2z30x|ZID`Os zJr4SU{xxoJc|&W!4*CL9dL+O$*m^{WO*BLma3X_nnWGH=qUsO29T4O4KW$N9jW}nF zl#aK=@s49WAKpQkNB|tBH$VtYcMo8>p~0It@I1~bFvzWMxEW8H`UboN6$0ZGsbiVE zXcOuKQ|{#{oI^D!*u@d?j98|@Ha<{GnC))j$_)cee&71AJKV+MTPp7>@rW)y>$A5C z&l(?B0#IO}iQ0SK8V7|M_XF4mUPf%gApAM(@UeuJ!f9B2OMm4&;`0WABzmVm~ z-#t6DJM4157_oO!U=tH2YHl}K*Sa+xtVZJ4JU$)EBv5&8<909=av?`PMoooGtzvto ztl`;?JWk11Fw$Gi9tHcX0~x+8NCKm`&;jasjv+>nWQ^Xf3{hY6n350)bg7GxIe7fE zxv2nOml<(1ywir~L%eV2*_cwhTi!I>>`}6&9;6K>^JtX#*$@rxlbVOY`?RNM;2I~$ zcDp4(yq`cW92{b-xjNX$Z=D6MhKPh9-bREYX&gY9PIUk7CIQ~3VX6HUaCf zBsflcr|`p8o9f`NKFrhjoFBUx6KAuc;8j$%gfo#f2|FTv~>=bM@+WkNc%%5-b zn{RN?#CI2KQbOLQGGw)~+gVb2D!CP?e%Kc%_$`2>ZOof1Q=%^aCIr|T?3SND2%P8(UI+dEh%Xd#?tEo0CW3%PI^e$+AFDgG!wIl=o4?sD z|0kjcrB6ObUr;hff4(;RiVYE71nxTX4wJ4d8Sd~5^j0q#z%#wND|OWOQ``y@))n$i zq{c!F8$2th{s}Ch0YD2uJkU%>-6=k%KvAt-{{!ur^E$D)@A{rfH1R#G>#+_<>nI32 zJ$}14iAT=y#`Tv9W9Mbt70gKq3BtZO+%SGldZyr|K64gwG1P=H=1bdoRq8i%TCHZP zoFX9~+GDgvA1+J_1-_EH2IaKPa&n+;sACK%5FS6Z;G;(tt8BrOobK=K;bM=HY>*2! zd0(&KNUBokc@z;ZgDG{o3-5D&8d3P^F3(i{J5n-ZqZmL*iwq+yb9)F^a zi2V{%Lzfr%w!{u&R2pX#+0!F7_`AcWN6mb9n?5)P{M=wgU0*`(M3|J1b8%|_aO1(4 zQcoM}BIRnFK+lWBZLO5s@hUj#K+bVx`ts@A@2`FFdd^oK-4$CzT7Q~J@;H%!9L&s>i%02+ub@Y4qV6)_KM%c#o<+ zXmEX`1|tCSpljOod-#$a6!P*a+Vw~HlKnf=!mxm50lsAC+G-X@!YR2v#!P79?RjpL z)<*T@C-(Kq^8?xi$**6@7%JzNfBItLbXK1Oq@WiEZ}nSft|^n2eGmkN;$`2)+}VEw zc5LLpDcD5(?8vhDy#&RhK+=4iXa{ExK96LP7 zNY8&Z8NvNdnA?ZuLS=@I{+ZFExo!8rwF{q^T!ZB95sw~GGBCIr6w;EE@3zhDk+-W2G+P1mdQG1Ardcc0LXvLYz+L9QB+Y?bnAZ}G9O57*T- z(Gk;Z>~DKC#Z^C@X-KjlEpddGhg#0XACa_pDU|B?2Z1jO+jF%)f%D5(wR5U;zpSh( z`gVScCm)`1+IG7&g;OY5r;w>g!^bXh zyGY97C7CeERj1H<2L;6D^tYDJwAQ2$cty1V>2msoQTI!US5MjM`MPe=CqGE)6DG;J z!tNCoXd&<5anY|w=cZlR)s^jcPqQA4lhcT{qCa)0zTxR(Hz&UGmLRBiZeK3=&TY|) z{E`*^&L*MAOikgunMP@BzC|lF=|G-L)=%(4bl@U}>(@ihB(Wsx zNt%?z#$8v^*Dm)+I0#!i@(3zLTYz-?=}~$i#T7&LXWSoMeW*oGAlgRUqE&AAbhN+VQVcznZu2egmn)5p24wm#`FYEA zrGE&$j+^sKqp^*0au~cgnd0D}-4I*Fjx^!nRkj_H#tUX3bmFL3Md58BALs@a6k5pW zwo_&U!#o~2He}$jPKF;x3s?axrV}7a=KDk2tHtaJS-U};^>==YduWIwk-tR@Y^;SdkJKc{GIo*hxWSvK{^79M;CL_ zk0eOn#fQ%yGFp+a3$RlNpSeo&F^Kl`Thdl}G6Dsnx#U1R4MFKYv?n-w zYL1}%xy?wWIQgiBo!n=-duV(q|W%AgngBbf`a(!USv=Z;rYE5LOO!8=-F3c zFJJp?*D31sdUrIxydwOAfATJwW9Z^t2jhZdB5`)>ELnoB)qz9SkmDz!nbL7B)58GI6@cg0F^OWlN#{t z8CKUtYeF}Q_j(7$?QB;1WT0ycaIyj4?%_^-^h*SV9{L@ELLdDG5ut|;_-Mpbwvkw{ zmxfT+L-!5L!G#CDAgU35hygwGT=iPf;eB;|bST2;t%r~EP6@(17xNa;GHh*AIG>w4 z@EXynhyH@-%-lZ|Mq|%Hqv1Z?!$ABR&e!+is5V1;Hu+*rp}d*Cn{;~^^(7qaUH;0R zbiNKc1Cg(Xj&}|fMEkZ44|4cy?4Wm=*M?=WimBq*jjEKN<(A^?=Ff1P3wj|em1;FpSkX?Wj=jy`IuX2i*PN?Eu|7`|G$r@gje$LPb#h@o>8 z=^Rma!&O)`!*1+GdP!kLY;mSX9&K&8HiNUtLPTFo^}RkG;YNDhH^X;g*%lE9EN&c_ z_i<}38<|)bzsV@Bb7F%fTV@++&Aox6+cU$!=!}|nV%0OTxX(gF);i<3&IkuyBLucK zjI%SXa1L3yb2w3i!`VQ!;Rb5?)n*fAP^=uSjA4=Mv$YjxTYX%uiOtHO=oQ~_oSlAU zWPx_CSmEycM7op5m@gJ1q>h^c)%D>Z#qq*itu8JNvuA|uEyFHvq5COtg^(k{rHHkc z>Q6n_rUlEwJ9&6AMQsz~4I_NkKBG9~EEByP z!H8Z?=Y4wIisEIcy^K37mq9vWb{a!g5RoI9=7nuW64joLn1gAjW^LZU-eT?Pd>Ia$ zr?t4x-277544wN%bD|{DVQr^hf5NL?KGEx_M}&;N+7#*Qh+1CyR15{fA-AT9q_%&} z&^4QDmp(dTuW8;2tE_6Ntle7<5MqST=TG&c=Qomfdyi+m|Kd|aSq2w8xO%|SS`3S5=9@ygvsnnVv7uq z$G55(7NX*3LR`U9RyS;Jj)vomX^pUK%@g6C{pIf6SnFo54$oN|$!V1>>vhZH>W#yN zDIubP@Y+IO>xIoCgWz8GMqAhf>L9BTcdC7B-|-miypjFed&ac9-alDpzlH4WQ?{jZ z$MK8^59fUkoG99p>m%)K(nW<=FIQkzI0MHDpGp?uYAsTCsJIsrN)x|?^-0nt^Ny?} zmc2i8^iCYv!$kSO#%q`uFx|Lcg=H&VW8?b)?z1RCG2A{5_xV({>fk(j%S}3QaQ?un ze*1W2XK-M`b{K7UX|!C0_n@G9|As0b6D-Odt=TAPD@Yu&JWf~n>54NEsMY&knE*h zYIwUHY<|a&uk|O zNg+mb)?c~vXslVwEUPApA2|xole-!k9HY{h!z{(kWf)ZVUG{3#hxf<38hv9)EoX4* z86@$TQ94I4&#{h;*utD<%;TR}RI2UpRxNna6Am}4XJ3?SJq^?`3Cu@@q@$#-!)q%T#Bl0H1d|f0vr>4g81K_m1v+8hK9bzA&L#_=2wlt z|Es@gv_jo}TjV&Vbd}&JmvqA`JwnP)@^#o!9K!gEwV|^CC+SWZ`e&`1pohbAO%4-& zr-;BWPX2xzA3c6b(xGc74*W2&mZdO8t%S2O5wA)p8f+bn^>3Z_JT2BXT(z;qUDm93 zoO3jr9#G!-&O5{86ZOwdL3Qgg1+9hFMQw@(#v64;u`4#1pb7M_HgN~0ynJ{I`+kiW zxqX;i=aoziwy^ffoYbVg^%tHEhb;xi2BJNoy*4^4%hhAh!47h=H>pDH1ZXLfY@0crX zpK#}mk^g&A2zQt247qe7>xDXg)AbTEsHF(}#q3vt7|o(ap0FYH$a1yQ7>HyV@`sQK4_-8-wYF=F*7SVy9NNGl93eD|~SsWf^P-3`A>U#9x5i*J=a zKgvu;ly+;oaeLEvFC?_x9knE28tWMKIP+8LoNAcHqGF@>h@9^D@!<^-Qvt5fuUDrZ z!S#6Ub3TlpPcv9`XHE%w=jOi@nOc)oi4D)AZH5VBSgnsjBzG3Rx3brcPP(aV#BN^$zW@6#Sy~?^%UY;pz-1g1T^1ah>zu6Y$ z(|pRQ5*Gon>`Ha?0wreYbPgX5<`Gf9fBVj)&YZ3P*0RCaOPFgxLZJ5XD=`m;YPGa6?Izw9A^$W%e`hnX4&1SQ=BO*BrT=ap9BojxA4wGaLR5Vh-#=;q}e05y&aPcqadgjwu$h%?Uflo;ri+1X#CH-dY7Cj(i3~AHGGVbhp zwlc?zH(;jbCXbqF%^Kiw0YZwD>5R5!)3ZArjQ zTN{TH?YDccmP;QV*0);3r`};mH$M1US`%p|0sem;HUFHN#rGEX`; zT87WPmZA!9xRYOYS~c*p*3hK3GjEOxjtjLDh8x=$FNGPwwysnv}wtBCyC;tYPr8<;$p3P9IiqlxGui82B zGWh8X0rjfG`#ldMLx)~L64z2nb4YATYJFb}8<|yxnPb}aSL&lCesUVG$loY>&U!Uy zi+ldsSALw;yb0OB~gi=wz|?~mc(t%J9>TzML&Xl&CIyVTJB3@ zA=yP97c)3G$yjl7;*@8+>D0&}QdHdMLQeyAB;gKuSEV=3N6D=?mm0++S3#WRhl+o< ze)cE^g}#nCVsfEAG~!p}4p`1F;IX-4rw1oayP&E!_yW&n z1)(hDj~Ew;JD37?*pd>(VWd4XcdEb05G?WDVQaRKsna?BEKIZk(M@@WeId$en6i4* z>p>>tywh5GLDhS1G~=A_rvamm7zD*e>?5mhs(ES$Bk_b3@B%Ar(Vo2Uj=H&5hUUVA zp;OV%(Dcgw-gD9Ev)=bVTp@{9H!(WnNfl^R+T)XZX0*BIvpmDP);D%pm+wilngx$_ z)V4Sm&%WQ5F{8vS&*MH{a2rrMFsdGicw}v!83Kjwguo}X_tQTfU>GsHf}g#wQt7L| zwk8?)EpnkEXjlMxiI9n`&8d%2qtUA$Ubc4$7k>W*TcHwuL<=e0s`gUU^?r;T1gFII4G zT#i(C2bBh3++GPUR$vh}gCBj^a$s#q^BK<6Zp4C#H~cREn6GT*DxPaywp zAkXQHTDlr($p%q;*hscku*V{sI;E9jkk<1$Fr$h4ZD=JGntXaY^hSBPN5jP+#CcRu z__yA-NybbHuSu*QpCS0w&-JXx@RF*)FV{;UE^m#eYWB~*cUQi2a}|;|glnc;s@2_S zPO#H7R2&{Tx)?{MoSQicH{qyeF&lv^uaNw5??R$tX)l2v8|HC4Z55Kl7BagX{wViB zA^UpDfWAbtyh`DBS%vZkUyOB@iX`t>GEK6_7v62;K97h+GAogk!}j?;{vx{BsxCYH zMdX5M^>qB@9%0)zDRJt@gU{ZWfG^@01#|7$9X?G!sX$oJlD{6I<2!7njH;}qnBkwf zp5JbgmSxL1FD;yq_I&<1+jv+kIkc;}n}^ore8lWk>2^m*=$j{nkDjx79vGSY2zoW~$#Y219dCe8lJ=xaU{&j$KV?yt#D#>hszBQLysGhnkS*!KZzr8-u;e6Hc~NM!D|C>b9I z;o0wMlnS=38n(2vpKZI?u$@ZG_Pqg(pLx`gmTw->a9sc8{OFMg=H%IHv}xH(`SvAGpd_2j?&C(e?bmt|_q`5jt&$))SArsXk%H&{#x;-2dzoAu7fnLf9_4;ieFK zr5F}n)tl*F$4$_6j)IQJ;PBp$HI==@h$ph=Xp|qz37+~ajZ)!#S(0Pc<+GLrR(s@beA9^7=eR0yHL#VL%dlRe55nG^sJS*k2&U5Ml+Qt=PoWZ zv6F`sGMa66OZSn9K10*#O+Ip39#&(Iw|Hq6OEY$s^!$Y`vRzGQ_9=(>v0Ty`7wek| zt~>(Iyu%HxlwaOc3Y4QbH|2O&M#(s4Z=<}vl9$NMK=DZJl>A(uQ`Dv28CL87C4X$$ zLRZ`Ker74xHp%bihO((Dscg}v^Mu*51ExY}%F-Wsg?dh2c#{3USbGnsrkZYVTu?xy zDotusqzfoWFQJ3di=ebv=)EHX2_20vqgjY5X^B}j{XIZ8J!bBmv&!pxe62`dLNgTBkKiYv?3kSvaNq-0Cq3=Xgg}ar|6cDG#FJzfb76a*hnIx?qEy zcjN&TZ%qx52+OU%{#AJafRL@=B2sZlJJ*;SicPGT9eL?LzolZyD|tV10q@zvEyHnk zT8Re?2FD`Q)wqv!XG6qlbMZPCZUno?JAL4lEr9i%UAdt1COHhlO-rEbQ5o5Xy!Thw zZ6IWij>q!PxyY*^H*_&D3Y&zBj(}saOU~vH-7J)A68z*|J3OT4Sg`lR`QA)y119OW zoz>7dzp9FDW4BND7g9dB<nvhI;j{&+}9 zn2H!!x?x-PXsJb*-T;g2VMy*;!{a3p+IGaM0JlREkRr^Y; z%Bk;p(1@^mSmiL?=FRpY(ckB}pWV*t5r`r+CSAR5k#a@ZtaT$!obZWiHn|%8HHuc5 zH)1ZNwuBZ^!s9{hGci#fqLMhNzkWv7AvaH8@t`5OHu0PGAAq;_>{&`YZ6NO+Nbp}J z*q69=YH+V{Af}Xu6#pUb%ip0dd2h$hqJuZBh6A0P6GnZnEtuZekta6ACQH3C(@&eK z=oX;Ks7aUnt#NHN_T@(DtF&NO==5~QT}y9*aVug9Sa)M+?4x6S4v+oV_UJ{NuVmp;m=F0*Z3?%9>;e?R;4~AlBfQiAN00z7GNXIotOQ(Ls5{3 zYQ^lDeC(q1<7S@B@yww5x6gFsgX^4y>`x%@`wJOQ*4Gj~a{5$OCQhN(F^iZUoDmYE zeF0m=6|ZO9XX7Tt!NGH^jO%suGqn$o){wL@y}|+KDp@)LdhT`=3+|dA5mv zAgHNqaNNE}uF(Z%W?1&RO4{JIQ7{ek{?QqzQGphlzQBDXCMS~hJwACMKP>(H8^sYQ z_abr}5`QMBhf|ip2!?F~T`$N!pS5$vQQSPDqIt9l=pLA+(m69SJts=9&7>WMu*q#_ zsee5UIL#+op-M#o4znzeKpMoru2{(0_bjBzOqY51S#{$4dfBY5X8k=VkzVLb$Z55s z3U9C1`8Notmt11n)V9)S}~K&GH< ztyaSid6m3AJYjF!tUY?#^=Q^f`p(A&bD+@HW@gE*WbK#!hMV>edK+HOv-a{wHK;5~ z*q5h69xYO}^tk@wDPh&&&x1yMH38U-ZvQSbS3S3*0$SxQOw5(_1wW^I{cPpcvv*gY zwV&U`(KVkNsogEHGNar)cmmaKv}GMf3TsEYgEoNa{_c+|XCFYoExzAMz_5b&i@{<; zckV?%jpzlf=%`5Q&9c7TlaZq-Uju{sR(P@B)cRz@F4;(fPuV;gjNDk!NzsBA{7S`I z4o*~8luv(?uuHzJ1=RkURzqV2Bl#WE06;Mf1Y=uPf#YxLhVC=rZuOJu6zWbqd;S0AC}sO!k$1Dd=$J5Nut_U-3SpM`n?cZA)Kr)Ii~ja%4`qGV2GgoY?~ zq~u}l!7nl)?_xvARKSi@f7oh+7dhDFH5+XrXPKPX=q;CxMSo22HMzNX;h)gyr?2@)cW=(>6YUbH zn@V^t`HSS;xoz^rB& z?t+t_M=SpH6S%&Fv>&D+@I0?O^Zmr3c;|v57x$9w1%%Qyk`T2~Ph#YOb$hVwOzMB3 zrv!pLSvo^b^Dea_DqgNnH2IVj-2R!dB5}VP3)D^nnxV7QYr1NV%dQOcB;N1%{biz9cRJV_ow`d&rclO; zTS>F8lFETrxXs16d+N-qBNZQY;{C4J``Xu8=?KpRg zQtq<{0jl5QnAm)V3bFpKL%9PR4)w3jtt@tnm}f>tbg$SnZ4n<=o79ra3eL4Omvnn| zZtd39mv)yHPHi{dnWi*@^vc31-uRviTt7Q&V0GHcw*;K+?!1A=R8}~P@?D=LY8^a& zy&&@K#Z>!`W0MEdL{YoAhf&iH?O&2*W@KelO20ekZzM_V zcbY5?ZoO*0)~uwHnb|aedi;)YjV`g)qlvJYV=cw!W}%eUCx$B_Pu{{kri+mD-DEkoNYxn8;Udh4$A6bvAymxESFn4-knYObTH=Ps zv$bD0&kK8YWI5V;ulC)f&J+^PH?Wf-5+)AVuNsTYmsHEJ(l6>9-?2`Xa4aa#BB0K! zjHIoOG>D)3agU3Tp)acAg;O>Q!E*8#T~dtE3SCl?QObpf&CqR~n5FW9_B_-*Ut2i| z!nR2IL?dHC<7}f_<_=RtTT0mvX>vj{u3x(HxZ6~@Zxi9Oo7=M8oK1OqsgzLF&@aFb zTxt1?>rsOV_rE(bbK?)x=)m&?@yrm$t8#CZn@%c*1t>4`KttUk!X$5U51ez;csUcU zUB9lK%F&x%Aftmn%1IJrDHSK0mq9t=QF>B0FROzgy`0nV`y?OJ{*e4C$RZp6T9U#dJ@_w35D#D5XAN^Zlc(@M!)bH51~nb~fUbSz0%$ zm#(`vFlQXnM4S9qyPuKi7zfM{dhq|?nXsa~y*7seJKgtZ4n(N9Qajxz>3-&{WhUtB z-f*=3EPejH566a6M^acysnMRuy;zgXVODmxYhjoNzDsup_ep(~_A}bQFx1A%=k~J3 z%xy2UotIf3hi7@x?^g~fTCUjSbFi*E;4*f*F#*YBpP+OcUJ zQd_rgGTpNk2Y$hlr@-RDVQH{O>Vo=pDeqEZ8Y5|TRc3`A&RhGt>xPx#j~iSf!eLXo zpJ|^b(~|PkBh%97rH8O)PoFbp3J<%2iw|!WBs_dUzC@`X;qiw(rs1PAVG8C z25N-Lp7MmJzhAT+N!;74ytaAu&&7@3r$>}m9$qH|jmLLYV{y94^6ec@-Gbw(Q5;U+ zo=*GS=%ptNH~zV<_(A=!)i1yzP^vS4zO;mmG;mHT)lzDbbwOe2foV!xvdN(>D7z_GSsrK$oi|@#7~G__MSBL((Q-jibfXMu7|E+ zA1siNC)yp2A0>FKiF3w!fGVz|CWEb-K5*VOuJgd3+zR~EwBGl5;DvkH$&2aXdii&?K?^V8w7T7j=^98Ko#&EAV^T1cv8PVUNo`bIrgwCEKD zn`2R2wSP&VO|jflA0wUuvN`$Q_E1G?Q#LSDh8QCyP%}g9MQU+;J=4HMQoV7@y@x_Z z?Rvk5U`2!O@dYbix@oA}U`d@;^4dm?%tW%4G`87Lwl*l<>_bEkvYfrMjT_46X zRqjFI{*j-WFvy|8Zw0KHvyPxTQE+wMtgaELOn*Fq{y%yY7s>v z=nRaAG>61w&Kut?qVl<}wXz=4859Vo>yTY*9pT$9T{JxT$ZE%R_m_?oowxq)62i(2 z57TiJ%h*JUuCu%2aT?~9y)d5Iu3n4Xa+yt4BE-v{@4qpe*L0@SqDy(33qfizQd6_7c}55dNFuJ5HBmY1-zUS?4- zk3AsACmEa=YIs_uyrdP_NZ!P=Zx{$6t{U+M>-6Wh9L{aYr?BuQ1`A0TaH?9l>2Q)< zmZF7hc@tGq9w$HP*I=?7jeDY>B29b#^~aIqbw@gJF=PKisIvq93A1WS6EDpd4Gqf# zlNKh+Abyahr2?^TvY0_ZmgiAq23Xfmu*x6E_i*-}i_FF662gr;ezlQtw?i&H9e8PG z;h<_5tXoR>Mb@!A{$P2dS9?&3_<~rLc+I)uR3sPWby)r3nXgLZWP|x-llD?Jp7?~} zo9X0`$WB68?XZ>jeb-o(!zS{FBV~tjB9mR zP8nlI3I0e`p+kjD>Ef}4O{T8?iyDHdeL7?zaMLf2@bMbwxhA*23KCzaOm< zyRxP?EM`uzW5}xIbWF`-pF#siEx(RhextG&HVmX9lI0!d9yWMcAg3D`!-r9^e=trc z@3L(oU!|O_n_VcEH3t^I%QgqDTeZfE#DeFXRB@dL!n(`_5ZcR5t5AJtpl*HM2K>w9##eiT*5FeThM zD7eEXQzOs+Or~bSkxgHPkKyKJ{zlEcuaR>l_;#h?yU{y(>mwR%ba6*@7_O1blKuBzc>jCN}lnOKV7pg@CB{a^TGLBZ` zNki@eUMnB)zf`K73ZPExa6egn|Kc-LX@#v}{;8@h$NWo7+cB>CF&7MP#lNyZ0^nDMjBp@#ikc`^@N~>)vs#{L>BWY7Gyoq~ z3f?HBcQv_7#cmgjQ`OoPpt!+%MG3lXTjIwopZA^00+O*!dY2QwFY4`)Y7Tw8qxWh? zjE$prz>O;-Yx0@kokNdoLOG8)q*Ub@csiM=Np0s=fc3(k=f=6|nr`V2sYA=!h?1D( z6v{2ee+#9p5(-!+)ak9c&LA)aSy6GKW09K_dGE&H_wZBnA+J+cA%CwhHTjY) zLNs;}C6jF8(DEW#-qYM9nZIdoel%TCXW?^(VzHnz=aa3aY{~04jJz7BgvCrFDBH|p zRvKdO+kG6-VYThIF%NHE=J0gUVZ9d0$E?-l)~;zyvMlQ@yL*IK=dt-3Q(cg~){S1$ zTRUSk)vG%zx;|=rM0xiRSTH7^QhEXods)AvQPmAcy z4e(9)7+f5iFYifBE0Fy2^Y|(>x02fy{fMrV(crV>q?X=dpYLQsQTk;=C|XW!jiWT}R*Vd|jds<->F)*d4Gl^4+tUj|YgLZyvCV042qp#0d+2 z$9bqnFMg(f`}ocfMG*07S?hKDt3pux-HQxd00~$)Iy^=lY>zHnm^YjhOaY;LXN{O+ zf6R=3ON%sU4ax>^bUnX#6%(%6;-$dWz2?v{Vs$Ta1B{#PXy*j~=&Jn&*W|2oPMJ2i zCHXxmL`yUg{GPJA)8d|RRi*=lx@_4SK=1@O+zo+W)(&L%XPwbui8=S*WJW}Z(qw5i4c@m%d?}n# z(Q6_6Vdnm<#=3*hoW@6oifN5Whl*K^pEIit!cS)I&uDO`#SK~nf1tqOSEj(>a_7HC z%*oM)F3ZMw>p<<~KYEA=l|J^iYLE^gC7ZkU(P6g9HsE>Dbeyp=18|Cz$!tklr~X zM))_>0Md0qe$FwG^*=RPw!r;b;1b29=@`l55{NZ(8+g&N=ic^oZIOS* z-zJRbj>$yJPk&a7VRe~1sJrFa?)LoDcjspq$&>$VI&2Z&Q-5~S=>uXp$?KzhdkICD zl_tR$jNXL5>moz9f8kaO?Xl4?NdKJfzku^U`&@=(sK>B~Q7e_LuxnUV$eLC}bo$<= zCcjSoEgDHx`~|;=uaZ5x4gSvg<-_6?3X#-RXI@DEnsWlI5X%pRJt@t1t2Qm=tWWKm zaH~&Uwc|DFU$aXnE;Qwb7XOp69{;W(m00*`nOM`sfjSFl+2eyiUL_L0y7#7N!Q9C1 zD65wDXQ{kxEwN#WO@V^Ok%dvs0^ebo(Ud{PK*(KO8@>lK90;aE{)fT`2oG))4LyY( z2xdV3he9ai=m^Y>JG%cy48O5kZ-*NvJ?BS_2iC7Ig^H}X5zo!AF|%I+n@$C3zw$j| z$M`+Up4=Xsmk74HZ5K8&x_QIw$yB3A3XvFkZ z;j{Py5b*y^{ z9o;nmymr5EJgx184Wet8;hZ?p4R{Qs5$pc;o)>m*EvudKI|43%W6^rgit|EmJe1!# zt?dUI;ofw^%r5GU0a6#c2SXD_(x^k8VJT%!@9?I*i- zXzO|E*S9f-_FFlu-*#Wvmtia_2;15W+xjqs$Mvw^Pcnz@W|+VekHo9l3QS@XrL+1D zJ?eokV%<007r@)AEs!T0$0pVb4Nh(g3#*c1^%o7jYkN+q8J^pklC>>(Fcy;%liZ%9 z+MI9jJl36J**ZS|BzQiFsXw2b0i0I@56WB0+03?IZM43W30og_aknW4h8=giTu}J2 z%>vrN0Ne^(-M~&sar7FZ*VvIJ9qb-muje;A~)TL zRLEXceR5j(@#d~H{n#4O4qco1ql_V%tOCDGCrCi0f;eA(zsx7zkiyrJxF1g+!B5!5 zxB%<3U+UNQy`*<)Row?)ZNKf={E{xo!b;`7J93!ZK7fjYsiNIa#n}!{xFM8e-R)rC zDmcqtGzpFk-$9%nU`>$uvgVo#{C)RA)bD!ih|pV=VZXKSa8$DTMu*O*TX`3=e^Yf8SaXo3b=S zd!Z2yq`{`NWo^FK3|5V}2d7KKjX7ONCC?TBxmGi#!f9niC ztpsX?L-3jY2ju^wnged=V88qxYsrHbagBD!EYh@X|MSY3+P&eSh=Xk)>hyRQ1B62^ z&NpI#7iVb15%4+=Y3VVo7hdwJ3zEUrpx?0R!D9PkygL*^%rrIatdKnMh zsslYf!6~nz#E#PY=Ay6e>+UwsUsWGjRNrmh6D(kdD54w9E{N-y`X+YWl=}s%u?=RW ze~UyE+#>;QyQSF#985a3{S$YL6zlQUY+?>Ool>I7zs0}Fp5L9Od>3lqTGTPiNioZ( z$;+q8gJrQaA&bw2W%s0GK;s&Q`(oY{saAupXD{~Xa&1LTF$;V>6Z5j`q3w(!C$X5| zcE&t>$&6CmLs!y6cdSG(oabpcPoM7C=fRJ&4)vlYRWo{N{8Ltuq9%5gYqJg`R_cy5 zrfK}M4uyjs?JJej_^W5!9BXVU^F&Qb2k9Ma#;y9RXa2+47z99)(asoWZQNI`ncP@V zi!Ygw-K$W}oa)9nf4L$`_oK#N!YrF?vu*R1*;A;N(XXcsZVh3jf1kFk%e+-<)&D+u zyEM=&@GSiK^Oj02$cg1LYkB81<~FA9sd%e0joh zFQk5ty&tQ>=nhKsFZltvq;ZeELkc+17>3IWO^;c5`~&1GZ9lXsE@nakwWa3mADki3 zCTgv5ghQZp!82bd6`845i%)|3YT55Jv+UgA zvrG)g7XF&yt{bsi{OBhUxx{fYt>$4p!TU!+`hr!pQ-9$&*^}m_aWeiR1wBFWBL!by z%|EE#9QTJl%KA5b{{KfWsge(2qPJ^ef*GAQ4n+vSUH)V=#($ zx_BS&0(}W;(?&oa6KlO09(eTR&C+Ay!Rs_-LCrS?D-)84v|bEjdEon)R8TY2za420 z9`sK5eN9VySeo;X_Av3jWuQL&WBih+*p~Gvzk58P%X+sVb2vpF-{lI1L0tSev6kbo zG{qCgrE%iHsrXSk0kaWlmOqJh2e15<@RX)Ftb_@+Yufqol}VSgl+h#e>9?r4pU<%P zOG|8xI~^qSoNf?w^Zz-NJWy?-J=UuVAVTR)tB(-U-=_||db3I{WF^l+Fwg2c9sE9q zv-)MwO1wpEF1>~hHf|?;Jcu;nB)&QJVjPCx+6Fi6%}t&UHo(kJ<|bucoV+!g0qx>o zjb~FySlvb=Zo#lMhITtk$gb7GJ2OQ3R+MRmE+57|+4G>G22eQNL&scQ0Xt6i6fCpH z)XdZ#wNxjS=*`6QN!gvSIUajA!%B9_418DZVrS3Q(%j2sNiOAp)f;iMGEdVED`W*r zM7|h=t`^13`m3+{eth_r*kWr)nxzQoyPU0bPMN3QCc5FrNzHqjg} zn1Qjb8{gBCXF23)ap9U@7Zj6^ljbw^>_Ob^oU5;B>`tELS#s2V8^_=3my`NThs-t` z+P>*^e9%0H?*F4OW-_&P>@DH{55=~kt#|LP0A8WKt%$^dapSm8z2&*6Z@E5w?Vdtd z8)=M9=7CEFxiHg^P-=m+DOdZ4uF4PVJXBM?Cg=bG!4PGc$|=CIWN( zXTx>iKx|j+emm9%``;F6!9qY0@C{%}785WuYd||Xt4({opi6t1>rfw2u%C!7MCqUQ zV#iN;uohrDtkbF4VPiC$0%i}cMKvya4P|JZAG%fVh_o%3gBfdAuJ9g z4*Mav%J5Tgp9~%PPil3n9(WUb3zh_ugmnn6L4OLO)X{l||DcvSWks`Yc<)OcNc}`E zd9Qk>!&{L}P^zqxjN>63=JgpGmDxNNsl%XxZ4&#nLJB1Vw80fUfbAY0i}vp!LjsE)PeoR)M+(#7A^9BS5tu5VXoj{c#m^Bd`awpc|+_p8ry~b z2Q@#K59SGug!egTz*lMyOg3syOR$sZe^8rYOR=Sgji+X4vkh-l<3Zz3!PD5AN>?;2}=Oo z2o`V3*;nC!Re*X0iIiAsbf!O#HShYGoaEytU~b=d>CsT@@4UT8d+;Zx)=3T0abXT+ z4ivm$=kd;bc1V5O=gBMTaDLjFPpe|b%;>zKU*Z8dSGw-QzQcP2L#0{zbhzInz^9#8 zp+NvjJMOQKdYyN~4%Gkh5${D#BYOmiBw2pwTtVE2y@9dA{!W#MjX96O>g~7ZL~Wmd zd{BdX#$6MTE;!QgL+?V=Hr7{}&|MzU@Yg#W3KN0CzcgOyzPb@}LqDCfJ!qPir6XV5 zpOj2e-(@&uga>^t;4gj(!=fq*or1w_EY%)l)R#)SwN&7;#5Jl(*#zT|gBW zJneR(oD)0x_I{s0*4aeq6Q(?8EAZwr)#;yS*GUPc{{6gTQ2?4b^}ER zV|VGRJ3ptrqOZDkHQF=17bZ482^2@Hh){Jf@|EQQtk>5g1_tTIq7K8dY71lBQy+pq z&NRI#9}7VpT5Z2CAVpZG;H1K2G;af)OJn@;=EaYaSM1tOeGWZo$MK{Z$__@L^PF5d z>X4pzB`T{{oZ1@Ol!wo;;Rtvy3|>6AG#Q?`S`}6H7;KEdL|$Q8@@IST@F4Mvs`gX} z%Due0(Z22UMZSKlY#AwHW67=?udUSh!PX3-=^ARC5-7)O%P$j!JKp(uDiLxSotgxn zO%dNBFeL_`!o3II!l9hsh=C-xc%C)6=SYL>416)OCBtNcRXZ+M5h|avK^ChiU^%w%9HIL>#WOv@@^#nf<)09{wIB8X-1?$+*sNCm zq*sE%N10INyLqiEZ*cdz%1qC8xR2#Kk7lb1t3T%k zSZP1X`J_U(>Lx_nzr(|FLseoR^R>J#sJ++7b09OyREybD$TuS3p3bAnf;*@R{>bs4 zJ3MMl4#PsZc=1{P`?k2Zhi?rnOpaTkcG5nGePY{q)30VoA^UKBlG1NA$|2v&N;{Bo zV03zaNJp)IT)|k;niIqMc&nW)ytn>Cbi>E6QIq_SiwO-a&3t#ptN;$T`BPf@Tcp({)VzpXiF6~W6_FZ!7!9cF`7;E^4 z;d-lARc*3iZE7kv*i)YPJd~iMfeB}+@LjRs&bG)6NJvQ{Nklw^V+U$RZV)lv;AiBi zvf#9Q>Cci6m7aPKWvJ7m6W6OI&ne8K2t_>H-J9|M)NAkktL@yY6nnd5f7taCX19rb zaJ3rawhWd^$ua$>aIaUOddOh&xIZ`L6<9Bio59Q z?xnB5(C-TOv8r|1t~B%aO~=KrT8F4JSucNcY3v$wsdRaPU`eOZIs~;ro?xLOI1Vhd z1M=d(6pe9GT>s1}Xo|8fDQl6$E$<$LLrG#5>ki|dSADE)$_sd>y&gBARcU%OE>&Sa zc!u3LClhd6BP$(~aRS6KT6o4hpy<2a`;J1N*iyKnKIV+rQpwG;cHp-qS;bmQ4?&75 zCyZa*8XImw@S^TeG;Z(xgGC?aI1Y==pC+K1SEakIaN-=ncGEczu9pUp?V|41uM8pw zMSTli8$?dkpuuWPW?TuUx_a^{BAMmszz>D_CsN)e?i% zk5PNJb2k}lSF44Ri7n?7M&PZCaV0&IQh=*M6@Xg7v&R(xB=Hgp{KVqE>>|aF_fhHH zjRd#jcYBU8jTAjX6@IF2a)xoqg6JwGzGODP)B%~_7FBw-D`R06kA(_Fg{&+@x3a&x z6*Wit3tPDjO}Z|byxv+ZqcIJ>mWVM<&nT+g_%6%4yi>J6(J2>FZW93@*7j#KSH~>a zceId~<;~eI_)yz>x7A}B2hA};3Keio{|QRJ``*}#MmF1U=pEcGd37F}DneESlTg+4lT=9%*F zh|f}_-Oc-rC=V2FV~nnJF%&O$6`p@E|IL;1C+Wsxr$7^Y7ya4pv)t5$pX0%IQAd|F zm$WXTx;v)Bb=Mj2Tm33gN@_#E{m<1sqND#ymi^fiA!!8aE=Kzq4(*i8|{Fh-1W|=<~4)nh` z>dpc-`(uvh3UKoz7bZYN8WJaoUk@XGw}H)lSIK;}!j1T6xz%B6rOU_U)Tw!LvC5~Y zRCkvc&-AHz!rCUj468Nid68Gyu6*--pAYQu<90Ebvcip^RMv?&I?_eg#J<=xNFDi9 z%%q;x$vS#V1iCB~IaF3pXq0s;q7B{MSx;g=P$q%h;57UQaz7nnoP37|?V4`iw}TKi zT)lmlJYqkqxSjToB&jfh-9Tj(vxEMK4Nr^FLkOU^V_=T!=@5~jKghMaa4xE|iyZjN?2>*!hKKW{H2@0RDRfH#=^+!>%EPneSsRpU{L*!lvje!Kdh!?^J zelt*ompwVRRED(FG|_K5D?`|bpGW?#{S4gDwvWFs{Jk-5%RdT_xbUNR_Xnl-%Kp%P zmQLO~FZtCsl{aod2TVCnHllB_)x65H>ul(oY}5}H21C?Q&(3NIlh=?_pQ{AY-X{mT~m2QvNg%Xhe%bBedh|CbFptOdm)qq^B!m$o-aTbXDxgREl*r_sAADW&IZd}1-8)^R)?eIfFL6j_ zfj?Ll;31y*K5&cCqVrVJ>4gHK@qi6e9oTuI)<3@>)H`gaeTm+7DZZ)QdmrnEU@Q;C zfA%zXw`@-_W_6v(IHmi@QZr<-c8@&zRd3r$Ir=-B-Y>UWQsPUn@wQsA?7TsDqRR`A zsvQ%iKmN!iOogPRo2%i(RMubi_x$+WiB=dAND6)Do|^w1)O=9r?x!MnI({UarPXbA z_9CSJOmcQ~Jp62rxkazK(Ak5Mb8XHbjgs@I0W#$OD-;HOcbE>#ZyCW1_Sed$QZAkC zkqDNN90v>g_Z(jF)B{MiXKfH{<(`QjnhsqZe{$q%u^>%VPBnXwzKr(pPd5N~pG$(r zpTn$w@65+)jUJjoGfAcmpzq+w<&wFy-`=^}Eeqi>i7tgy`0p8lw-6Z@D>%~2*Anmp zJSpRa+q@dNQdtM#EmPTgg9V%#J6E#I9w~>&Iij4y;FI4KhWom5QuF6)!~VevuchYw z5uVN8O}XcfCMi3Gw}WSwGmFE;D<|_=_k4V|PPwUT+%G0dGj~1wXfI~#&+Teu=Qd@Z z$d_eolzDYmW@I|kZq05kMhbS)5!K-*>ktWW?r+uo=v}=gorm_&NT_-`Pe^sYYm0|} zxks+q-dP>(32oi%+9H(z>Wj;S07iP$|DYjDb+1_|$QvR3WBnSE^KPT7n3ubPSEAfP z-IoT5z=kJpo#r(b()Z`@bBq1F>Y%0LbSr{+gFuvvR*dvV^x>5>nt-&Bg)X0f!5fW- zKfjroGkQ<9;Cg2>>~ni-T6H{9cR*e!2d>q5`h|4Pxf&>Iyz|e!;X-#|4=K}MYKe|4 zPp0wu-0B+nDe;o(CyI{q74zv~v*u;N7N z7B$5aae4X2>F;Q6DFp}Fh|52||DKp=#3jf^jhf=d=jCf7ad((#mD))^|6>5s&zAx2 zF#Xp7ZhW3QVSnHx?;#vp{=W{HyArEslN$*v%$BEnoPHzq9fx|7eRsRbI}PVamIuJ* zvnq6g+65QpBynl+c3Tk|K&675LT^N)hkzMo&;>8=eOE6vSMQL#9E;X$KsY}?Kb{fxi2k(*cX&TZxHGm~HL2k$A)rM+ezMNpb}x%TX3 zFQC+YRGc>SeN=eKo?2~hR%A=lI?grUT~J9YCAK>9nJ!+I^6l{-^*YMhrG@x5Vy;O@ zbxwe5D_vbZc}tHQ6Qd)G^tD@?__G45y2-K(mU3fT+!|;tlzNn zP`i`PTX1c2Wy`?SwLmX3eC?opVf7OjdG>oRPnfOwcSD-#*x`awRq63tx|SxN&?a>M z*s3Q(OIldQ6p~MAKj`{Jjly^L3HO~}#`SaYGxlqG8s)j{f($fM+iHw7(8Hsn*FSvU z>l^AbItw8*p{RVJMT@R90feSylg|mjoza;WG1wUXssAmWu(;c9+LhM#Hj&Y}AxbP6 z#VNe#aY@j$YT6W9H0Vkjcspj9eM*fecm)lG)ao3g?o*mUXhh1 zmbIf!o?dA?qO*=aouCU^jSDlZ6;d|d;*I)VT)SG<-o1OD7uI$fb|iNjDw!*otAwX+ z>Y=)SGi|PD+fq;WlL=5L@LqfhV>iR{m=T^Zx8|vps)tyKYHaoWO+vmavc1rBe_eXD;Zj z8MaW3IEi&B!XhpL)^)0m=jRiwk=DItl0$Vny$-bS~%5riVadmj_5(bT;L$e|dbfOV(AE3rakcviC9%Q>OC zr+4H~suIL5sDg;QA(zK1J-{{tcbY0ED?vA^>e4JMab9>1AD z>Aq;+igErIj-hlp+Sg;86Cs5@ukh#f4S-I65C$8pd6B0QI*2x+W6nOlX7oK!6Z@6t zl{;1x^~Eq`5H;5k%S0{Ot&O+VTs8Vm@XR5Aj@gBdS*Mfu>&%a54lfyic8{i6VP@E` z-(PxTy-;7gf)-GTpUDj!e(?0g>HWdZxb+)bye_GHxp_g!w_S{Rlc0eMFJB%C*=9ME ziM85h#pU=T`K^|pV2Xs zYW<~<|Ca)%`IjOG{x{?3Zw0}>6x)9(0?+8u!9<%z*-c4rf4DqFu|6d%Nm1D{k7);1V#e7qm_{j1`>3Q1~oe4X?@B3NqzJYl6v(Op?Wh4 zx&U6I8XaB}?k!o7nL}}l+Oa(sFX)cetl3Yep3^K8X%)VcIl zZPE#?*hx~qFFp$ICTQwjb`pS2j3Bu`_ENz}QmQP+6U*yF&kI#eu9>1uGlI^&(C@2_ zNQ>xOGs&YTATozuQUv*&WO<>`WZtAme%`)k+|YyCwgo^>XO{6b+7^?m_>(kXuT)Op z0$&dov1@Lq0>5&X6GA-F6Liwktr=fSI_O%d`ReBL##U9?Rn?%Ll`aokG5z_oDfq># zkM6w0Gp7w@9xDEtuiVh^k6t#k-p`Zga&-HQF4L_Q=RMtD(fa0=yp-2ebLnJmQoIr? zRb%IgAI7NHkr8fmh-%)8y2@fh2FNU{q6G$|S&d!Sdkc)6i2QbSQ#hg<+K;2J{|;pJBoqSiIrwC^8h{Hiiwa1ayy`xL_5q z;$AJ`2DWcFZf6?cPgi8xZfZ}^(9{?tZ9+(LOmwB)jHierlIeKE!grkCw8Fl(=wpw>ZcWJo zCIPwbrLDf+rFF+l-D?ncU4H^Q<(Mcuckbv8WmU~OS(xpWVX;{B-pDlDTYi4f(zw4! zx5y&2=*_U$*p|lLj@fJTHG1oQb@O}?a zbvtQCNp&Fa!2T1&Dpp{YPgz&Gm#5BMu#_mN9^}743nkTy^uTJN5cAt$NpQhw#;W&! z0@qufKvtMOR{T{%Rt%g6%!SVQH*kO%&}K34e}HtB1;K9QEudD&9u(pI0j>=GH%xVw zC4#)M4X2(5+c6*pm=<^ewY@UcTP6iI!-{X#dv}*b0=UFa_D(%f2#fVaR+s=d1KWTQ z>u`>PyI{jkT}RykF>q>_Jh&ajydu`)EDl!0iu=~53EDbp)V@ADV)$v3$!R@h(akuh zMaiPy6C<2j;Nrz2_0z_yV)@e@DXsC$rJbi<47+_ZgB9Ce!-wc0t-Gt?W&?$MIetWtNF?AINJbreTC zh5Upb-0o(=IusmIWR@kORet&Ld~yBOI^-n@UqXk;fI7+6L}NrwXS7haq8PZCV`zbW z=IpG%<{y@3-2BQu&j#5r~47Vx`F?7S(#h}*Nn@3w8V^y z9G2UcLL8ic6uHv7kNcs_bux4IxW=LUoMuRxF7VGdasOMJ}k4X_08r2nWM zbhZIzgkdbfCuDgGf4eX4ksSZYaGUM$3uxUNw&Mfr0zjKEp%n+80Ovw@dKqT<;xaI8 zUN`m^6ulsbaRVLzQT=E2pqioc3J89XxWm%%Edl&>18=5Y5psvTDM3lKD>eC`9v7c^ zi^*~;)S~7oP4=6|3V8@*Q!d=6S5mNLBM~fLg)(8dshif6chv!dJjcFKtSmo=}kd;sG$f!kdC1ADjf{HB;hXbefQb> z+`aEO_x|yHV=(f}r_Q-%$_gv)!KV?N2SIU15-^4j6L?IZwzP_=f=stu@4MJ za?7}sYv%o?>jI`C&M*{Ri2lWZe2Zl z&v11W7s0-B2wJ$hhox7<>6yf~na3Qd+aClYId*Dun09N`Hz}&Da1>t!GKMQcc-LdctQD9{R+M(nG$delLDek(ZUL z%`&+DZVT*SLM=jN9qMDi$Ssd{sz?glDq1NLK6s4ur z6^zL(>SIhAyhrCGucr9!b2b}JG3NDmPXY~dP%O19npDr&;9;9eOueMz?Ec=x@9uBY zTcggQICz)_e!xPh@Y$KFCb4xMvr^AbLE2(7TV>G$4Gr%6*_(Kq1IZ8_jn<%@T7_js zdBpoi>>qq3+&RK|EVBk5&#nj~1|PGtW)^(q&i4;gdKJLlJ*)I8(tl|5n;~$+zU3GF z*C}4T3bc-b>I7Z+yiW=VdVAd;kq!bGcQ7p$FQgz?oO)p;2y>^B1u@tI2WJSKd(3*& zL@|6m~*ym@2i{=AJ7hE2O{3P+8 z(=yWo`X;WZBegjX-OcO->xVzPFl*w;`MJuBLdUKghls>5|DAdtqF=yZ*;IuCDM zPq@sf-&m$2ixiSB@vjSlracZ5Lf0DUR^*NnN;sSO31yP954pmbhgk2E(I~#pUCCNO zj+xmaVoF?%xClnS3G_0_E^$8Zn`x43r%zn0Ul(VPN#yiQ8KwW~se0gAiU^ww0==Fz ziJ0or4Yy}4;7s1N5OCDtUlcW$Xz=O)_TGCD>CA2u=3LcT_g*=y@_DbU$z_Ds#Fvq( zs8Jo$xeIDiz zZ&wpLy7Bgt(%0b;D3p5$s5`}wy&Zidw(}qxF}3@- zW7lAU^x0~HfE~Swy?BL-`gW}DL?r)IOo#L1meL{tWG=7R83yL zWauN7Z`K9bP}gPJk4rS)n%&8>U*6ggf786(_E8(P&9Z)Z%`I{HlezZo*d&R4E_(IY z@|PzgjBYa6ry9(5J!li+y%AfNcYU^>quzSI+kG|klIf;MmtyCaSDbY36p;zQO%-0H zPS(Xd`zGDHy?05khSbw~bGf(e zb|Z&1Y<&Z$Y#guj#c6T3+jn196O2QPEp;cR()Q2(?*4>)8ojo;;;Key_73X7&e^O^ zD!tU^X&cwz6_twgEKJE{qV>o>Qqt`wPvgEB$4ax`RXJQ?vHzhqHp_x2j>By9Q26pH z@0T#W+`N)&Lxyjt^HkK0Z{?O;<5GK{P%5utd`l~i?T%^iyHfcyZpA0{-Nz3I1?~#i zA_yT*Awy7-S&Fw(FA#W$09a6n6u$ejN!|A6vv(INLKp)WZ;IO@@FA9I#X;0iuFiB( z5T5c|b|P`pS%tJ0O1Y3(g|5b1TB7WCc7I_moj89)egJM_3Xj^S6U7p(^q1oT^O2XZ z5~Jn=dvqVzZT@b|Iz8M^&=VY#eq z1}U>;Hp4vK#}eI7DVT}esPOjn^6>PT_8rH1oJ2aF8SJ_z3XHkC`?SqWkHKDWzNH-_ z7+a{GknF<)?gDSmv>dSOF<2Ev-a^zEZh}&roo~8(Vgxz4_`CwBt%^kig+lF4f`wkL zoGyET9I(X9{lVdvR1ODiNiY9mHHCL~@nUHZnIAjn+@Mm11T!!a#6tA3QaXZqa&Mua z-M7Vea(yVQp~V#b%^m$^YSzI_#1ADi%Un#}ykG_${?$l4){C zz@U@$Sh_=V7)!?C@Roz_oWQ8N5=&qbDgwR$gqc-smfB{zb*WD)3!{fmeFZ;l19ILcd20{0+|zNK zoievnE;;Ly9I}6*-)&l5=u3>)T^c&xLF_Im!RxmzJkxOwdj%#B6USD!mEgRtW@ZIQ zMr=``=O4!@b;5^mXr0LX(t>n(w>Y9>qt;_y} znzDDH4o4%kjK%ARuoOM(F0MHxr&wgQXarqPG(z4_HUSE(v1t2=ENh8}ZbJDGhKOF^ zS!#fWwx`c(&B;=@2Q<8HVA{evylf+8Lx?HzzuShU`(41+bs1&ek_qyDy&yQNogsB$ zRHtAE!SUe5FWy2iM3^F8;R|aIF<>Qy7t6eL!Ej=Vq=kmiiN6cHT2xTxZJEWF*qP3q z_d|S@j6VAt?z-qPkk?915<5^kxPy;k zce{^I#$`kg_?{uN)2PY~Z<)|8#l0~l`-_Be`(aK2N$la@d;u z0p_ngtOeh4qfn=Xa3TCOMu(2%6HP)XJA)(d0?yWE2Z?h*Wlz7?&yPe zr2U&{Df2g170NArChO1vHiim$Q;sZqAKMC!z%uaJ#~t!$m^3v>$b1W8a+#gtN=E>4 z)`OzM2Ugdw{EaUB*sm3q!P^|slOFrUJ?m(T4s>c<4uNc)Mk4Oe)OKvTD89WBJ~;2T zt|WaU95wIeb?bnv!we>s;pkyxs5a>Uzh)CW{}GYC6;>oKY&aPu_cRZ&eE439i>2?L zDIE8u*3hf;TblZ$n`pNNFQG=rA^*O%l^&9uhx<;9Dkh82N>A&YH#yoDBY;MCIfu0)H zdi!iBRC3o>ib4(;1S58Abs_nH%y!s=K7QHA-(8{zldFk65}}3XN67tqss1YF|LFfu zdH+{-8;qwk1qnP{Znz^;6_fmbFP*{I_dfYC{VrdZS?d_TI|#%Un$U>5}m0 zxdjOQ<=;%9xV|L)Ob~@>x-;h8Fs++!n)9!B!{5V7`!c9MT$mxj!?ZPiY0kI{vuK*K z%=zh1?Ensz64!Fc+bV%cn5M6&O&KmY)t`KJ$Xr4exUXvKXp59$T%Q-_&>!xslLq2} zfJ;xiLT(FN=EfmjA;O`Jk2&@Fg$(+I98h3avPx%*$tcw|O6%Ab=!1opOB6R-=B~{C zmyD8V>b=<#fCqA(P7(1ZAOQb*chBY$2{E+m62<>fHujWp2~9gTA~RJykZ4?~cjHWw z{=ml!^F0jiMAO(KKgOom3?$GJ44s3L3IwZ%GR}rT+vmt2q{b9uvroXMjprw*^BD(L zSha7?y3M(TO0_VxF;Tb&N(DH_KCzs-@3I}wY|h4a|!Hwytupm zPKLbkD}s4QrxSKQ?&m~H#gBOh&DG#bd&>Db-89{XO$OP>I9&H?^hQ>kjDZA}^JMr( zwNtRLqLOYmcX1ky3j6ZMlREqqwjS>1Hx0GmVK}`L=U_3#ER`aiTu7FRF1H>p4bNd< z4L1!BZFn3X4G)>3S}@xZnPRy7d%Y}`I=bfn7HiC{M-v`Lrr6!|`_6xh4SbWWlWV}O zx77jtQ}-XS`w}C>@YJIT5S$TXKkw*_vHx8ghU`Vxwr6(kk8B;Wm+(F}Trz9C@z{{3 zqgG&Qw3IIr%7W-U zW;q%bO{!?#Ab_V#=?OgMC!-KOaO6p(A0@$w(&a&@9?{%>p)sQ;Fjqo}dHGAFZn1PF zX9&@#*#5hD;YcPISLmc_qPy||?WSIrme1`n@S{Eta@S~&=OqXzhvp@t7qxcaNo=Jf zy28Lx8`m=$fl&)$Ni4Hs;-WAuLN2c(I>Qu<*Cvi7Ltyg*@jE4D3$%cT2g#dg4*a}8 zd|O~?r-ThT#QG%<;%B&M%m78i^^}DJMaUDKjt$?Nzhs@$6F~Cr@LgqqbT1hz`sLvT zs@GwPyUIlAp*-hB4F4+j@8p=d(V|`+q!^+p|6V=bsmSRbsp8cKMIj#`S0BWxS34EC zdBS4Ft9SC(P$&&?lzgO`pdinOXNTvrJnZhCdD8 zTV4WVg)_6(ZB(M#vydsVuryp!|G+)e92h%@9lmEXd*MEhhx-h3j;vAHE;FVQXBh?Q zG!O?_%PQE(DoDY9ic(cGgpJ>06WzV}WcTLy@j(7u;dkgrsbyAj|3FIrKwp_yr0S>6 zT({uCUZ0RrpAfg^nwJ)~_k{Mh_E3KeL?fCx`Xz%!?getcM5=&4ySNt&*-x(OHc4Rz zxd%_B&&K66q~**@;b+VJXE>}Q7+7yP7t&6Ppeki@AgU#+m6)V(pxc68ob3L5B-XYA z|5MGG1(6?-qv@iM{>W?axugG~qJE@~PK-jnM$*7nkN$@W<8SdVz;6{-j~M42!8l^f zRkSz=PJjzJVvIuK!4)u9Q8WI?Tey$~$CjCE@OHHLtm7Nx+!5aqAKEwy8Hl8UFa1vy zyCXaFSQIh@c>}(A^gmQg<{W9^B@2$hNJGr0C?qY;2wf|QGdeQqm{~je_fFi!u3SD- zQc>~`t~?yPll8#MEp)RVS1T&Q>G0?oVN}!|6`dIpq_W@t4+NaF^dP224wrd$`wTuS zadyZzB{a|FsdR*`cQ_Klcs6XV3rR^PQhkj+mis-UAq+7`(hHL79Ql={Tj8mVZM%{q z`0t~Sn;h^GiMUyiV@$t;_3@6Hw)_RbYKU!D5+4Z*#UF?D1kIq&ch|h9@aO=h%gHY| zGjP?Uuk1J9ar`bHM$K;tLnf!#U7Kb;S8#Nc@V5ydz9f*HWlLjyWoUgnpNW6PO&YiSIeB*)O~1e9mqv18^rh<{e8U%bZQ+ ze%9aZ&H{9>Pcg#8ZGfT<<|^k_evX%$(fP3ttmHWR!# z4uuW}ow(|(wknrYD4c^uu0QAQPC7?T7sp<+T({*O`Ahl2dfkzG`Y(l$?YfCTGCae6 zT55N?Z-S8Nx`jY8i}60P|M~QUXKELF_BYPmg<{-c-8XNkZPVpmU){pG;xk`?!=-~} zQDK!Y3FG6m(b1jbdw)i4v{2jT__Yie zbj?R`kBrC}3gjK+?Ugr|DyJ=e{G|bD|D<66EoyfEtoG!2^qoq(SwYOH!*`*M)StJ1 zZ&P1=bS1?XPfmXH|1(N1^&ga6^Eo9)2inuXc_q`l{*do0vDuTNrM8j1ard6|a95g= zwWhY-M!|-7wd`u$HbJB1Dbp;u{*Yj@XcNo~2&78WCsbsL9FdFUf5qyAD?ABEdyA&vr{Y`e^bq4n>Wm z^^?4maNAD~G%VLV`>i$s_p&b&`3D{ineFEv1M`LU8y$giGTWzDrS$u~n=EbCJmnmI zBzsLyoEuI(+xtd#ryb7?SSu-!@2e`VX1fzW?UG1U2QvMBm8cWRYUjKRJBHyY!1`Wm z-_>?mO=e8`b~DfgJKp;GNMF2H>2r+$U?8OzHC>TFCv~I1QDv;dfb!1v=K~nq1rBg| z{Jf`9TzPu3o?C8Qlg6fxjw`D0>~6J4>_C(;pPs#blDyYmXZ25pqYv+*c4(!WWWK*9 ztYNV=^wLowd7Vpz?t56vKDenk9layLn#s1Uyd<6Sz3-~JFbKQ*)~aS=0=j7s6qC^EV;05`6h~40`GA2och1%hFG|;umnfPva>+k{nBae z7LEX(b**f64~0e$s8v)6BUUePwcNIX!PPeR}6&u9}wEQ|!ZYYJDDxc*=S8gx03a zuiRmomZVj7^gQkQ{NC4MeuW^X8=`pN9+rcQur=~9mF;4Ry>0h?ikYom<{@?EuItaP zn_zti2VJXT2d5J$L~l~w0k4)@Ahu_AaXT-4rb2u0;hRPQIwvBC?xd0fK`oC1S8b3! z&UAIA7G!2%N>|#mx1EZgO`8{_Od*)vplC34v$Th+j(V~Pp;a2R9`5W!v9%AgUhHYR zE=Z12)Cd?`k}vfa>9AiEgX+Sh>X;yU5KiOPJK<7YOtTg940Xf~hLfsWgvK;uUtOW8 z^J!^8)F&p)(V>l40*GPSdl6{pJX_u6QXYZ#>a$uMcNT9zO<~Cp;)1=gLL@QPH4mwT zy|+@vhrPE}_5g0WTBZxXda|wtk36v(FgHH28!->U88n(R?2mmwmj2tE`SNhPT8X{G zgXsSL(!-L#$j?pfJALn=KB1|B)N^~^$C9S~=FItLu)&zO-;iC~*z0seWv|DgEf;EQ z_cm&l|82R~~P5L_G}H3e0eC5lM6$kUyN#DgTWB4UhynLCf2pz90e08y$U z0Mp;CTG2F0RWNf5l#cV$-z`UHFiQ+nnqy8t?TN&nRI3FRC+Z{S zfw+nx^K2Z|USd3s>Yq}vaMiD8ez@Jt(lg9K8S-prS347TjEaWO$|27%>%e`CYPFS5 zusx1Q%+YY7HvD*RJrRyHKk7ev%Q8JaQhLyy({z&b(Co+w`hGG=E_`#evMN@2Rr0Y93Gz|J#k@k13;0+SjME zxUsZrl>I+mXYUyo$~A5Q3l^ql3+1E(cAbQU!E1ui&%=kzvv50)E&>Ik6Q$yCWc!II zZzeT(@JUa!u_TQ$HY?MbTOPjpp)~3vS@(ipI?n#LqcLuCPq14hxD+$7Y92>PX?k2c zj0F2${v$p9NN)B0yZWNw6FM8}EWR_h6FL;tAL$F+uIZux-#J-~;C2Nh2 zL@lOSAvTvHf=;@)-oNbE%{xfQx)p2h9J6qZo-H`hNRDSP zj=R`eHTf_ zCKMuqLG>_!2;c{D!2B_MqARO)j?KE#qpIvsD5UAfz8n|hO_M^kS6#1kiy?rl`b&Oz zrJEz^Y+z;e>~Z9p2G7%WtH-Ls`r$vi9vSIec8X*Z7p}@&&j~k1-z?LKmhJYab}m-ndN|QxKxeF#z5=Bm z`*5DQo)fNszA3K5#!-y8o}46VKoZ6){PJ|y?~Ou3BMXXgZB&_7{Hf>olD*Hvc>jog z5C1-Y-OiwH@avNUBSTPe70cR$iQz)djOJyJl)N2)19j(%&uZ7kW11I#6*636Q7Lo<>j1Amh zE1uF#Vm1(0A0E!r(geI_o)eVm!V11T$&ZuKcPsE(LkYte$&8t@Ic|{(O>AumHf%A{ zPyr3b8Kij4i_p`iYSZIyyE_wG86^$i$_MqE0JpTVtIPTdwPy#BL9OoU9@(Kz>?U_W z1*aTDO>Q7$=Vm|5t68_uF4S94Hr|+Kc6`;3rC>C&?TOS>eR?+?nf0d2u~WE6@Mky4 zz5+j%4H1WeQ{S|1Z!*ZH%Qi{DkuJivz?XSd*3+z?{m_i9wE^vO`UhMpZ$L=gYEb>) zuyM^n>w^PT24iYaDs@IG;Zo=BW-4`D>g)N7MtCaW>_y`OTmoFQZUvEs4Mxu)hNlMw zw(jcenl*#P7b~0YYKrykc>d0Q zK^``DrM3)VFnN!~+L$T4;qBYGc{SK**HL&Xjk{*DrhtRdq|EQ-`5PT~`d%E%cze?4 z_fPxkPyV`+Q-&~wRT<43noIIK$z(|K>ji66%xW2TEtbAADZ8beYJYO?vrzvOj$sR* zwKh>i4LKhNPrcXGJRfIlA{n&7r{!5~+HNRNMzQqW?PhaBquyM?#NykzGBBV=n$lQrhDzAJ6%QSel>YLteUF?E+jdb(~T^iaCTV)sv3=TCW=&?}yCPM_m z0JO<4RYO=6d1=%dI&pd6fF0Z!P%-1K2iiQG6vMBI^rzconG(ad)dg*?*ur2X^Dn4Z zYe;lb=U*%vr$$WBDod%>M*0KaH71afkjWzOxK{n9u7NRV6R)HJ0d!*AU~iDS6J5xzUfn%c}TJ%Nz(Xj$eeavX5{%F3`FHGT}3zs-$AeIAf_kVG+je8}dAj>a$YlI`;$K zGlpG3Q(Vz5;m4&pN$pEZ=0az)JK9XV7QK{XS@_&%fyX33wP$$McnDy_=3}~VatMq* zioEbvi)-VhZlndS6)0|X{}W!R2(b>1XqQsp>;op}HXaZ)aRvOCa!ibX`>fFPlEB%B zS&#*;?ttO`v2r8<^teC_M7Y~uJ$K)p!-A0%!bn=>OJ4K7#ePQqZ^MWZK47SRe}AGC zh?sN}`iJ4~h$^Nl=P4u#e;Y;w@Xk}z?@x4|r_>1lBgOgpxdB3GjZXdQ=!W@MaRY7A zW?qc#Ux_qOZJOz{r~|h`3v*KytV(1%f4}TL_vjik(5CYYCPOg<2D(ar`<9FcjB#gJL&>ZU#(@k5@I4?aA&6Nv*b@TNdV?1`g0;X)g{e`gG z#%Vj@fAK`pIg5XQqJCyifGB$B*CC>4cEKc}Kfa^8K#rsd{th|t_$x%}uMqyIKOz4@ zCB5?_x&WU z^1SkQD$3l}^J~7Vm8RO6-1#okp_=66s{JyfIc9zR*Q)xyF6?PO#MdCDpzIkl!t+Fr z$uR9BkFj#RwJvY6pu?3s14mjeX!m!MJkJw+c%nl_vq2&)muvU;=Xq|^^PUt--XDX#e#3=|0PzkO%-J$>q+kSXwieo5Q&~2HU>@Uk`9Xd{NBSzkrZX zL)c$I8{s)5X`TSnG-m*knf(S(O_U0-J%6CUXzJ0u9Xo(PLMr+F13>y4Tw-bZ>U9n& z4LW}m2RJ5{rY{%jMZ(`i(*KSsu{8C0owG`NLhI)g(_reyPyl06?k@+BrGG~!{lS*b zv(C9CAnTk_0X+yc8($~P zZFJ82$C)6cD&~dGC>Ovi0k_?-{(lhHf%6imoxgpqO&PjLkQ%2fg})@jEFSdk_S#=N-;? z5?aEgp9ryO4wyG!Lc0Grb?ESpXIi|tpf(vHJ-t$5|$C~~@Cn=|9%7T!${DLqc{{=7&dK9FlSIH@r zpVfWZaGZHWH%8-b(pittncTdwKCcI>)%_R|H181oh|V~?VbjudG8Zv%bF`y3yg}1a z6GAQ5{US%gFNQ#wU5<++>b76pgpxCcgE30UPfHA>iQ(>v{B@*i28zU_HG<`5#2w6y z=nA$OYdK3Ih7ThrBENU6o_5-QS)1SUT{y6Cg`G6RCd%r;OX`z-CBUa0RqbkVm^wOV z{ zEtvQ+*0JiXQ424Npw3#Y**ZVA;mz^&`8c0p`ycD`U!K=Dd6}m9H4fVk1Daz!lhTl=;rawtL*6`r2R@ z&d<~n`OK@T5;+5z7EET*+=N3Cmv&tr%b6!`0+){gv9RkZ0SMf2{o9!_&grpWwfQkQ zS+kvH0lS9jW@bT8bGo&6=4VG9Ur*~ldN#$%oVyH!kvKFu=Fs)=x|hCp?A?MwYmC{T%LrLS5GDn~u``Wh26rCwIxjmY4w)-yERH1sXpY8YeQ zrdM(E_f{R)VVn?xH`=}G|50{G?$cyGS#LfvDQN%gVUx*Q5s^c6#+=`aJpu8*Za=?L zR%NEnaKFm1IFE+!_HO;i7wD>1)m{&C0Xd`xTT$?max9y*?j>b`o~N+(J>v|ur4H%u z$DI=nqmHMS+x>J2ogbuf2RfCn)QxD+1U#X^`=*(F*`g_d17APyiO2OqJ~koSrw9)& zJwxHg65^m7PJ+HK&z6Y1ZNehhW<#v1s#=n{@$1kvsrwVM9yhCV@hYRcJn7YbFcO? z$Ei-=jFZhPZsbfIbg7=#kl@K|QVxfCXf)%PdFt>wYr!AS^6k%yMSeVEoub}jf#QN( z_E+RAumxcexM9#36&-fWX@AH$+*u_mb-~FN7rgv5y8bBGCZ$f*#jf(j-ECc~FDwM> z)f^}U@Ao$Es=A>Z$$P?(4PCp6H!`-pu%g8uITcGc=d+csq8-@SBAfZf{DAAsI?F;E5A&T}3 zZ5J)bn97*V*a>9n=&{a?&;a2cDnf!G9k6h4aN0Z~1;J34ve1Q`oBGsslZUK(kg{_m#VeFu$QTYhH;-pWSa|RwqwrvyPA#w~ za2TjSjum@zgavv+FqHWKi}#<@92~O((Pam|I=KfYB876ZdnCDXK_>)S@caLyTItu# zGm@#j*d+NTjPF;S^u0c1G5g^5@rw$*h+EXcDM|4mz3aTUdna_}B5Zr;My(~_HmYt; z-)0^=h!z=Xazy=jxm{$pi&(CPO!`03sxkDAy_@{myF~Ezo#d{;*Hg@7yCEH#<)5=G z6EsF1_3USK430FnD{@Aqj=PIiZ$ov%7V;06G&iLn2J?s_UuFGM3c7f(gYC>e!VbB3 z=Xn=-qx8S;)2~oTZATOJIex2Yt{q&OSEO+NC!Hi~b8B z7=;81nrKl#LAL}(5lXpMskP2!gHWIJesih7iPp58PGWPB`1@QESk)o(fRorX9LH+e zeXOb$JZ8`M1CFCWPW6OO2Ocw=$$_OUl>54>9fKnq$z0syQU%htT|W;Co;o7YXE@CA z@(lbm4vRfrusPcvE@L_KI=dy}nc=h{8j8!i1e-L!8F@B>afF&bTo2xD*qy|AaEV!_6nRC09PnQL01ZEd<*Owosf# zoMM+N8l)(p@g>yDc}E_yDZ`I5>v1Rh;-n63)vjYa>D*%vpU?f%sW=aYlhbdYy$`*lAqA90t!3)^ zv3J{!M%rZ3YQ&zra&Sp!n9|_=sF0Id=HT+&o;Qaqh{JLCb}76_FjOvQA0T% zFaLc%FL9UgXZ8CP9utb!`@JF(6&Lp@3g19C;)htaPfoR1Dr>PK9>6YRjzdK(KkhdA zT#dgTWuqs1fSTAo-MSoc;P%wf=Afh|o7ujdGR3>!(RS}F?y*VC0sygwQ+_sx%>3#T z7;wb|ode?96+T3wiqn6*u;#jZoKwG2b1mi?!o%ia_j93y7urw79p6VL*7RFeoOX&y zSY`3uFK@lQ3X|5?6R-*}6OxQy8JKC~OseepHBcAvh5u&d;>iwIx1Sz1D2k3hr7Ya(S@>u%sKvxh-Qz!Dn<&>wglBlE>otr_TytsJ z3kI)1f8^nxp^7Y|iu^rVs`QAiNv#n7zLL&~y+GG^YyGQS`t&?3dfL8u|646Zv*zIB zV@Nsz>&;+F`1}GF#W97q?!%=qMEQ>UNo-+?6rESEr!D zGH;uolexBG!!~#|_O5o`+)HHT9y#du9FNnzlP{}b^2xcVWwv*8Y>F$?yh%?@he&G zJC+)aX)hNc3bkVria``QC<=Yaf&RXJTjmiOEtXw@^Me0wb%M> zrVV_mlT6;~<Cte=4a?BnYx}|m ze>4;aBYMqy3BT-#@qocw<3X~^*F0znD9ze6UVX%8{Y{aYUK7Cs=UmKCgCX2V@ZZciJX$CVB6mAzss8zA#<;frPzJn(oOIHo3z zvL+uBthAHez-L8wM*`b9keYF#Q{ruo4jG8<&;H!^u6gFYf3d~f+oT5+uZ1ov zYCpVdnO`GdxPgrp%_Itrl-v5IZmyc5hNmFyZ___+TcY%`B&F6cX!7#Jy~dJ)+7dA9 zGz6`tOTkN_!Z+34;GMx$2(~awTQ;2!2oG}Ko;mgWDX6zl@SK;JmgHGl?VU0@N9Qt; zZSE4vn&00r0gg4FH#{ns%I+~#X$*as_xBKMOYNw^HtnP6Iv!xz>oipVZK6V~#?Tbj7D*fo={(Y=#QlJjp#g}+!T zRSr))nGUIq_mpZpZSXX?^d`}@zu$3J=MWfp?6kgXv_782^srZK!P<*t=|@zQpQL|_ zt<&=eRr%IPo@9=H`pU%IxBY({pQN6vEv#1*xWY%GX5}l+R3a&l(|i=P zrEj(Pw;it(U2Sk~tNbLH!C*n#s2X|SGySr87*gYP$ro=yAAVpj->k-!*t?krxqDyi z!kcY>za=rdM;d3m+g_X+%MkE;T1`4Xo8un-92VHj+@XUN*uwO6+(GEf=e>8BQQ0)>OnUb@WanByHq)mCWP_IwR>uG-cTBD}}1Rgd$~ZPIY^+7_EQsFp(O zjcdU;H+`uD-WJ@rGsiKj9W|WgixY((0A<4@g{L;JrVW>$9e({ z$T*oJ-m5q=aBeNd-(YR_9-eWL!Ul8SmaZG+OFDly$}xfau6V3@5I4m4b662uaRnF>1=2pW3t2P_Y8Hx{Lf#u?uD-U_mhqyf3pa*>Beq?zc9z||V= zp3iF`JLi~Q@#5rTREG9^Ao3Uj`Q>$BwKb*-bics6u=F*CSHgYI#IQ*4ad~m%t zi-w$tdyx_gB~@v2@d+Y&OAA+utJ2Vh=ewQ*H>-3CaVJW9&&y(?W88An9B^jJLY2PV z40s4^zV5M?+}hcb_CDO=L!p4mrA%27gseD+uQjW$$KAiPDHFi#w4Hq)TB&S&IM1zT zXFevHL+h+pq^^qy!p&njt9!B0djo9pskVuOj|jj9v|^;ZPAcUbAG+qkIUgue=q~!R zh3YSUU<*B316sS^ADA=EM-wzlrpZy9EL^)qcC-MMr*X1po2(AA80M50yPP6G4Q-_K zjJZss-o~S?6 z7rm6YAsQY{m6wt{nrbg);ce}mUf%@yS#IkHglSaa2{mp%nAQsn3p{jfjCwG5;i4s{caM@yB((#^iod`sv<%Rc)v2tNsh=RGU;DaB$0=I7(s! zQ<=JpdjL;>b;;z2mZbKvx8zd->T_wq{?C-43)!civp zj&w&)!eQNH7Cg5tJYK0ryXJt-{X0BMK4JlfClb9jbVs=AE2|<`CiQQY_6t3VroW|- z#Vm~1p3}gh$3hQ1Z2wN8)YZLk*e&jNR*juFW+6YHZY=9|rN=4WGzvJ-df-6o7lI## zl1e|j8EVoxUhN?kz@_iC7k6BiK7_}yeE=rBX<@Tq=aga`pbgy* ziTh-ER{o-m5#;sHp3>cLsS7i`Ti&C&A$RePxf?9?jpnOmK5J<5ymQjcNy{556e0u? z-|#cr`QL$nJxYOh)keCB;{^By>huZ0DbpM2yoiBvfttm9{f`bCget?Vi99EwIoG zRM*EZbgEqZ`g3M#aEi!S%Llc~R|>FcJo-x_N2+apT5>xICi#%xU6h1TJ;Z%5eu3C) z^jc%y7Me2nBi=2&a)EPd`1Z*=9JC<)jDUBA5PaQ~G=Y3HQ7I{VK19a+?yBcXoO-Ro3i|I(2oh5cREuA?z>IkEA$ZpH ztanAQw+!Vio~D2a=p;kffhKs0wY}w=v4W@y6}^`6qZa~2_v5b}I48@_R@5a2Sc7L( zEWp10HltNS?RXimVfiMC&Kdg=&}b_#ZugCD=^bKPkO+xxy>z_ePX*7I7HGYd@hHD; zmX+}&zwYYe?21uFvdV`YpTy(tB^yslnGGp&CUt%k6*vJJb#9euw>(e; zo@ehO!y=xIJV@`Ftm^ZG%#~PR(0M%_DbnwFZ$Z-z^dBG4V4g7p`-u_fkYAJ@VxC``yq|N4*Bw zM5r}q8jMtd&$5ei`X`S@1om^(fK#O!g0_g{3L-A|z0GDf%}O0~emWmtz9Y zR4i+sKQY#JrPNRCgRSj=*`0B<2o{2(fWt+(*H99~SsRjRw zsCR(wBv|@DV{>EMwry@~I~&`!ZQJ(7wzIKqTmP4P@Auw2XQrpR`%KMDcg<;3)vq#@ zf0A9)L9z8*j}g$Hj<=_t&o=!{wu|W%TPrY{9T`GR#F$+RNihW%=1KU|)+_?KC|S=x zPwcZF^Z=iAp%p-LAiX@%QFrR$-~Es5axCf~;n+gZhhxzzfSS*!3Z>w?4NN$p*f2C) zlGUf#KPydVKw&G81%G98OttdO(tZ^D+=Vd&YF_Iol!AmwzxYfmAoU-Kdhgd1V57MI zVd}-DU#E9Gp`-lsHkU`lK6|A1)9`lx;h|GF*bjaj$)Eyl$Y4G&Rxt*b?1RY#^$|q6 z3tfR{UYqm7GCdz0OG^0Sul^ke5OVlBxHT#+Bnf?155{|3ggQdV?p+^doY#3TDOX|}cpZ`M< zAO4WO7`O*GUtV`*UCT!{9o5AwuBD?`2fykEP#-Mxh3Co+3bpkz-{tmovv4!?%bPA{X-XTZ`$qVjcIZ_{GHfax(WjP zto!R8l(6wC{={cR0-{d8yr&x>0RHoh6OoEC>VBo3i~fBnQsuVVB<|I*WVTwAL*CiW z$BV_r*2=UMa!u6E!yir7eccp0jNXXT9NbruhVe-k_1>Nfzjp~=ijA$`2d0Lmu0Hy$ zMyj>2LV1WDixHk=+c`VoO+8X^c@!n7+jH{7PcR6G9l7D7o;2tlWSK^qt-8wFwmcKf zD2MwFTaR4U=cXN=!R=RH*VnM~Xw#)3ir#1N7&cKp)Rl$fEBpIYzSEi=l$Fop4_!Wy ze-^hfWE?(LlRl(xL{Z7Uw!>$|78l(1V(}W6Pe5(cZW79I9MauZqr{iKfIlL2{7^5t zSXk9@&Faz$tKX+?E`9)py(Us!-())UqBexBH;h_z381CdP9E+a-%k)ZR*1O)r2OJ( zY4dMSWhl~eDP32hcOC8%RhzukG8384b>mgn4yzF_Yo_-sOp4x~uAX1e9|iJtvrSbr zLx(8H`^5TrpnsrS88)JASEd;YBdWN!3(V`Bgvg z=bcDQC!}*H)7JTFE2rqVfGLny>LdWS)LtA*4!LX)y?sc|txufQ4RHCGai}W--i|d0 z){1Pj6NA*_Y}Bpg#fzwSP_IOK^1rHD4;Cv=M>NH{`N^<-@VarkH^ua|svla>1mK|e zTjn;3(!jbt`L$56Q8Prkq+Fi&NMc+CB7zW?(A6*ACtr6>2#_Ss>dHVCL`5U;O@XB6&&pfas z^MhUvmmEMG01&hC;W)p92{X)K+F8;@l5C>iTxKD(VDmQ$)s=vZ7EG$`o&s)8&LY!=%|ab6$z)`#<4Jf0hmvs{2R#!Q4cc;X)lq z6E0G8lHh8K9^)Am!-O)h{$yk-Fy*6c4B)Cb3>d=UX_I^u0#rY25H9egrh<8d z8{#^WX90LcCs3@NwEwu^ue&n+KMyaLeuV&;Cr&$3PftnBv*ZU#^^Hx8*A>rETFe!? zBU6hfctF`H4YHEf8L`9~RNB{20<*LGYm!qm75^eujV4o#H;Xlvjx@)280iyp@4yuA zuLt71@H6m$qmF&@kNGBEUj{&!nH^g^^+r?_%v*f@M!fZX@x`$)1*P>}{3YWgE&MBL zL0Kl!CZ#VVFHu;`Rvte-O;Jh7prlSeJ3ApWOQSjs){66#?BwLU49LritB>C}!PnN| zmt+?IX(oNS-cOVMXO^d{X}2zj7?Of4ORhh58RsoIz5#H#_XNGgd_QAv#e3%3f^ zL|LKo?PYF;Xl`y~6Qt2jF+5d0FRI?*-uM z-LLa|rxx&n@YVaOT5-U4XG14M(ndkK?sr7O*H^B6+`q3~U&K83i8Lc}tL=wQZy*+u z?V@!J&+DLa;bC%uKi1NO``)qG1M)6~zt!!)Q|t7V<-F8mEtJzKkK>z6xRn~!D-QkwF&a`cEqf$wZB8$e*G0`8jpZZDg>++}wCKFk zBhxtYo<4-^fqOlI-m1o-L4rnCrzk@+sBH6lp)51|6c~L#)&=$akMpja2L>e?-@*eC z1v^Rsp;i{yA|9nR?-)hC;P(yyY`hsNmO!)9fJVOIEfO|G?On6yTBBQRoM zh$t^~cP_r>#EJp;9yuB{ic^G1ENEaIk~YBiy;m|4xO2-H4#dHhq`pmJFph*a``E%b zm8l{e5s1Ml80S7otKy%}`*sdJpCOZv;q`sLth4QIm~TCtk*_)XP_+H5TfHM@;37Ub z#-kKH4=69hQZwexbV64mP(iFb{-nRz^k=C~=K)RLZ=Fn3^0!VqD>x@v}Ar z%h$G0H%Nn#BKs0Q(r97xn305Z0nhctQu3#V5Rl8nfuHNiO+TpsX#N>dY9$Vp0CS=MCkv*@7GQ<7f zBvu(_zV!5VTGul~AH7b0pm}ySF8Tqk@+0(*KH17Tcf&IaEKE>vs!>9mJ(U8F)b%&5 z9|XRc{Et4l$R`PLFJQ!aT2Jf@TH;%d1se924HQ`JWD0JINMZ^r;R+U%6tU#wf34U) zXNs8@19)HJPu@}y%N%ln9Bray(r>LGbW>iI0na;Cod1jNQ=O?OGbji*+AHmYv`O1^ zEfma$5FD^;uJBh_^D1U}E#R^<>oD=rQJ3ai&#OZ(^YFV@N4u~WYJUH%Bu=@o0W~Rb`Ke;D-PW+?RNc@8RJ*V{Sj8a^W6S2U! zMc^S>r0NU9jj?^h!zI{XMCK#B42rFZXoxK94=Vh6h7Z+I|a7=-iCw>(o z8m7`KfR71+y69L27iN~D>#ydk^X{(0kXa`NT!V7MpE8Jms`&MHfj(jlMU8C-S}ukn z*cXJLXmJ0aR<#cf;8;*|!Z59s{uwNzvW)y_hupRB&{~SOG6b7a7)vT!4b@oEcuYNNKOS4z{mB% zI`)TQN-ZOXh44nRo8>i0ua%?Y*Y8@u_>(}#xBBZhVBuOTkC6=M{kG_emI~-E^sj4d z#8g9UwYq;)DYa6nZg@yxK}_+=L0P<>4Lc6wjAUGdg#SFQ-PR$>mT=ZV@ihYEW`qXZ z`Sqqp^1U$i*D&4TAvMFdPi?CFc6zS(iFDfsa=HnU$hfq*Th=|q9pg$ZpJWdZm@wk+ zh-r{IWfX)0c_9G0hB`sGfs9@TLF`;V@pixhgeGN)cO8OkXN3(7=|L#OD^)|R&522$ zNiwgH$yr6qB^BKNy#978vqOPIm6F()1qLcT=nXCP_z-xjWhkv|2cR$(4EYW33M@Ew z*n!?Q5vE9&Ox+Emw_@LEBK8M-wb+-PUiBf?PM8`-BDFv`jfny{AtkQ3^Jw5|^pn-U zcQ6JO0glrvYRh0R39Cg!(2M8LhJSRa%8e8nJe&97o3VDVACq<}n&i+VD7#(!#D+}*!#ZAcMUUKNUGsE=bv9j=qZ+rvqv0tLbuxJWB0jK3Q1Bda5CD=UaVZ=_FkZ;ZaZJ zY^^`YaI8AS3J*n2T&6>#4D2F-?RCo`Jh1nfQ!*HeXxJNu!AAfqJ=^Ta#^`*W5)?$^Y;f9pko=mF zIOIUoP2;wuM<>%*jPcSurfv_Oc8{S6AN6=Q@$K50r~CTZwvyI1t+MDRaonq@s3QHD z4j`vVTzRtt*nDdn$gzA*yKTl*J+0GZT)93uxI@|J^Ko|R-0pe>o@_0Cl-h2?T4;ky zcJ;q*ygWR7AK{8o(TmoAuu5b8-Jq8qz%o9YtRXVvv5!J*NV}sq};oTt=>u z4YB^qAGT`Ag5%cUfRN!-m~3XNO&V!`>q^08rJ@9;kq_}EYabCU_?1Iwmz{E5c_Rsw>bz!tVaq|XPvTg;6;Hvo zilxKIHx{i4`+MA0f=Td+8ms@j2;JJ?L40u>iw+o)CXXicR8CEpe z{G~AqCv-{7n2ff~7j1yZD1jn_y@jiv2nR&JYZeTRY9KE#uRYB|Agx#YuTm8>*DE6& z#kV@tFoX>2{<*yT;d|q;;3Ku-)A&oP;Wic198xV&1b}RtG1@xG2!VEG4m~va?!g1>P`VFZI^i9Uw_2 zG9GTQ(Pz)@*LvLgMC`4tm3kaEil~^(CjhI zxLnCY))T&&`@+(g+4b<{Yj{s>3&jVJWwIhMoZGLRVNo}+(BAN99Dp-eNi4dAZ0edjzfl}ogr6>*IyVtLY>`b zvoUMU44K4*r9C8{ETW6P!Sa)qy|ACm8iRgU4+6fNs==&Y~-c&*iDp`bpV;SF=doPUTu^m@vkX1pcybJPK0E2 zMc*Y)Yt5TAad-5`U4#PHCPcK~mp%S`wB@v0;Q28@1Ht>nx%zBE0NuXs z98u=tecIda@h}$_1~Q{&n|XxX404VBtE&o_zKg&f%xMY8+?TMgBkFEjJMx)%8&sMn zbT$}f`W9z~dS<3tBXQM=vZ zYBBJ)e-7o;g0PtPli-6f`V#PHd$ibkY8}0YjWZ)+{>2Cl0|8&<10=j+; zw!S)75BCr=hXyT*{*3!)h{X{^l$yMrD(4UhhX${s7&{DcEDr5H=Us>TeK?igu{A#b zvFXfl02hN3dmPs-vpMXkGA8W|IM)pLl+gbXeN=GA3qr1zT`h_G2G=P6$Y#kIJZ|qH zBZIiqRnmB~x(*|tUK|)Bk^iqo7$q`Dtg4*egZ)UVBKn}a2+uVYlsA{Ngg0H0S(oPz z17(Nh@q!EGyO{E>!u<+rml+JP^vYWVhFpK-g3I51G39uLiJxK<80NHE=g&eaLGBrK zZr^!SLc9|iyj}~K_}GV(SbbJ-$+woQ6DpKjP;H zj?~_%oX&2ip>+-4uLbw3Ua7aZZvcT`M1S`B(28cvgLJo3)@!^ze_I5{@&fsn`9$*= z;0yLY!~0>5oL#XvQs^w#rQa&SuH=`PA8scOr^LE(a!^Y{VT$XD;(m7F=Zgv={#4&1 ziWLe4%?Tsuln9!t9a@axltJnBbM$z9H}rmXf30Bl&xL3PWFrXMqdbVf-@~9FPsE=) z*!cS5Aw(EL?Y*Ix93W4VlI zX81`HoV`=;D_MEV7uoE?l@Xm&^}{vkh9%M|cDL!-7>hCt>yk1I$N{16*DLOaHK(mz z_YIx90n$l&09rW8WodVgK47vB2Xg8~lg)=+tA67q%ks-F$3!U)?|Fl6<3wQ@hed|F z{z)Q6X6r&J>|v$i-_^(8+TIOqL@w*K?UQ!?4-;p|*6la8*iQb%^H0A}<`b`jj9hE5 z)OYLhK5@=iF@uViwisM)-ugLnv1aI9D?uvD{Au3MO%fd_NPZ% z#r=B{`o5ZnqxMewGArhS7ckwo`>Dod0IhMw0?HpZ+D>uI%6NMQ!Z_9+*C(3?-cF80 z7zV@@46FeL@g^3|BAkt~DrbN})C=_{HpU?Ai?U?V=#yID#_|YunMFQ}Bm<%5FO>c9 zfL68O+3)B_yUnZ~Am_tQX#jya#O!W>tN{V>1|Odn_Q`wL)+_Ja4^j{I6vSyh$0Bl# z<&8epEqD!XM5V9+(n9x>yrGTN3HzemS1D}3wA3hUU|pKcnUd$_uX*M?uVKvWY<2&j z)R5?KynQ3x}9;HpT$0vC3Xy4yb2%h9i;`@JFb;A-%yG_-8%D{E&bTPG*`t7gUOj)X_ai{)w> zUzh6bQ=D7(uMW4)azfjl__~Icda4Qgw&YGLzKzeKr&-HN+_y7JGFywrSyD#V&`5ZU z<@U6GnaNNZvViy}=AE&;?|L*R%l=d(3k}UWdR4WxsVNPOHsEk9bhrTxhlX9=I-8cK z!GTVw!NKU@^P;i?79htIjJ1@KDqBggIHy;mz4-UJ)(2uz5&qiR zVnf^NbUE8{wf%Ob@E$3JlrwvsJ9{OzlWn1;{JY)5$yD|}u@?aO_)-|%2H0tsma+M| zJ@R$tj!~*4NKmw~Rw}(2EN6GDV0W%ycclU_b7P_PY!7%yt%or@>>Z5!CI;TWxUnwM zlKAtqfUHZ9*5lgp4felPGC=vqzT>9uR{iuj%;t2#K*}{cnZ7MRIEx2H)_?87nHw*O za!7Y{W(|SPtrPIk{bG$Z%1PvXp=fUg)j-DAZI{TOm}k;|CbNst%59r^)UP&%6IYhz zRp|`YMgz`=$GxcgOQL!Px!Ote0+)z>_LjU~HaHb`kC>t>ygr@;dsnSidpG>+KH4$n zt3BrE%HuY_VOL`Y8Q&3ij5A;eLRU$+Dw?)&gR$)F4&u&kGl$FFm-VQ%9QTUN5n6kn;*=7t;lJ2T;B@i@A@xxlneP%8 z%-S{Cdm*yjkQB?DW$5kHi+@g+jO3JN46DXMSfe;-zlt2-(bpLKV(yNo|tZFkdJ-*)v$}kcFbpc^$yje%~dWxnE+ z_kFd5f@5uo%jubhA z=v<5DTnkw;TZLVStJ(qdsDeKr2TNf5h3M@{6xI`gcTt$O4Av9Y2N=5h#CV}`5y#2q z2At%1EChSaF40loU2veCToA6XZ~`cpPUM-+5e?$wv5Y2h?AZ=~MQ0c#r4^D<`JFIc z+jVyb<6-}*lyk*NBnxB0-cnkSY~osSj@UXF(hI{LA*u7S9uMdRqmJalD1lK&2R7M@ z>F!4UwU`&@PDUna=e#Nzb%FQb20u#@ir=5hh~L^mRRbttO%f<;N|dl>K^>KlW`#G z$P1csUpDE@^n0@hkhs#(vK$pE&#A`~ zEwUnj7xqWzMr`(aH|WO4GM)S@?Dt-8y_~JU4|;s-Fud)ZIRq=iqWehhmtK>oH14;sIqQkI8^V)?5Vh9*Zb?1b(O1FJ4TAYAfB{~}Id-)(>I8zS`>+5Gl#`s{&O)85H={5H61V{my>Wp~tJ zK+wxkTCkfro1~Phd{K>Eou7+Y?R!EE0vPjd&|}uOd5v19>HO83g2}}Xj8FIShqJ1@ zxa3W*&pl{Tc-n%>2AKQ;olggjvJ#R+6&KpU%RZQfzQaRAi&Eu`tXJyFk5ol1keyI3 zIA{nu^lsH{EBmC}+XR-svt?EBadng@Gq<$Mp~6@YaV;Hys?8{ODvvoe=t#b%h80$G zGD;>k>Bo$!1-dwya@vntcvx~Ea>?u9M<#$UMzV)85jw1^J!wE0CQrbY?NWu{ikP{{ zDRTQ5m8kB13HaK+cHQujAXp~i!1VaV;!^rc>)PV7LlFBA7EgeGMYwC{+O|80`D%K` z_T&_FqG6G1eS@FZgy%zd*$ndPTG9N%y=}`Ba&#-`Yw(KOI853y1SO?I+8mUS8%D6s z2Q5fj%!ADvs7a!)a>ZQaL^j~fYl06{9B(;@-M+*$>3lH~m*Muelq;ok!M4jWLOQ`v z)uq*Gp!#sXX%7OUG~sH8Qw9OHO56 z?cFB8^=Eodj;_Ix#TTkNJ9?-y6@3Zhv;j3ybT(#F@|6{4TM1 zdQCyXf+XZ>-%{$we}5bi4Z;wipW;qUgQ?{A|3G#plOD;|V}P0`Ur$3|ID^dg*?nJ1 zSJtYqJ?|q_ImtC5X3DG|tv>-~0B3+Gsq*Ecdlqg=JmBd7R&x;_nydR!x48cTGzWAc zh4o!N8z7jHIRio=BpRN|PZ9Y>{ zdM8FHscj565c^|_=lBWk_hRw+!TP6%l50Ms2spvMu%2KlJSN-8Ucf?Xu0^gfnyMyS zUyXi9iGm9nBn}NViwnJ+-GTi1qE3aTlvGM)hyf3f>H0k8p)M3w^O-y0UY7ux2w4bA zPZqh6-Hufto@`` zxY*1PQ99BLZ|1!bfcU}f>?QJycrrCV{1FiOdBW7k-+NQB@xCkM2GBKca&jJroWHl- zk*gF!1%D|g3fq-8b?lMSO=k9JVvd0IqUh$Sr5hxrQ{p=hHHby8^!vRTKL>MAmw(W= zSTL*X0lb?F=I>_ZP&s@&;c^OnWkJ+xd!u&c-t}GlFB`F~(z;b7+bG&B+k*;!$P>*A;T|yf2;0gQ z98iZr(iNIu0mZVxnZfl(HmhF~q|*Oju8s}No|w3hVw97!`F_Zi|1+o9_h%SR8V&$bX#2H^di%zUKkKk1x#blk~+kx9*r( z=Ifr9#0xDyq1$?vG3F#b4S^>QG`fCz2LUf2`~@+Fh21VV&gJZaFuQt0hLM8Ikx923 zdTM-Z2lE0bq-w8mrWr{`K1~U0u(Rzcev0FIdO2$FINAt-r%Z*sBv!jay~0aX;Ts^P&DbSuXevQ$eW|Ykt{ZQ!rh71BMjfEF1MbsF}u`L{nSy~Ep7&@#eT(g0>)>X=)Fsy z^(`IQI0Tdi_chqw0NZQ#OfQp{_~7rHNG`Jl;GVrSEG33S$3XK^@>0gSuziC{EBI5YWtps#rcuPT($SGid$FKh zc=R75{;D8LwKF~0msgurg8CKck5!x@>jU=2%}s(|#-9S4ge*ko&)hS9X`z#F^OMzc zopqt^=aTV(h zSCf&hqvhMGB$yah`f6DE84Ji6e=?C+Lmk<+b*$PJw9i|_rgb|ZWmGw9?$)UF>nXB| zo&o=LRlC&L`u!6c@dRreAhJTSTAW-<=b@nn{bXDkB#FEjFWbGi0@e#^|8yrPG%)8PM?y6#)?#AuMzIA*jqr!_*jPqTECFs(zd zGcT;#ger5`1fs1rd4NJJ|F>9!-)?(ESXGFiXqo&zgqe44ncq9*H*^pUC;gJRuOw*f z0F3o{SJgU&s@^!e4Bz8K$+5?W$AzC2*=Jn)#U`s)CQ7UwsB4MXZgShc-(^eIyKgLD z-qPg}9&o^y>2MyB;A4Deamj?@4IegWJ4MV4!FTb|->^ou_$QYLovB2`Su5GeJBnu` zrUtQK0{_l^t;{V~#PF#?yU-qcdBg#+voBHvQ?6dp6$de2Z;7?WIfEUHw|w02uNd-R zR|6Mq0m_{c*+lwOM`@SY^LdMS29QY~My~cJBzr~CZ$F9aJQZaw&s}4#-9BdU&0%v; z%>;NgsZY<6u?T?%pN*0O^$AS@L^|xv`Q2g1_IfAk-G)deX@g%nbhm@9^n7`#?(*zW z8^8kLGAO528OlW9khZ~2G}Q}#0zIgifSnpl^niJ|_^Si68+Ng)*Iqy{1z_=M?(lnY z;i+XU`)x1mo$nnTl4B+;gG~a9C|m5CaR=+K;%)a$Q5fuy7#^Z~^?;3856LU8OJhD= z|KJiGFgTdLwMITpfz6c>0fFIJjt#99T5y5;?(?v){|0w?F=zWB>e1Hi~50@$@?e&nz}a|m3>jRAPF zJ^^{}0PTCB@93se8=!|-zZ$d7e=~UiZci_#Z!foR0gohDAfp>dHl;M=^0;l|{j+8F^&siMh zyf0-Oyd$q6IiU3P5;x#>-(nAU3?R8{kU4Tas8C7z(TTZLCmiu;cj=@-%Me@?JNlhe z>{tZIlf<;(3RC;N@UKvT+xIjKsljGeLo=8&=QgDfQyH&DJKG4OZd|~OEsWR1ITC}Y z!9o>0K4JU-p37rrr{=Bl-N)V>E^|Ep$A5P#i*>Z^0vS=iX;#C)jcCt{%orxkT8B&~ z=>_ts%QXuStX7RaZ+ObY3j8+@`-fUjvg`QL^yGo%j1fSsk{DVzL|N|IUgZLtUy?Z& z#c8*f=r^cIy=cy*)GY$mOcrBds7Pfm!TEKlDnIr+`FLF677! zV~EFYbzl=w&ZAaf?HNmfPQ`^#3#8Ub3Bzxr^pUC|$dbD%vHYVDub~>D5<}>bU)eiT z^huTia`Fj8Rct<52$*6IO_iJ*>t%TB@*;GMd>VCh)A8r=PJ`k^i$cYH$Fc$KEU#n% zlh5--h`zBA&OWB>)74uhqW{%p011nF=|Uo#X8mdq93hK9-gWP*?~}E=Q8{SJfz+hQ zvnRrKT4BxjW*g|{KGmjZc+CzrJMaRkp}wPum>n`1LtzJW2urj9LVarNAIDEGd)?M5 zS}bMAH}+Vya0Fk%ybw1i{1KlclwbS{(u``AS!g)>sstL58gd!RuXc`W#f%M4eW7Z1 zSkOqH49|`D>%U~%8Au#i zMb|G8&?{o8BF8~n#P8t~(6a+KNMKr)4WxAX^`mq#@l&Pcn_rRwQ7YpsE(u81KOq0! zp#E1^U6@%1r3I(o0J^ga(}F`EP`?!pVfaV(gOLrt{pa*&bXjI87MXEkFE(BV^%xIF z(ECx3|3^PwSe6!js&veQGv6`?=`k5jzs+1&*A{)YM`ir}J|2wk%Un>GCwsO>q5PAL z{>c{A_PR`>3!veOkc+I^r>Lnahv+nG{2_OjA+SyuWay}Y z#mmk0A{r9J8)E|tu=w4U_J6*eR%)j2K(Y%VAeNa}82W!odY$S2{8IpRC=9U(3y2Ne zGE?ow$u4UNdhu~1gW+(q$;9s)D;XkTD*=CtrYn>C;FXv8og$x`7G-wzAi5AIR^_sg z;P|wTOS*u7j8`%GSo~cJ8z`{4k1KWvt7!SE*4#D-MQ5bzi*q=oCyA>7a9#Li*X9@T zVx(ZFR_E_T1IGK}&foo{l?wQe#&WZRCq|FWo^tHkMoykP#;&U;SuTp7+jRXrXByeG zx!cvC-KL+xc>YWIlDw@8p`*Pt?%ak}7D<~Gk>sy10ZK`>{8?FH{^Fu{lR$+*aBY+2 zz}PPG;_#2+Y;bW+nm03i0;`q%Re$KjGEk+M)3L#ZmuvT2MM()iz}hoTjHN0WPi3U4 z>+-p}6pp{>WQ^+HM(B(+h0_|)Y|{Tq-YalwVgrZg6HrC9%c0+`WS1$1Qk;*zjpfwNki76>Wnzxj9S46wWvVj?0RJM znslbG5)yF7zS2cFirv+h8koq4ab4@orAjJRhMIVIXhN~@;V^d zo)~tWu}R3dH>}S8@jYO)m!(WD+W75kIvHWlNfI&YBjH72^q zrRF&4>wB!#rvL!8*Xmd2gd7_azxv&ArT+$7RhUp-M<0EC#hYBem_0< z2{_Wy%TLQqR6I_}OqLx|YY3nCVP;?(T>`NA0LIRMmD6vA9|`)eEmS802ocgJTCacJ z+{m+$IqhwuCn;fY*v`$&z}XRTLqk_=Ff=VAEVN;$9H8Z__qz)Re}~b_Qmev%O4}zIxo=_oF(;4!_WbZzA)S#?X7&lQ zoqUZm^V+Xw@U*&rkkZDi|C(E2E9t4o&h;5FI1@hn|K|a4sXHkjB#8QjwqFU$G#Bf0 zB|TpnRms%iMY{+_6Gv$Lc+-6{GaRt`3>yp&#}dY~xk7rF>rpwmbeSas^{aK(ZEabq za-1<1Lt)Cx_}q2jb1gV5@LsrQlE1N44So|xFBi9EtG?~6_B0X{=Ilj%h0^FfSut8% zBrOi-6S-~z1TZu{x&nzXy^4)Io5YuaI`$m!hLIQngcapqyCz8}D8XxvamyFKl@@Y& zC=>3Z+i3{ei6_W&WiyMf&Tx^=B5kP*vL#gyMC#FVwAgm}u-hhR{-rvv#FE1GqSwic zMb|ufXHs5zK0`2F7*Z#`Hp}+> zZahnM-W2d?ytj2ChcNP^ypvkH*=&nbj{l3ny}EAavN=54#vKKnj6a0>o}B+fHh5wC zz37f#W$gcJ%e7^Gebsh1@dDGi};c~!+!tbS&FQ@Q<1P~k=SS?4hQd>I?)FzP`iXu z6hg)OoqwyU@+!=>ga98?`FuIJ@=rkM67kz#2O*CEeRk0q_X09XZfmdUo)e^z{K%Z` z&y(24Dc(@3{-6S7FVzMF?U5!g*eWU>a+DO+V)W!D*#+)YnJN}`HzhxxyTNB+S<*!9 zH+D{U^}7tENz*?kN+%I4xp7kIn^$uM8K=r=6CAWcOWBy2=@__@Lv|_+4Km}(%+dA0 z*ET6VTZ1(vBT&L5llKjpg=s?=UwUP{wI)0=1FY!Ld-X?FLD}*p=+#>=JNkCI`F90^ ze*f^oNE^r<;<7%s_0@MG2rynHZ3V3>>*37dapnS9{Xbk|T?@ek0XX9qsB4#l3ZQ}e z^BJwXt$oU7jlBvV3e6hz!?7BHM8=}1KbHIdfW%^4M3Mv(MUiUXz7q#kACCSw1x2!7 zYE*wyYBQ8Bqey1oQmCo5(6*uHYQvdhLIJ%OO4i@XxlYdU8Od5)p{oXdN(Vy)lh1H? zAUHp<5dseVDK*78f|XP7Pg5DoZ;l<^0!)>~tI}Q4JjuI=74RvUv}(T67lob|!N>_c zbBh4Fy0|$(#Pg`mlJOzI!#JU?9EEC2+*=pdmE+&aGwNPi{?pGpMF&M;YM;FlaRdm@ zI|cyw|4UXH0MBq>rw!0|s5v+uR;dRKY4C+o53^sN%N!l9xzz)jR#|o2?V4*d@X$#XJ^Darn&>c%rY+#vp z>f7k`~Fw#GDhX^M*zYLyZYlE#&d{Ju!jhe9T zi&PGS*k z*9sI&RFG9c5**rxJ_w$&_;~hqYDOd-E`uiT9bGc?=_ShWT836=fWS;cQ$|=MQkD>h zkMhkB&?28fTKKH-bCKPh%^v1kZNOG(PTZJ)w#6skf=&1taP>@*3!!Vm?~23ZeNL7V zY3r!%1M(ZtDs7$3kG+T*RXec#{|Fuql(br;jQ#4oxBe5f!k8u>?sXtfTU+CQPLR~8 zAJwZ&A#ky!v3axrZ0)DyeZB;5%MNb(imv3ehtaqL!ip=k)iQ11{2W*i2;JBuI4wj1 z`X_?_*CsGXS!_)Obc!;Er!Ev*Tjx5U+rBc^-JOgWTrXOLa+OIEinD+xrpe?edMX40z@G7E+_R4H~F&JDV!VtGZqn zJpu`YZq(ClB$Is4>h=%27yhVb50bD^!f-N+gvHtFM`?KNKZRuQf@wJoOmz#+?P?b0 zu90Nz9Iv>1fO2wa(%j{nYAZMk3@QcVAk2utk&48NyElXtCrcN%UFbz zI!Smt13c)wHG!AYldy7po+WnJj`RrPwsg*306`CS;(#S04DlEdrR3n?&5lGZQ#{it}n z=+m0a!oszU{(i40!Uef=El&QslFn(?$Y6HxE)tC&=d~iyAa~}Hxez||I(&T>+No6f zNo6X6RYWsp<}nfR&CF_!pk#z*j8|@K7^ga>mG~Bx2lQK67kbw~SdI}T54iw(TkN4x zDM?5IF8ysRfq(fPox8!W{G6v9!hCiX)ywf}Wj&2vw2mjbeb%mYxQJ+DFUL{csd-%K zpoe{^ZG<1{J8A85hRd2ic-*uAC~hqLbue`t?zZrd-s*B-VV*w1_u+AC2(oYa1y&e! z!kz`z;6j#FtX97PL__bK&v@G0>G?0aYorX2?awAD!7c$8;3`&sF}Gf{_G?Uj=a<9q z%dg=I@cC@d3V#>Aj5>IggqD;5>%@wcoXok}2_mkz|$C;N~q-Y=(TC zrTDn$8nX8zG?ePz?fsd^qsKU_s!;aNn`8J;rBgB+U{4J1kAH=S8JuWVr_LGGjA=q` z70pl#h=LawDO+gwI2GrPlp}qSdGYj~CYcIUMCMdy@A2?->>eP%kNqhC0f_4d7~cXgKLxJm z0LGAE2)^)?&p>5XArgM>pk@j{Fobhy2QR!>7Z?1z`T&ulf6D_4YGCEIj#|RnbL;`QL02&&qCt{kD!0UtuGNM&K{Td8EL}q1ztoK&pmz@&$g7dNDw{M4J=(V z$Y8IUd9e$Kj9G^cbtcQ8DvzX3r%t1!!b6mqUco_PooPbeuivQHN>{w}BN{0|M}NlO z$mk#@c(olPiLxlfr$$ktL>qEAHK^z*py@0QvZ_6pR?vPy2_z?VrhVYM*Qa$s8n}T^aNezuSDfG7G#WjuJLL{HW#p1XB zu6;N!K~Xy;3k+wvA8i!u6uOeXI1|+F=JEseVizO_hEhdYMWWNR!Yr;ID07+=E~>X6 zs=lw^PNh!F(Y6Sxoi@d6V2Y1VZ;J`kU|gP4aF3_$!%QQTj#mvK9s7pCTQG1%X_%C1 zL7h^UNBm_t$5Dj8-7t+YU64X)JRksirap_EEjtE7y{C#Yp^31bN=W7`C7VA6{ZF>C zJnM>?YiOZ8LJ(4F+Zm=(mR#%AqC3Qy=nQ->y=6(9yjRuOvM-@(z{h8+{)&_q*pRUt zRCo{~xUwl(-RX#+xV@!@40?242e!KKqd;S_*@WOXh>i~p0vOMp518A8!?ZuR;rA=b zwe8sq`|8H?M<($g{TTrDQk%azI0s?)arRJ~%`_8@q?Imox;KZ;;BTN!oU+a75D^VDH26#MW!5bcs{?qkfme` zaLQ3Lg0+qE+PE>?EwD4x?knh+CmE3y!%7+b7$E3+O{RDDv1%cSUbS-iqA=sZnC}Jb zK3rqD^JU1A2M9!nGX_7Z}07^i$zoi1yHf8qed5F&RNwnU}Cf1-aFu`MBipQV^ zA_FNV10^N^=?NvoUw=9D{{wR|CvC;!(SncRa^mE62KaDFx1C$c)RKALLcNZ_nMAwg zJo3m5F>q=jZA6`7#5ofahQaB5&uwOayv*m_?ryhpQ_gdv^~Wx8>~uf;a(RCG>uI-i z#MBLPvD}91XbCO}SeK;Lw^!&zfdW5S$)13bG3Csx21tIghw|}KH63`1cYz05dY!3g z_N7W{ba>YfLOk{HoRh1fGPF~30`4S8{+ecf(MFmre0AZavvvU#yhd#cm7KmU_=w=U zvh_=!=PKF{73XDmD(eYULA@bif3a94dpu#at`|8VzOn}*+eo-%i;6r)KE{*2W1!t| z2rvd4;eLvK>ZIhYS?PX_X2;o>o*=EtR5|97%<}cUWrSYx=9E|1pSXqr*NOP>K8Vn!e-wC;9yGa(cz~zUT-wWk)EO7@eVp&2m&Jy3so0vwFC^fS)?bc{XS?S6Rs+B{-TmRO%_3-Vna5@ce z#{W%l>utkm?K+J`{PZ@MgXw$q-u>_%-qnFae@w4S_d-pzfl-~0Aiv!SO&UcZgN!PA!G zhBqPZ3{E!6v+>be$LTrp!LY@uv8khg=2KWf{stYMw!wT4Sy#9|Ja3{9WJ1N+wn8g9Ze>fH8FFPb1D>4> z>oo(z;8O_9O-9*WL=%S~SaNVfatW7|CmUp2`S3r=BzERM>{GqIgR{%wZUY3%cMGLno=1PZ96a-MUc~s7iF9VwL8+!}R`CH3FeqrAd?!~GZ!&r@% z&JY_yO|s0v1ZBg(*R5luX}FFPgi@s=bd03ra#Hg4@wkUtvi}**VWzoO89|l|JA7_S zqIW{Dh&yr)DxI(|r^wJi18}YEaRMK^y~hkol5d79wd|Ec?(psY8~Q3zaji5RG7kRS z1W@|w^mWI14LOrH$V8r@C&1~f9P||M#gHn&Ynxd`x#jZxz9{OH&zAv(bb2Gt$+ z#E0n+Eu5}bqx*1WObYPy>(H91u^h4cM@+Ajc$!B`v{m-OGm368hh((aVyok!EFy-DR^!o7Gsa zZ(g4?+4vPEyXc%-O+Jo|<5?p2W!s2SRZBQ=4tXL_)5}^|gj^P=ZU2GylLjr#jS2!+ z1{^X3ot!7?9fm;^`jtS_q9&C3hh z7o3`}VsUBuN>o1seFfihD`^9~603USS6u701H@7QFOj3fB)5JNt8mB6X+u1#7!@W@ zDHEZBFV@YUZxW_jV(K$^k%e*9=cR>_SI)c-glP`gA#%E}!t%)@HM-Kxi^(C<8u^pvcxD8ice`E3OLRnU)*<^{M$5buocC>%6b8GbUbb z7-QY@X%P*_mcJgSrR7I#S1Js#kGzG}fWpUNzlM;wK)SMkd)pUt`ty&7iIy{z%>%>C z9D^h0nmMyfmiozT+B7O^s!idi?;TyZPX`z{Q&tzCSRw4h)X3j^WiQy@K!cLY)qT^- zHx;tJ=t@l~ADod^HRnqJdq>PcGyCf2;_J9u-rke`2(r@z zYRX=e%BB0aQ>pG8Hi8p5M*{jKbWg3758Sy);Y_P&g*)PNsc46nunl~Y=TEoYFJ4^D z_60x6N~hO$94ZRm~CiiWN2(?W@-WwH#9IcGh7fcp3mpOJJ%F?z zAOg|@f*>M@-v7Td_ueyi=A5TH=jrY>-+oy8VXfKUdiWmpp6|b(|NoGX^mYmQe|0tg zssE?EyrQ(C(*NdPR#x#J{^g_<{=fg{f6IDgL`cMNhwPuA^cYk9k0%WOz(m*LfrNpn zo|MT0Qv*F+a|=lmy>pYPNn;}k$vJ8x2~q6S4Cb-)g4~y#AW1_LaRZaN&>AB0*N3da zkPgO*N>QS{s_ZNwrV7!Ho!s4u`#E<)_l3iD1&*G64>}9F`%iUJGTQ^k8smR!{g>Sc z{sS++P^o|Y2BrR&-=Nh0{R8aZJsL+E!eGh#;Vd!}kH_ZcP5ThU(;5=Qi^el)C$U8A zmm*%gj;AHyEiGfns2AoTAoy5r@J(AwmG5Du;74r$S&y*IqkjLBXek()OC@O|W^dXZ z`W(7DEtpgk(+jvGs*Pa(O*>#NN1|8ZQBH+09Dj(#=j3FtG3KtQiAW5FGvpTG`uf-j zXz@izIDOeiKw+yyW<=$E8m$lRM1M^S-zcL#(*E9$t+ER0I)@V;DnB#K_CwLq=B`K# zQ*&|Bz8CD!D${Qx$FgWU%k72RQ{fAvr36^c%k`KhL?;e?%@~*PD-W1 zh3y>;?5rZY%9@xCD|uV^{3~hc1r@gJ(I-t*m=@_~ozk5+X5})hrvDqx_k>gFe}M7F z1LR*@@GKv?Y|=t8TuV7RZ5)`z5=nk{DpvE6S7#GM6F6C59#5Wgp1N#!bikwmklS62 zJY!r6AZo7VN52clm{LsiYs)5hB#*^Ug08;2%tXr$e{~MbdzeQrE3hM2;chtDFDvWe z;q*#G$lOWLurkhAH_uQu+oOg^83eFIvY^?(j`a<^=H`_-#=hZ?4#yU<-wFZ5&YO)3 zjHB~NfMH+DOC7xLKVPz`L>ilSN;*~M83%XPCrljyJGSqG1;!<}Ipf zVdZW4r8!{!zE@OI60QJ|){M$*!;vh7KImv&l% z#bm98b?q`{gmn4sv&Ab_`$tQwBpz_z$BLhrcH~x#R@_M+E3PUEOkRT9a1XNHL8U$N z3zM4Hu|_K{du8}$9pOm)@2noEut%}_=Qrw~q3=2Ms*)XFVi~$=3x%OBqd8EzQ7dSN z+cUL+rZmR|nFp{gUyo1YnKdZKROs!y2qQ0xnVKSVjfRK^3idym4;dG0Yc}3GnI~Oz z+4a7SF#3^h7h^54Vcui5O^z)W+Nhb4lx)~5V6NZe2-h&L8S961T38C|-LuO4^*6il zoZA|D8RM|BBJ~fxPhc~wp>6M*gPl5>gM%9IL|(f&{uMdLyE8^rX8L|}dVYTg_H=~e z^Me*vWMe&l$Naw9PzwCJD(LNaf|=a&^=c3G@qd0j$#ngsJwVVwMRWn8pq8D^V-Np1 zhda^zmf<@wk{JS}dF7?FCl*PzQ!>SyH)u+~&m{2t&(`gIJHg!_2>O7{aFta6~L4>W7X%d>NqofOP}|S}nuyg6AWm2qeWbMHn{EjAhz zU0gV3>MDfcZZyZyth~j`Lsf6+)Zm5VSXWI?FHA756R!>h-jH{{a2%6#WyToc%vLJ! zvQU-oILGmNS8L2OTq|A`s?i<0J_Z}{b5+9F;+ddgH!9s}>(~?L=gr-?bvzeT>V~)* zb^B_4hReCnm8LlfH;AXZ6uwc2Ox3^^Ih!^AGZ46Wd^?`?QamzUW5&rDvyy@rxRi}d z=$U|xI=MAqlyDrEf{`gb)1O_wHUGrj;0Z5zZxFXdx3SSvK$jTz7}prj7?!Z69L>BO%yMv`sA6Tkc8fip32TGD_SwP)}I+n}gh`=2! z&Sk>ty$FIPJFRfswF8;) zVkQWOx23Tyl4xATuwO=C;hUXg`s&M@)q6})$DO33>ZmXAd*lTd>IvpWd#7n9G*zKA zQML8~dNhfc2;qYHln>z=^pg7?y!H)b%s*H<%9rCNBg7r%*as{%xO(U9`xSaP9hTMl zsWs?=E=~f>zY(`z00Zo~$(~>E23T|7{dpl1@TB+-&BgfXqhb=&h3#n%kOnr(-0v36 zsy=5uh`J`ZGMI@g{&9So(o0%&c(ZAJEB(8YJ89#`{Hbx@otYnEr%5ov2Yv8rO_1g- z`Sp>Rj8;s#AW4R_=u%%GyIAfYx-~-L z!ak_;c5RNZB_b6HrLtR7qij~m237TxmlXJ#iohgpX~Iz} z)p3D(p>_TX{UmxEit=o3{ADVNil3YTWrT_fs&4Ny5Ywp^K7JP?OnNasPv0ZorPAR( zv84E>{*>;29p{_Iio?E6IZo5X_1mO3usmxjYa)N5(B>lKMgvv6=ghn<-0N8|P(Pv) zwce469HBOrJ#lS5(}2psMi{nPp-Q(hiwjLjtca(cPWY#ZE>dy?^V6?ztKvzlo*q;3 zwQk%P$x8)xXH7Y-oBVfyFIMi7zHtnAnU@NmmX8{o8d92$RUYC<)|t*wp5j0aP9v{! zR2cPNV@`d8f$8$OUxb4N(iNAtS>z~3->3x?{31?QqS;d0m5EwbPXkO*UKNEiZYcS0 zfzE-ZvfSJ5=OQrYKe6WG%rFS6^5QRTrD=-(11sL&W1@+2bsv@IlLu_AJn&;Fx1(P*mHi#yDle2o$(A_~6H1M#TkRN*K-j36B;wgN%%6knRI$I| z{kzkWb`7rY(2>E)|0}qU3rV9ahL=9<8EZ#$W;!WpuzTC4OU9{*q8W&Z85{YMLmo8(Eqt7Hhw3*9f}w-hl#DCeqJ*C};eMBz zUY;jYg*P*J$7cTx6zZ5sdx74vCxM7gvl;T(^8pxU;0Xgeot?&^GxBVQ-9{PB#DztK zCBHKj@zl+AW(Lbq28U+2;r4&Or>BLv2{Gm{w1~Zy2KSw^Nb^v}{{=a=OK*%5Tv;~! ze!qp@>>{7ov+gkr656NQC*zZ@?SQx%_<;?I*9HuJab34q9XYfo3N!y2(Q{>fj4w4V97(eMjKnCj${ zzv8+tV4VAxst^0_K_h(+mamQ976A=hfqV|2{nUrNRz=J2j{Z*nwL>m;gDldMJdW$K zwo8XHS5%4&)w2uD4Ukos;P+W!f@-7ov18aXFb^hJTuNa6N54JN>qo!-%EQky!am?kT(r^?q%KjRwve_`AX0SgERvrqS?iv#FKb5Z z6vp;Nr!bDYox6m_5ZR+TGf5HJwkb}zRY}nCmS>{H_L>&$!`l_t&NxyQRiyWeAT5YH z{bO6E9;(X!ra@Eu3=$C>grM_0i-CgWYsLzHQrtd%Qlwv2GldHy{B4% zxLk>h>*l~G$hGUp1%mrWsyVrg^GC=%2?EUGAzHyVZHq?;Q_&54JW+8&Nj_L9teoK!a= z?L_gb8{Jhm!nU>-dmW?#!DB|5wSO3$Bb`Ut)DJAm9;7)d-}>x+wqz$AE`Tj%iu0SbgPc&P;Qs%28>pPF9`;q zGQ*MCryS|qDr}|UDF%W zV4@0w8&fH*d8nT&1f`Q)ktoRKQJpE=d$hDm(on7{ovj}hyQ+bb0KLRr2;?P(`qutZ z%}RRr!jr|d3ZNEmtAvAj#3@N zwYJFV&L%TDdC+>T7KfM zhs&>$6J676a$f^WGGGt+HFSczQ}oyj`Kk9L`NPY-!pl*?+)e63hUy^ylQS@vz5Hss z>`#{IXTnTs>A`6SMr`Kl2TDj)qc7N39lw5tZ&o>1gyq8Kuac`yMVl}%K*y0h7v7G` z$D=L4vd%A<`jVdwKPrzi+c$k{41Z^MYrO}CO_W8&nr%y?KIZBl%sBRpl}&vOv>XM} zi^l+mBOJcT#Umw!mR+xSts4ft>`?l+J93#0rhZd-(<+#|UW%JjmFk7ljoQtV;}T(p zc7X}v;zofgzu1F<*zGY+&;s514?SoKh>K=_NQ6Y-mJ(wndM@G{doUwwe{y=3!_lf&e}9S0nK zc7gMyYZrI8rf9jSEZe&a)L&Sw^7!4)Wgp-14lmG*Ut~*Llr=0=Pqh9N>cC(8EOjS6 zxzm+v=2KX`S<3rnqv?>lL+$e68*_1DCFATmnMyfc$B{*?KW(Rn*A@f0T$EALuhd|< zLjHU|l@oF|?iWp*sb|~UOasp3YdRM27V8}GmX211`rb}j06C zW+|p{5rnlxwsh6LlY$gzKC(9-;Gl9Zz$2b1Ef(1ie}7r z7Bn07F@2xtb!#^@)8bma9gk{qqfy_4WS=rHEw)7cDmW=Udsl{8`JmA-8gB<&Tl^U! z@LA7d)iMdX*0ydj+F1r;0~~hHLy}z8jLET_V}Zui&jM@PB;`-M)eY7gtGV(XY@{{J zt%t>RMI)0gDFhduE5M`_U`h%wO(ht&pnO2l8I8pcP7t+YXc1b~>`|eH!ycm9FPXE0!ywa?Tm>Qz^C-prMyG33xYic+B$$+j_)rWsE@ z?LbcRc)-&z>@}dxRr}n~flF_P4q>MZRxW)Ak|?ZJD=k9Useoy;duUss@3d7NS8Eqm zL{9J~PHG|97>98GM_j(yKK_B9W0X<5ZE0fPsCJ^Y!ixhw>lf%l{f{QpjKaAe7oE3{ zju!k>*=@yag*O59QhrbrVB_`Y?vP)33g`)Z*#%k&e38mi&Ta&VwYG0{(D!J3w;4c! z3m(2Y{NfGe_7LAmrNUNEnH-M}rPo(FRSbD7{1sdHYtVJb#opnkQ@=_k78+!Uj_w(y z!0vxw<&-JIh`}qzw++27b-XVL{VrixY(HMI9&?-1Y#kU`rd;-7<}%V4e`v^|kED5o zp?Qq4zfz2eKcc9objY=`R9Y4>Dd}QYncD&-u->yi63A*o+DD}W04g#_`|{Q5?%Lt; ztiC+#E?MEU3)fem-)!w+)lE_>OQf*B8d(B9A74A zhQN`%Caq|dO?g487QT=;*bj0>;=nnt3$@vE4o|9}*2wtDbY2d;ce|RUTEDKmhmON9 zGr1_j%}3UMcvMl(tF8D=OH#6qR8eMcA=1pz*u4klYE#Xd!)ew|ElJZD`m+j?U)#wB zkN$-C-)n#MQn2Pu6vB1Ke*8+-fcPW(Hk}nkud!8Z`FchU^RbLCjdO9E{>!wWrnI3p zez5=v0;IKMe`Z4g^OMWY*D{~7Hy^NOD-Y(&?YfMxSSNCO5C!Pbdd=pyX}bv?e4B`*X&h)wz0_xcE~;! z=1-Hu7X&hT8i#mTl%{$YfZ=lWqp9@PdX^K_Sk}CPKtfOBpmoMpkupiI+2HK)dbFyA z1u6v+sX1)9@H+WT5I9);&7r8bw(fLCH8GP(u&K^7(Wh`o7r=wgI|Y&m2<2NKo--CY zG_Dpy+t&L<&>u~&&%#qy>d{UXS<|{LF-6;=Y+AbT4hTZ>v1|Ra`b6+bfFyf=aHv|v zRB**tupzK2^=p=zut%?$hkOM?kRe@FT~!uweU?m?Y>s)d$_~)bc3*XdFl%e!Gq0%q zSJAR3H{||7D>2o03NdQ`Mg~hju}^u;n{9F_$zcF%F0Iq!WFfgC?XagJMI&LVn;sQm zg4?$7xw%_|sVG_}a572;Xd31r0?RuiAF$5ZvS#Ts46_u06*fUvtmw*yz!CLRwF70m zSe>AZ`pu^=OW#q;2LVsU zcHv{oS_-tkI@<*f`fK{;mQV5e z0+}b=yva(lqX-`o)db;wEq`9a5I(8H42~jqo}jR1nOX(93Km40$=i{)uw>zB!g zL7{gSpjDuSI%8dHhHpZeRs&Fn2RK|bUbsïZtTd~HU}HhlLv;w}8eZs` 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

XCiX@}9+pq6N$D^-E0YeL&A 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�V_19x{`n_1a{&uWEe>c{sKZrHy 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

o%seZvNFG8{9X{Xmwx_? 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

T%h>2=3C5Hxf*RVqgoucsUK=cZ9z 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�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 z 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 literal 0 HcmV?d00001 diff --git a/xmpp/Vendor/libidn/libidn.a b/xmpp/Vendor/libidn/libidn.a new file mode 100644 index 0000000000000000000000000000000000000000..f36a25737db3258e1d74bf85711c891895f9406e GIT binary patch literal 1295932 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 /* size_t */ +#include /* ssize_t */ +#include "idn-int.h" /* uint32_t */ + + /* On Windows, variables that may be in a DLL must be marked + * specially. This is only active when not building libidn itself + * (!LIBIDN_BUILDING). It is only used for MinGW which declare + * __DECLSPEC_SUPPORTED or MSVC (_MSC_VER && _DLL). */ +#if !defined (LIBIDN_BUILDING) && (defined(__DECLSPEC_SUPPORTED) || (defined(_MSC_VER) && defined(_DLL))) +# define IDN_DLL_VAR __declspec (dllimport) +#else +# define IDN_DLL_VAR +#endif + +#define STRINGPREP_VERSION "1.9" + +/* Error codes. */ + typedef enum + { + STRINGPREP_OK = 0, + /* Stringprep errors. */ + STRINGPREP_CONTAINS_UNASSIGNED = 1, + STRINGPREP_CONTAINS_PROHIBITED = 2, + STRINGPREP_BIDI_BOTH_L_AND_RAL = 3, + STRINGPREP_BIDI_LEADTRAIL_NOT_RAL = 4, + STRINGPREP_BIDI_CONTAINS_PROHIBITED = 5, + /* Error in calling application. */ + STRINGPREP_TOO_SMALL_BUFFER = 100, + STRINGPREP_PROFILE_ERROR = 101, + STRINGPREP_FLAG_ERROR = 102, + STRINGPREP_UNKNOWN_PROFILE = 103, + /* Internal errors. */ + STRINGPREP_NFKC_FAILED = 200, + STRINGPREP_MALLOC_ERROR = 201 + } Stringprep_rc; + +/* Flags used when calling stringprep(). */ + typedef enum + { + STRINGPREP_NO_NFKC = 1, + STRINGPREP_NO_BIDI = 2, + STRINGPREP_NO_UNASSIGNED = 4 + } Stringprep_profile_flags; + +/* Steps in a stringprep profile. */ + typedef enum + { + STRINGPREP_NFKC = 1, + STRINGPREP_BIDI = 2, + STRINGPREP_MAP_TABLE = 3, + STRINGPREP_UNASSIGNED_TABLE = 4, + STRINGPREP_PROHIBIT_TABLE = 5, + STRINGPREP_BIDI_PROHIBIT_TABLE = 6, + STRINGPREP_BIDI_RAL_TABLE = 7, + STRINGPREP_BIDI_L_TABLE = 8 + } Stringprep_profile_steps; + +#define STRINGPREP_MAX_MAP_CHARS 4 + + struct Stringprep_table_element + { + uint32_t start; + uint32_t end; /* 0 if only one character */ + uint32_t map[STRINGPREP_MAX_MAP_CHARS]; /* NULL if end is not 0 */ + }; + typedef struct Stringprep_table_element Stringprep_table_element; + + struct Stringprep_table + { + Stringprep_profile_steps operation; + Stringprep_profile_flags flags; + const Stringprep_table_element *table; + }; + typedef struct Stringprep_table Stringprep_profile; + + struct Stringprep_profiles + { + const char *name; + const Stringprep_profile *tables; + }; + typedef struct Stringprep_profiles Stringprep_profiles; + + extern IDN_DLL_VAR const Stringprep_profiles stringprep_profiles[]; + +/* Profiles */ + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_A_1[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_B_1[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_B_2[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_B_3[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_1_1[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_1_2[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_2_1[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_2_2[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_3[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_4[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_5[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_6[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_7[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_8[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_C_9[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_D_1[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_rfc3454_D_2[]; + + /* Nameprep */ + + extern IDN_DLL_VAR const Stringprep_profile stringprep_nameprep[]; + +#define stringprep_nameprep(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_nameprep) + +#define stringprep_nameprep_no_unassigned(in, maxlen) \ + stringprep(in, maxlen, STRINGPREP_NO_UNASSIGNED, stringprep_nameprep) + + /* SASL */ + + extern IDN_DLL_VAR const Stringprep_profile stringprep_saslprep[]; + extern IDN_DLL_VAR const Stringprep_profile stringprep_plain[]; + extern IDN_DLL_VAR const Stringprep_profile stringprep_trace[]; + +#define stringprep_plain(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_plain) + + /* Kerberos */ + + extern IDN_DLL_VAR const Stringprep_profile stringprep_kerberos5[]; + +#define stringprep_kerberos5(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_kerberos5) + + /* XMPP */ + + extern IDN_DLL_VAR const Stringprep_profile stringprep_xmpp_nodeprep[]; + extern IDN_DLL_VAR const Stringprep_profile stringprep_xmpp_resourceprep[]; + extern IDN_DLL_VAR const Stringprep_table_element stringprep_xmpp_nodeprep_prohibit[]; + +#define stringprep_xmpp_nodeprep(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_xmpp_nodeprep) +#define stringprep_xmpp_resourceprep(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_xmpp_resourceprep) + + /* iSCSI */ + + extern IDN_DLL_VAR const Stringprep_profile stringprep_iscsi[]; + +#define stringprep_iscsi(in, maxlen) \ + stringprep(in, maxlen, 0, stringprep_iscsi) + + /* API */ + + extern int stringprep_4i (uint32_t * ucs4, size_t * len, size_t maxucs4len, + Stringprep_profile_flags flags, + const Stringprep_profile * profile); + extern int stringprep_4zi (uint32_t * ucs4, size_t maxucs4len, + Stringprep_profile_flags flags, + const Stringprep_profile * profile); + extern int stringprep (char *in, size_t maxlen, + Stringprep_profile_flags flags, + const Stringprep_profile * profile); + + extern int stringprep_profile (const char *in, + char **out, + const char *profile, + Stringprep_profile_flags flags); + + extern const char *stringprep_strerror (Stringprep_rc rc); + + extern const char *stringprep_check_version (const char *req_version); + +/* Utility */ + + extern int stringprep_unichar_to_utf8 (uint32_t c, char *outbuf); + extern uint32_t stringprep_utf8_to_unichar (const char *p); + + extern uint32_t *stringprep_utf8_to_ucs4 (const char *str, ssize_t len, + size_t * items_written); + extern char *stringprep_ucs4_to_utf8 (const uint32_t * str, ssize_t len, + size_t * items_read, + size_t * items_written); + + extern char *stringprep_utf8_nfkc_normalize (const char *str, ssize_t len); + extern uint32_t *stringprep_ucs4_nfkc_normalize (uint32_t * str, + ssize_t len); + + extern const char *stringprep_locale_charset (void); + extern char *stringprep_convert (const char *str, + const char *to_codeset, + const char *from_codeset); + extern char *stringprep_locale_to_utf8 (const char *str); + extern char *stringprep_utf8_to_locale (const char *str); + +#ifdef __cplusplus +} +#endif +#endif /* _STRINGPREP_H */

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