The SHA-3 Family of Cryptographic Hash Functions and Extendable-Output Functions Jos\303\251 Luis G\303\263mez Pardo Departamento de \303\201lxebra, Universidade de Santiago 15782 Santiago de Compostela, Spain e-mail: gomez.pardo@usc.es Carlos G\303\263mez-Rodr\303\255guez Departamento de Computaci\303\263n, Universidade da Coru\303\261a 15071 A Coru\303\261a, Spain e-mail: cgomezr@udc.es

This worksheet contains a Maple implementation of the Secure Hash Algorithm-3 (SHA-3) family of functions wich have been standardized by the US National Institute of Standards and Technology (NIST) in August 2015, as specified in [FIPS PUB 202] (SHA-3 Standard). The SHA-3 family consists of four cryptographic hash functions, called SHA3-224, SHA3-256, SHA3-384, and SHA3-512, and two extendable-output functions (XOFs), called SHAKE128 and SHAKE256. The XOFs are different from hash functions but, as stated in SHA-3 Standard, "it is possible to use them in similar ways, with the flexibility to be adapted directly to the requirements of individual applications, subject to additional security considerations". The SHA-3 functions are based on the Keccak sponge function, designed by G. Bertoni, J. Daemen, M. Peeters, G. Van Assche. Keccak was selected for this purpose because it was declared, on October 2, 2012, the winner of the NIST Hash Function Competition held by NIST. The worksheet is an updated version of a previous one which had been published in 2013 with the title "The SHA-3 family of hash functions and their use for message authentication". The new version includes the XOFs following the NIST specification and, at the programming level, the most important change is in the padding procedure. In the original proposal, the SHA-3 functions were instances of Keccak, which uses the pad10*1 algorithm specified in Kreference,but in SHA-3 Standard the application of Keccak is preceded by appending a two-bit suffix "01" to the message in the case of the SHA-3 hash functions and appending a four-bit "1111" suffix in the case of the SHA-3 XOFs. The stated purpose of this modification is to distinguish the SHA-3 hash functions from the XOFs and to facilitate the development of new variants of the SHA-3 functions. With respect to the previous version of this worksheet, we just made the minimum number of changes to comply with the standard and, in particular, we kept the terminology used in the previous version. We also implement the Message Authentication Code HMAC-SHA-3, based on the SHA-3 hash functions. In addition to the NIST specification in SHA-3 Standard, the principal reference for Keccak may be found in the The Keccak sponge function family web page and, in particular, in the documents "The Keccak reference" (Kreference),"Keccak implementation overview" (Kimplementation) and, in more detail, in "Keccak sponge function family main document" (Kmain). The implementation in this worksheet is similar to other implementations of cryptographic schemes included in [G\303\263mez Pardo] and its purpose is to facilitate learning through experimentation and to help to understand how the algorithm works. With this in mind, one important design goal was to build up an implementation that could handle real messages in a variety of formats and not just short text strings. The implementation uses, whenever possible, lookup tables for efficiency and is able to compute hashes or authentication tags for both text (or hex) strings and binary files of moderate size. A hash function maps messages (which may be regarded as bit strings of arbitrary length) to short fixed-length strings, the message digests or hash values (or, simply, hashes) which can be seen as a sort of fingerprints of the messages. The idea is then that any change, either accidental or intentional to the message will, with high probability, also change the hash value, allowing the detection of the fact that these changes have taken place. For the hash function to be cryptographically useful it is then a basic requirement that the function be collision resistant, in the sense that it should be infeasible for an adversary to generate a collision, i.e., two different messages with the same hash (since hashes have a short fixed length, there will be many messages which have the same hash value, so the hash function is far from being injective but it should look like that to an adversary). At first sight, it might seem sufficient that the adversary be unable to find a collision with a given message, but for most cryptographic purposes this is not enough and, on the other hand, finding collisions between two messages, none of which is fixed, is much easier as a consequence of the birthday attack (see Wikipedia Cryptographic Hash Function and [G\303\263mez Pardo, 5.6]). Thus a cryptographic hash function should be collision resistant (meaning that finding a collision is infeasible in practice), and also preimage resistant (i.e., one-way), the latter being always the case for all genuine collision resistant functions (i.e., for those that are not specifically designed to behave differently). Cryptographic hash functions have many important cryptographic applications, including password or pin verification (the passwords are not stored but their hashes are stored instead), digital signatures and message authentication through MACs (our implementation of HMAC-SHA-3 below is an application of the latter type). In the case of the four SHA-3 hash functions, SHA3-224, SHA3-256, SHA3-384, and SHA3-512, the suffix after the dash indicates the bit-length of the digest, so that, for example, SHA3-512 produces 512-bit hashes. An extendable-output function (abbreviately XOF) maps messages to bit strings but, in contrast with hash functions, its output can be extended to any desired length. Thus in the functions SHAKE128 and SHAKE256, the suffixes do not indicate output length but, as explained in SHA-3 Standard, they refer to the security strength that these functions can generally support. The Keccak algorithm is based on the sponge construction, which is more general than a hash function since, using a permutation of fixed-length bit strings, it allows the selection of an arbitrary output length; this construction is presented in the documents "Cryptographic Sponge Functions" (Csponge) and the already mentioned Kmain, where its security properties are discussed. In particular, the authors have shown that the Keccak sponge function has the property called indifferentiability from a random oracle (a random oracle is an ideal hash function which, on each new input query, will pick uniformly at random some response from its output domain and will always return the same response if asked the same query again). Indeed, the authors have obtained an upper bound for the expected success probability of a shortcut attack (an attack whose success probability against the sponge function is higher than against a random oracle) which, in turn, gives a lower bound for the expected complexity of differentiating the sponge construction (calling a random permutation) from a random oracle. This is a provable lower bound on the expected workload of any successful generic attack, namely, of an attack that does not exploit specific properties of the underlying permutation, cf. Kmain. In addition to these good security properties, the sponge construction also has other practical advantages over constructions that make use of a compression function (a hash function that acts on fixed-length messages) such as the Merkle-Damg\303\245rd construction used in the SHA-2 family of hash functions (see, for example, [G\303\263mez Pardo, 5.6.2] for a description of this construction). Among these advantages are its greater simplicity, the fact that it has variable-length output, and also the flexibility provided by the fact that its security level can be increased at the cost of speed by decreasing the bit rate and increasing the capacity (see below for the definition of these parameters). The sponge construction builds a function SPONGE[ f , pad, r] which maps arbitrary finite-length bit strings to infinite-length bit strings using a permutation f: (\342\204\2442)b\342\206\222 (\342\204\2442)b (where the positive integer b is called the width of f), an appropriate padding rule "pad" and a parameter r (a positive integer < b) called the bit rate. A finite-length output can be obtained by truncating it to its first n bits. The sponge construction has a state of b bits which at the start of the process are all initialized to 0. The input message is then padded and divided into r-bit blocks and the sponge construction proceeds in two phases called the absorbing phase and the squeezing phase. The state bits are separated into two parts: the outer part consisting of the first r bits and the inner part with the remaining c = b - r bits, where c is called the capacity. In the absorbing phase, the first message block is XORed (using the bitwise XOR) with the outer part of the initial 0-state and then the permutation f is applied to the resulting state. Then the next r-bit message block is XORed with the outer part of the state and f is applied again. This process continues interleaving the XOR operations with applications of the permutation f until all the input is consumed. When all the message blocks are processed, the sponge construction switches to the squeezing phase. This phase starts by taking the first r bits from the state and then applying the permutation f. If the squeezed r bits are less than the requested n bits, the process continues by applying f to the state and then extracting the first r bits of the resulting state. The process is continued interleaving the extraction of the first r bits of the state with the application of f until the total number of bits obtained is \342\211\245 n, and the final output is obtained by truncating the squeezed bits to the first n bits. The whole process is summarized in Csponge by means of the following image: MFNWtKUb<ob<R=MDLCdNNZem:`Q>D:;Rduxvy?GbRQtKClywY<tXYtCCB`N\\@Nd\\QHmxhYPhHkfhyU<yCMRMpuuuLJDVOdr@lXNdLEdRJdL?qqp<TkELOdLO<TJTO\\UyiQnrploXKLqTQTK\\Pj:@OB<qZLjDHnCuW<@RZDYX]swUxjUT<DjCmj^ttqYvELPsDQmYsRHsVEmlmj>AVj<\\:>:tT[TLWB:;ZEAn<H:>ZqIjDn:>ZVyZd>=>Zjw]b@F<Z:iiZPj;Z:vXZ:^UZ:>HJ:>RCB<mvt?V;Qb`qv`]wiYrAwCI=ejCfUqVKItKIR;ERRyu@ob@wVIqe_ATxB:[XkmyvIyjAxjqeXguvGYmgiwgIAQrJ?CsWg:cdDegf_gnohpoGdKGtsYxaiEWcEutpccGgcHkCHsyvYxIQyoYwqoWWQgf_gf?fZ?rsAg:B:AETKEP_dN_wRIh=ItKITSEUSMSDMcFmFaeV_EeUWeeOgdoF_cFCESCEXf[CksRK_HocHeYweyTf?U;?DtQyoYWqgWhkUv?Iv=yj]bJQioUw@]cRCB_Y;;RZwWYqiOodPorAyrY;Ij=VrAx[QHlKH^MHsOf\\OrTQuT=R:=FlKHLWd_YC\\;xv;e>_b>SEUSECCCCoWe;eV_eVcV_evnaxnETKETMUTMmsAYJ:>ZWfr>arrWiuwkRF`\\hiDWcEWk=Xj=Gb;GrWYqqgxoixs^mA@pDnvwYyqYfAqkOqtPqsIysiQyfiquwxfiwgYlMXlAikUv^b>_BIxnC:<JvykQyoYuWRAp[hy[Tj;Ae?QkQx_Yoev@ikovFImVxs=_c?VrZ?`TOeT_:ERWcEWogO[Sn]XnaysYxYyiyuuJAtjCYlaV\\KB<BZyYf]urGXBAd[cwISB=SBiquwWw\\QvlOWOQG<MxJST;av^avZuvr?wbAwNmTPmtOitowIOatNadWgewKYnAwrAyr]bJafCUdBCSBB:ocFisGYuyqiuuxhwbAwr<gBE;Cv_SR?eDkF[CF;SGG]Xn]XJKRWsX=aysyvYWwPig=QuJGs^qcEY;;B>WSCESSeitehkGhkisUwHCaV<qSAEF`mrCGcCWDakS>=CcUWeUfHcDFmYxmib?gb_gf_G<=GxkIXAuRAUTMUT?d>?:;wd?gb?sHqsH]UV]IlKp>`j>DjC=kc@VdXoehV^?nhVyZogYqqGhe\\gmQxlQOeTO[A@l:>:;VjAWcEWkMXlMGgcGwoYwQIpgBA=COytQyfawfmmIFCBO[SsEYsUyZqGWSGR?eR?ecWTaOVuYfZaFR>Z:Hb?HrZ?auVayPioQ_r>arosVHagYtiquwXePod@Iyv^ZN?`CGcC?u[^^>@l>`j>`mV`exoixfk@WcGgcgwmX@lJ@jJNjEFLJkMx^IsuuxhioYuqxewTipWtnAxjAxSSPP?Xxs=Kb@VXuqxeuk`P;qObpqtexdur_LLYtMipohpkWhN=J:LV?uRAuwXiquMunHWaysYxwrdQsDQS`S`TkB@kjmQLDZRxcYpacQwdqpy^tPqtHYsEYggggOOdLOr``dPod`av^AmSHmkoaUJ:<JW`V`mVhTUp`SUUUuqywWaHV`UGeSGqdgtdHqmwvLNlDXhqqn`Xtci\\Of\\Qx_YokEXkEOcDO`kF`;qZ@ItPqtPodPoempfGNbbHqsHqdPodIr=xZFnZ]?wJInOitOQlLPlNN[?Xf[F:>tKGeSGmGhkGWdMWtcYtaXwdQwdQWohpohlOhlwtiwUYoIwMir?irmyvIy>_B]auwGgYoIwMYnAwKqxAWX`askAxjARBcR>]RBGcCGUTMU\\[bHwEykyrIx]qciOxjAxbAYt?<;BrCwTiheutiwUiIwSeCGccEydiSXlsSuksO=@;JjQRRATt?:;JwqJO\\K:B:[=>:;PJ;;rw:;Bq:;BVyVJ]TjsgXeiTgHemT[EV[Ct;=:;tE_gf_G\\WFZ[HBMGROhlOhawSYoHn[HJcE>>:[sNsDQsypYui]Ra?Rb=dN=P:>Z:X_>pj@pauoxf`of`kbA^JGr:J:<tauxhiueUWeUkB@kZLQB\\TjB:<wUPn\\Pn>`j>\\jJiquuxBps<dLFJ:Ly`\\Pn\\lHun]\\jXxQymUXmUH]WR<oZK:<tadwupUTUUUEKy<l>dLFJ:LYAenLEp==SRLrI\\N;eJ=J:pu?hj?HPR\\kpyjkHpk`rX<S<PK@J:dqeapMinohpoLPlLlb@PBLOR<Z:BteR_OTMSDMSIG]FpARL[Tj;Z:>nQFn[HnWv[[Ff\\Wf]W_eV_CFs=@n<H:>biPqWiu<WnKA[vP^CN_RZ:>`miwUyp^`n^pgYP^jAbL^djJ:>f`qywYyWw[[bausXgTOeTk=IIkBd;]:BjSr^uRECbAKdZO:<jXdvayvyHYmqjCUJ\\pK^DR?Z:fa\\OhBF[maxcYd<o[^Fb?VZ:>:;fAeihQV[Gtb]bFcWaXxm`Z:>Z:noJgeWgcaXtAakSVtxfnv`qVPc_pkTf`DPb[`pI_yrIx]vvmHb?V:>jhIsBAs^`n^`hVPh[Qr?vdQwtaysYXcEWcMflDVZAGL;J:<vxZ:B:iYB;ID_TMUTM;DJ;tkMSHmSHKRbavCYdlOhlgwMcf_gfwcIwCIWk;;BVAb:OC@MUTMIlKHlSIuSiMaxEwDikXv=iheutkC@OB:<J:lW<]sK]NAuRA]UTA:<jyDLMErflUv@msUJ?dJ?HmmtVlmNFJ:<qHDPOVf]sRn^G^gggg?^ZZQci[:^hiyaOObB?cBogho_avfVIx^huhPwdQwZa`X[Z?pCWcEWbBFyrAyBV[EV\\OHfcQt_Xn@gk\\FfqVaRYpawsKX^A?asVyIwmxf[Un`fXua`\\Of\\EPkD@fY^;>`RAf]NuOwdQW\\oNnWob@orAx[YnlgVe@?ur?`@nZ@n^`n^Wqa_wfawZ_Y;<J:\\SJDQ\\hUIuvmQrO=S:>:;HA]V?ShnEwLMDC_tcMf\\Of\\gb?gB[CY:B:iGB_gZ]XoeXGeSGUIG]Ur?X[urUiU<B:[X?=xwEdtoEBMb==S:;ZZxd>vdjfmH^^cF_cfcYpaW@qrZ:>vH^ZQ?`TPmTXvAykiwibwgiw[A@L;ZJY_<X_R^xyxZL@vJN<>ZtQfJ_dj>u;`^_f^_HoMwnLf]AZ:^e:@yDnbWgeWauVa][^vZAVIF^<:[x?CxO[Ctyw;_FrZ:Nyb?pN?`dQwdAhBF[:J:pQ<IvpYROhlOHtKItcIwcir?irOhlOhyeaRDMSdmsVHQwAY[DmFmTLMTLeTOePqtPYhQumxJHN=MyQJ:<vs]K@TvgYuqxkXdQdDOcDOdLOtIymyNehQNlLPLN>pLh\\URyku<MDYsEYOeTOU<MR\\OV=qJEUSEmOylqMPZPK``qv`uAyra<Qr<m@UnCQsDQodPopYQJPkDPSyqURQtLQlLPlL=TJ=XnAwKESCEswTYpAqsHq;eM=<:KI\\WtcyHimunixoisGisOKDLKTN]TNuTQuDQsDaehYcXoeXoepwAK:AVjlQv=yJTMUTUPmTphVEqLUUUUuUYuuYmYsinYdU[MyYErvPYoQs;Ir[yrIxMyhypYuDiledkGhkuiuOArKIwnar>wivIxAqqwWyxQyeyob@obf]Wf]<Vx:>Z:>Z=xbGgcGQl_VcXvax_ghoghyvauUwHI]SF]cb?HYuixeiwUypIsMwFAecTcX`asSsDQsdxixMysmAVXsIx]WcEWc_gf_y[YrAWfAucLSUx?F>?s^Mx^GSMogWUipQv?YclQxlICMkFvmyvIeRAS:>:=xwYyqUXmUxQwGYmysyvYGCCCCHocH_BPwGBCFWcEWgIumx^qv`qGV=iJitOiXAqcWcyeyfycDFyvIyeW_eV_KSdrAyreQwdqximrfMPsMx^an^`NlDmfuWiuuVauF]XVJ:@SGisGqKHlK?ir?IXkEXexTipwruNYLVCAsBauwXYQYr=YvNIoMuYvIxAuQt=wIeJ]Iv[I:eR?ESDMSpYv_aw`Wf]WXeqtg_sFasmyvIYDWgB:>jBGb;GbCHkCx`iouV@`[OZKIetV^K@cAqkWVpohpWIp]wbCGcCVoivfsPjCasFakB@kRypiweyqc^IvFV[EVk?WkPFyuYyq`pn@\\Wh:;JJTn`pn`BZAvZAHymyvMfm_XI_R\\cewSQeUWeIn=ujReYgTsO\\sgXUq`j?hjq\\WRArdYKs\\sOitoPplPxCYla\\RAD:<kKDLKDTWeUwxVIqM\\XjjTn[Hn[awfaYeqtgLMGprLYKSmoZMLLLLFisGYykeyOARVeqtetVauVeSGeOodPoxkiDmrDX\\@ob@W<MR<TU=H:\\wP`mV`uyxL@uRAUWcEWSPmTPvUxJqmXpmXodPo\\ohMpSmoZMKDLKrtY[PxdhTePJ<LJDXkEXUUUUuAyLDR;O]TN]RAru>:<juEmUXmMHs^eWgewZAvZmlX=ykYvA]wHYjw]xpiwUIjpTnq@nPyMWay]XPuDo=asFaK[\\lWhmWyxb@oYdLFeWgeoF`kFToiPMrHv=yjmPyLDMSDmTf`fA[=>ZZYe;FZ;V`aosFwcIw^t>[Zy_FnZ]YuqxgUv`h_fc`lcF_cFfc_nSwgiwwx``u>ijAfYYyfgggggeWg]ou@ocHocR?eRhtMHiuYhgNtZIqPVksngCI[:>vPvmxfiTYpawcf_gfqsWXaCps<>yNwnLovqyuywfLAyaysY`]xVw]XlPplPN\\C`baXtSxm]Qb\\Fl>ir?Y]UV]SOwV@vuVaLIwnQwdQwXWomJFlJgYqoUOdLOBhS<<JPMsfmuvHqidnFDNTQuTAMFlJ?PR[DlBeyrHkLuoRiT;aOWMqNeUWeU?eR_lPplXQqoWmQxlQPmTPuYwihpqZggggw^IomF^[F^qmwvHausXhuh]GqvDileVwPiomYxmYxnaxFHkCHfM_D;B:;vXUbj_d[CCD=d>cF>[R^wU?yi@QDXIiuuc>MFgyuywEAIiZyUMCVhuuxgyyuyqyYUmhfEyjIv=Ih]urJKR?gb?WFAmcfggggXoeX?=C?mR@MYtMY`[F^[cYsIXqr@qrBAsBmUXmu;Ir[giAWvAycYQioUGsCIS=TJ=D[[vayvAQW@otPqtR?eRcR?eRvquPSs>]R>]R?eRC[kjMsDQsvaq>\\J?dJalSV@SnMK\\DmR@mREe\\Na?F`dN_dNb<ObBpc;_nivex`\\N^\\Jfm<@c?fZ?^oXG^Vi_@VjKyr`?ecVv\\Qv\\HocHwcIws>xSwxIVjPwimqtWivevtS>weilPpl__fx?et`fkXtlh\\Ax[YriwUiGgcGcEaURiT;AF>_v_ivcaXtqrGWEkwbdQwdYepcWTIimufMWdM_gf_g@ojKUn@EsEYs]\\jNeTOurIxMyAx[YrpQK``n^`rEYseQx_YsREy<@LT]qrEpQxlQTS;LUUUUUMUTMsEYskYYIWslOhl?kH@bj@sBAc\\X^JFgwQyoaiUGrvwyxim:icB>va?ecVv`qv@?f@hvevtGymagncHokAyCYpSYp`sMif^_fjQe?sRIYbS?IkMvIyeysewSY@?DTSIp]WDMSDOhlOxysyvYX\\arCOb<ObYwIymhq_cHochEWcEEZADBQF\\KFPqtPaC\\AcDOctEYsEDR;bRLTL=L<EPkDP>uJ[\\kUXmUPlLPLKIOB`Jq@kA=K?]R>=Lwyy:=mWYqqUSCESKd]KpjIv]xPf?Qk;xx=Qt?H_\\QVQd_SSDOcDOeUTp]awMpqZPTE<L<Ut`pSxHYeqwFIMMIL<umxdv\\\\jpdWTarghLFplPpL<=of`oFDNNQtLQvcIwsDWLanDP[HocH?uMgwDWC]bJAvvwwL<J:<VjHWi\\UdYweyWYqqgP_OvlhWxlQxXyqyctQgnwxS;C[wdiOvagSU_S[?TJKRcGWc=C[GYmqv[QdDSrKQwFSEYmCu\\sMYtm\\Of\\OgdOGTMWmJuLUNqtPqTPmT`Pn\\Pn`f[[^rdijOC:<ji@kEXkIymytQb<OBESCEkWdyidUt`PitOIht;itXanvhRBdOk]XJUyiENoQv?YO>@tjHV=AXFqrpiYjdMAEtw]xbIln`pnasSXPKLRqqwWYpohpguMVtKuTU_HpkHxlivEAK[HqmuvDTKETVAHNjdsGisfqkD<:;i<khAiff_gFSu]Qr^_Y[WtcYBSGtHieuCUwCCOCF^yEjMB[[Vw?vySYVMsDQsyuy];uTQuTAr:AfawdnYFaSsO[C?ORcYyJqyBCfMsFH=Vy]f_gfWAikUF^[F>SilcRYuUygYvAvQwGYMHR[c\\Qv\\MGOOg\\Of<?DLmTPmIkMv>IcMsFjguj[XtcybIt]?C[kd@IrfeWgerpmU;;B:<isGiswhqwx@qr@_ojGdJ?dZouXocHog:XfQf_SOp>Yr=Yj_xl^aiDibBferv\\bf^oymMGbx`iGybBFeUWe]^jb`ddwtQ@tb_pTPmTFasFaPpf>QxK_^_RcYyqywwuWysVHaEysIyKEGodQwdqAwKYfkYvAYVMyWXaicIwcIwdQwdof`ofdOgTCESCw\\QvlUwPigpYc?yhfEu\\WgeWicUt`cYweyYwIymgVEilCIsCI^[F^?hjxkIxSYmVWMTLMP`]sRlTYAN:<ZZ?dKodPo`mV`uvhha]exfq@odPoloyxAjiwu_H^>prGhyIiw^F]Fnb@orA^jJAykYviwuxhav?yjqoQWdQn\\PN`R^[faZLpq]Gq<H]t^hbof`ofYYuIp]wN]uXfMw^DQsDydh`ecAa_^`n^pMWmsWx`ihvVwaYtaxcwwmigf_gfCGcCpohpgYye<>Z:^sCQsDQfy?pnwoSb;KGhkGhyuEsfGUepmyvIy`of`CDKCDvUFkCDYsyTCF^GgcHrZ=tcaXtdmHMNM@L<uWXaqkhpohwp=lp\\WJQucUt`HpnTNPxk\\dsYxQyyuyuy_ex@LlVxLXlMXqtPqjiIWIAZvocIwciavCYlpqxpiwAyr;>]FqvIymYAtJA\\KF\\;IsSpyYIyMa[Tgq<`qvnhEA^;Gb;ixeqdmNuTxtixeYYtRVpqpgWQ`lN`dahOOhi@eh@ffiwgi^_rXuRBisBAsrmyvII<=wKYfAeyhkEuigoghoAykYv`oNGhkGHQvTW:<JiUXquXIdKGdPl^bn?\\:NiqffDalCV\\`^]r>HEWcEvJaGC]D>mD<]V[KD?=U:=SNOFr[Bu=cBeIXodtAx[YrQwGYdxfUMNykDlRHmShuxhiuqNqOf\\Ofr^HedOgdplPpd:?b:ocHosQx_Y?eWXSmixoisCIs;uCyi:;J:ly>O^Wvax_aiv_Iir?ijMWpvyc?VtsyeIf\\FGdKGtthheacF_cPooVGsdaotY`X^kAxjA_cF_slhfEq]wNinFilavhWufpewPqYfa]Q^^^^^Ax[YrhpohplPpl>gf:B:;b;AVDadcsbIsEXYiqug<Ob<wiywImIvwUuTQudWgeGhyWuAWI;AtcaxTQuTqx`=i^UGdKGTwIymYMUTMiiuuxtIXgAXymr=GDLKDDSCEStKItk_hn_CF[CV[I]chNeTOEisGiwQyeygpkHpsfIue`KIH;J:<jrmmXpmhmWhEJ;DJPqtPymytY`MtLeTOeXkyY_hn_hXvMwGYmqdwIEvlUrJ@tJAtkUv@ITc`tAtKX<weYwqYnApYHHsetNatlJ@ljpWWQQquXqYtaxSiHUmpVDalcLodPo<Qr<iyeAXZlYvAy;enLumxdYtevDil@pj@tSIus=yjITrB=P:^wjgxditrAyrYZAn[b?gb?\\WhZ:pa[FlBwnIwmpF`kFusXhaHlKHlghoghmWhmHpkHPn\\PfahelVypiweAyjXvC?^DPkDxivIxAwPeYQauVaUPmTP_dN_XaqsW_hn_HmUXmYGQmgjCE`qcsoyYiT:MR<MvhiuuwGX]irKX^AcywiykGq;DY;CCCCCSWeUwwYyqYETKELSe>;B:YgxgYuqh`esTkB=GTPmT@IveYI:;EZgHemtRIuSierCX\\qvGYeqqwWYFjCC?ORS_IsMPqmwrLQtLpnUtDqS@LYY]ncUt`hSUpPgpohpOeTOe`n^`j_HvtEx\\LN\\Lnhpoh]V^]RBqMZby]dPodl;EF[bJER;EBKIU:;VS_cF_cYweYw]YpawO_f^_f`of`vjS:=R:ESCEs:Ar:mUXmEAou@ku?KRBMTLMhUIVeAJ:<JZWfZ?fJyw]w`=xZUywfA[:J:<rW\\Tj>Z:BjuEb@J:B:iYZOJ:>Z:^uAN?;Z:>hY>oZ?:;JZ;>Zq=>ZV=\\xO`j>`Jpyj^`n^DpC=J:<T;AZ:pqTnav?ypiwUybF@]k?wJI^\\Xp:>riAxsXo:wpDWcEW[EV[AakSVrxHEvj?nZ@N\\WF:;F>qtDkrAyrasFasvSYhaeip_cDOcTehdeDuKHREUSeuvGYMgEwskR\\K@MXlMX>]R>ytixUELKDLkEVcEWce?gb?gdOgT?eR_sWXaQ_dN_lbakfix]yrIxjIv]xvixaqj@pJPc_ptQytePodPgdOgdAwbAuTQuHX]qngZvx;gvD^ddf`f^_fiyuyx?T[ER;EBC_RLAtJATQuTYcIt]x<ibEcHn[HBoCBqUFkJLMdBAsBqxO?b@ob@Wb=Wb=sRGH]mbOgdOssiOBGgcG?ud;TJ=T:efLUWeUWOatNaHn[HnghogggggGakKHsvlqeiqb@ob\\Of\\OodPo@pj@pjF^WpcAqd;V\\MV\\uWiug_gf_\\XZ<^ujXo<H_gf_Gn[HngeWguWx`isrIx]ImqngcGgcpohpev@ik`pn``HH]\\bBwEykYZAu[AVPeTOeviywyuvHie<Qr<ETKETgcGgcR?erkUv@iyrIx=OS_oF_cFWwIymUN]TNQsDQWyqywYf@ec\\KIikyLMTLmCWKInavCYd`of`cNDModPodQwdQn\\Pn_eV_uwYyqI@kB@xqyxQAtJAUt`XcqmwTY^]V^=kHYkmLQWpYwQyoYpaus`pn`PN>`pohpOhlOxjItMH@LdTOeTYkQv?itexTqxWYqQ`]sRhoUuptTQuTxXqVfPodPwBIl]tpiuuh\\Of\\LMTLMatNaWYeJlYxmYLMTLkhTZmsVHQuyxiyMwLYnDtsExQPmTPYbAt[@mR@mYxQyMOdLOd@ob@odPoT<MR\\lOhl_xnaxR?eR?\\J><odPotLQtlwUypIER;EjbaqrTVj<MqpWWQKDLKDESCERBDWcEWc@ob`KUlPFDNNmUXmyditeXwQyouXquxkXdQTir?OmoBDcb<]X^=HZ]C@Sb;AVrMYtMHjevhqwHEfJ]B?cBaqsWWueUvuyxiYF>oIx]yBwW@SXmUXeUWe]YuaVC?gb?gQwdQSiaQtPqtpMv>ICSCESCB;Cb_WSQob@obp[Hn[XdURaWtMSDMsXhaucsGisS`SdQegTeTPmT@qwZ=uqASF]Kpusb@pj@XCQl_\\NLDSSEeaxnaOcDOcQq`Gf[GvxiyuYOp^Gk:DZSGeSYdatcohpoHpuBmUXmUTLMT\\uxV=EFkRV]UVGcCGC<=WVAqHamsTTJ=TJipGdlDeKDLKTTQp]O<=WNAoKuOYmq^ARjdMWdmoYwQYpumOgeWgunHem<qT;hNEG[Gf[g_gf_wNqjHwnaf^_fwTipEGb;GjFo^i@ekPvuyxiawHnlSHmC@\\D@K;uwSfLOdL[gdcTN]TViheuTlMXlceHuwNqfkGhk[Iv[YsQx_QB<KBLKDLsbIsE`Gtb]wHkhuuxhEGcCGpus?GrZ]F^[FZuVf[cXcIt;Hj;xUyhieUUaDOcDWWIqmsFasFCF^]Wf]y^IsMkC>SEx[YrQcOSGr;H]kiLoeXoY]qrGkB=GrPOC`?fZ?R>]R^=uj`tOitKLRilUv@VXqMd<mxUoghoWxQymQ<=WCQl_DQsNigweQwdaiwgi_hn_hhn_hxxiyuop`WvFg:kF`Kgb?gBUSEuB>[BneGWQiDqsHqXn]X>=CSAuRatOitkgHUsVd;e:Ar:EB;CB]UV]qifEocaxAt[jN`lN\\J>\\BN[DNfqo`H^djfhoghpppp@[[vbAwrx`iA`tQytuQytQcB?cb?gb_n`pnpYfHHpkHpAx[Ynob@obip_vfd>mqxgYQoeXoEOcDo]x^irpqxpqQqxYvax_er@h[Fk>Opj@pbv_ivfeo`Hadjv\\h^eJ^\\N^`n^`vxiyqiQQtgXoyxyxYiNAoK_flFuYyuyx_gyZ<N_RnhZwg?Vp_WsPFdKGduVauH\\]nbbAwbasVHaMHiu?oZOya`qv`uBAsB_b>_vdite`_w@`mV`MwDiDQsDIgcGgVMmH@sRd;eBAsBEV[EV]SF]_uVaUPoURKDLKFf[GvKV>AcDQsDmH_UVj]f<GutgXeKRbEylivysYxawuYgTSEUceV_eJKRUqhgUVYmH@Sye;edOgdGd]sRDCCCDKCDVcijyqyuyoXpmX@ob@w]yrIHUtEVCESC@j:@Jp`sueWFIjDlvYxYxIMl\\VBHj;HRpmXpTSi\\KGdKOtLQttKIt[PTc`WDqBTv[IfexeuQx=nnWWhmWxtixeI\\<WoQwo`WgKVZO^[u^pQ?`ry]Ev_f^_v@ikQv@ikUfb>_bB_^LxNIyfIumwDikUZqI]kIQauVaWiuWIefLUV]UVQmgVEsLYWyEy_yd^av^eYwey?UcPcv`qvlGG[Si_gf_GIsCIGwEykIkCHKuSIuc_wthgUuoxcYtaweysYX]hbEDGoR]UT<mXucXdatSYhauxiyuyytYuYC?cB_xwib=mbFCikUv@qiwUyHaesSDN[D>qi>_W?UfKqDgKUNwdQwxnIwMiheutl_xTUF]Sf^av^UV]UVAuRAawfawxwiJOS_ohpoh\\[blOPkpLQhKx\\YrAprEx\\ULMTl^`n^TR=URPpUeuWiuytixeQqtPQUTMUlwwtUjQr?XKalSV@usXXaimutXRMQAUUB=Sb<Qr<yRIp]udsPv]Yv=qq>@jg@xi@fH`]sNb[@dpgwTijw^empfGpkHp[v_bjwv\\QvlQyoYwUx`iOmUXmqYv_QxlQxRq[FVgeWgh_yxQ_eV_mHpkHdOSY[Ir=tyGh?qFImevewTihr?irgwUyh]qEIWBXcIt]hmuvHiTeoTsQytqx]iv^KDcAt[WRHqsHYIp]wrMx^IChIxr;rGisgkGhkwTiheUT`_ScyrEiV_eV]KF\\[F_cFggggWWeUWkucAqWOeTOmtPqtRYibyuSGw]kRF?CESCEQsDQUkOV?kwkAIZIumwVhmWhUSQoGwKYnAWyqgk[usWXaqtgWUweYwuwXiiEWYv;r;;IQ=HsIysydhcmkUv@eV_eVfMkZ@^IwcIyvIymAir?Ivuv_xolJ@ljGyliv=vZH>eUWeqYqMfhogxuyxiyitaxCX]Aypr>ijAfSGeS_f^_nV`mVwquFhj?hRipewtiyqyqkWwq=ibTXmUxpfGu\\Of\\O\\V^]VywH?c^Nt_XcQ`kGhkWgeWGqhwbNOcDOsiyqyqwcIwcAvZAtiqcN_D?hj?hiwUyoEwKYNsrf]ek=wJIf<QjKDLKLkDVyWIsNIoMwcWPaOn]Xn]SF]CXfpn[bgggghoghWn`f?uYxixIaJH^LNZ=VZafcT`pwWypogvI^A>hh@fHp]wN_Z>^Jqq=nZ=hw@HxlQx<yhX_iEpcaxgWQqo?wJInXpmXXZfQg\\arCpsHqsAqkWV_gf_?i^Uvf^of`oev@ikWypiwfpwsvwdAv;YjdPodxqwqxUn_;Aa`>_b>wEyliFb;Gb<Ob<WZcybR?er>_b>_qv`qaysYxrgf]AZ@VjkhgUq`oghoIjyWoFh]unhWQqo?uOY_:v[fNe:>ZZ>ZCSJcDhCurSFuSIuausWXhkGhSFAmcV;VQUeqsWpcHocygyhYQeUWekEs@IEQkGV=sCIssSYpaGEurIUi\\?TbsvHieecGgcCB;C:YGU;vR[ee;e[YrAWYr=Ynww:GrBKCDKYsEYGMenCCukYFkBbirEwDcEWcUyqywY;vPYC]iwgiuVauv;dYOxVwDR;EbCF[Chuup=twd=sJHNXpmXxOYmq^QnWAPRir=Yx`iseyuKYlHmnIumhEWcEYlavCmJ=HPjqurTNcDOcD_LqqwWy@`[SN`jqupywYykJNywyxYyZXi\\AAfUowwXiqq[vX_lFmfYweYy_YsQ@kB@k;xx@I]FnZ]arCX\\mnfFApj@pR>iio^`n^EolfFamovFWdMWt:Yi=^m>Xh?VpgWuppgIGiSWqpg_pXi@vuSIxa@pj@`cGgcifEql[QtUpohpwfHem@pEIrrPbeWge_b>_r\\irEhf_gfkGwjgxdeB?cBYbAsCjEwGWBLKDLKSEUSqcWTabQubUoHgMGf[GvUx`iCXeElWUR=UR?eR?EewFjwx>UR=UVXais]UnOCJIwnAhj?HuUYueF_cFVMIVwIymiHocH=UR\\UtUv:`lNfZ?fZrqo<fxoixVOi<?]yVvoHhsFiXVj;AkF`kVXaqCb;GBwTYohpohSCESsUx_Y;Yg=mhD=SB=gdOg<qb:Cr??eR?uFIemCibyBb]TN]d>_b>awSYhkQwjmsVGI\\KF\\CTKETreXBqW[Iv[Yhaus@iVA[C@qtPqHisGIgfEOdB[dLOdLMUTMc]QG:?DlohpoYnAwKUSEUCHgYlwSN]TN?cB?sVIq\\it[anCUlN\\LN<qhaVZ<JO\\KQHyxiyudlDer_uucUqcYtaXN>@q_yNrMXlMPp<MQlkwMUR=U^mV`mPn\\PZAuaTy^tNaTmSHmCTKETvOInr@qrAqkg^av^]it[VeOwdQwv_ivkXfO>vPh^:hvVH`]oZHhiTOeTotOit__f^?vRy^ua^av^IX]qncV_eVvoHF_NNk?hj?YoQwojQwJ>h@^dj^e`@qr@][^ncHoCXfY@eigb?gbrnxCUkEXk_arnyxqbBFfqYa>qlgAvQ_dN_jui[Tf`of`s@w=>jjqe?^tNatb^\\DvpfFjLPlLFhkGhvww\\vjWQbev_iv[AqaSynr@qRV]ji]Aob@obYoqvGnMIwrqhE>uDN_Rn_MOdLOjJNdKGd;IpIG\\KF\\cGgc_oaIri`n^`ZYypIpyu`asaiC>hKYuA?iiPZNN[?Gb;GjUol:GhkGpdPodnqwOfQ`fQodPOvUi_U@p]G[b>_b>tb_ptQyt_iuhZfgZO^[QHoeXo=?[CGcCGvUioF`kFvpFNwOwdQwrHxpI@\\\\Qk_>b]HtxoyvIsHh^JWdMWjiwmfObfQ_Jqijqg:x\\kq[>VaPGZfiwjWs?AafYe<vayoy>ypU?rP?d;AhSn`WOxt>l[FnrvkGGgs@wlOfxobfQ_jNf>AksYxaYkEXk]wp]I^D^o<>ZZ^jZQx`KnO`S`]Wf]G_hD>Z:Nbjx[@B:;B:sH<OC@>Z:>hY>O<J:>RDr:>ZP^ivAykqtgXeVQhSq[:^aFN_R>:KydOf\\OVnAwKYsPgG]kxT]F:\\JO\\;huQxOY=pwxOixUypNtTK:\\yHLOR<J:<ZZqaJGr:>Z:>Z:Xy:gZ=>Z:>Z:nw=f\\F>:<JVyJd<M:>:;AB:;>J:thqqn@ikQxLysysyn]eLatNaDLKDlAwKYfHWDyuywyxkWVAQXpKEa[hoghSMUTmtQytqwSc]Wf]RBcWSQh?MTLMhwMf<Ob<uf?KrmkIx]ybawfaukMS;EjdQwdqSyiuHlKHTYpaw[aWnlKC\\KF\\qkUv@urcdr?irIlMv<SGeSgAQk\\N^\\r>ar>XpKAJ:\\QBLOR\\uF`MsLtIysiXt>QlLPlLRuYR?cB?GT]oRkmHQsbJ=GNcSGeseuthgXToeUtp]YrGwg`AfbnkTn`f?e?gb?ypiwutfcywxhieAyjAx[YnvZ[mnfFXquXiaHkGisGi\\Of\\gy[O_dNobF@];IuV?Z:nUIT^[uf;Uj?RF]SFGYUSIuSI;CBXggTsDikUVYWUsRAuRH[F[[BC_Rl=Xj=VXqRHmShmvFIeVGs=IYMwFImTMUT]mu@qsHqcFhrYUQNLK?Ty==TJ=lRa^:^evidl>uBPkDpsYxaYHiUpqfWvsxtfIUEUSEU`cCN_dNontdl]EYrtoQQyfEv<ijv\\q_YNMHspqxpasUAXuEKuLX^AsYmYsijFmNihUuplbaO:<xu<oZ=x>ayUIUCEc?hj?vr<AhX@nZ@nghogVl@V[Qn_fwyCVsMp^F?mZhn_hr^HZqxgyXiOYwd>rgi^f@nZ@vuyxiYgdOgpngVAcno\\::ke`isUwFhkGXYtmoxpqxvgiwqRBcGSMh>Gsm_Iygy`CdB]SpMRb;Gb[sRGH=Wds=IiMt^GSFmC^Cx@ECEEfJ]F^[FBoS;N_R^ekvaJ`rUyjJ@`mvfHadJ?dbqxcfb?grcWt`Hhrv[aI`cPtrWyf>_FFmFCgKUNYtm_IYMr<;BrCCd;EVgxniEgOgdOsgYyIYy<=R:hmWngYPvGxuYiqlV`mVtNatfqxcnaSqiqaxpFy^`j?>Zj_[N?`rVmyvixwr[ycTIar>ajgx_>]wwtMqo`naSqIcEBMTN]T^Iy==SRGcMsFpUU=IxFECUMUTMEYsEIufMIcHKB:si]YcgMGaCcB?cFYeqsgeaXx=I>_bk?hj?TLMTdaHKETKEXtaxcaR>IF:uhoOeWgeWsWfuiuetMeCAYE_[WWeM]UV]IOMmnfiuuxlbaO::YwtiSgGgcGIcMt^KR<AXXcb<EwtGB]yegyH<=sVauvWwH=CXAuxuxKutqSsmcFfmSHmS_eV_KRbIsMwF>uV;;bYIR?SbyGYmqvoMIJ_ViuWIMFK?cDYrseUq=IkhwqDk>MUr@X[urcLkDPkvhY[dYadUe=QXHO[EMFncy?Z:>k<f\\Fny>_b>o\\f>eJIhDVxe_kswsNIoMgdOgdUy]lYupY]oGoRAy[Qbtqktp[I_sQg^f>Z:X`ZPj[WkHxuQQuTu>GCM;CFSrs]VlCi]qBFqtPqdiohYAC[SXmUxHWr\\?x[qxuWvUmv=QDP;B:IBJErjgrVIimUuI[FgKUn?cioC[CVtkEBMv=iwqurTkSCESCwCiOFpSHmSWYkeRwCE=U:;BA;R?SrPKr<QrPqtPAuYaymeDLuRMoFGMrHabJ=TJ=vIyuYiwoUEygE<Mrn]IJ_rAgFf;JA<R?Trh<uqppXpmXAqkUvBps<=jpYSdeWgeWsmYZLuheSV@QKTQJ`rqXui]wGXxgEKE<JZuPb@VRirDQsDMSDMkCAKeaQITusarqXEUf`eDOcDx[I>_bS?H[MbpoPxhO[EJ:\\w@iVYaO?eR?EuSIu\\LN\\TNAmkfqXbYu;YRR=URqr@qjytK[DVFasFqrHhMEyN=DtpUsKItKpSaXxC?muP^K@cEp\\gNmoVgPFt;?Z:^qCXgxXecahtXquXq=Xj=gcGgctOitAwKYn]Pn\\@kHftw`lN`lgVep@mTPmx>ijArPqtpoxfIu;Hj;hhogh>wv\\A\\tfmxwvHim_VcP@]UV]agf_gylYsiVcP`_Cf;Eya]yFOgdtrHhMUHP]mjMXlMipeut@qkWTwhqwXHmSHSnmOHISIuSquXquMulXf=Xj=xditexVFAmk]wRIpdP_>wv<>Zja\\hHoZoiyiyqYkQv_@wbAw_T_pBitOix:Ij=nkHpkYbYCcHixyKweYwQwGYmI[Mr>WeqsWdWgewHocHCUSEutOits=Yr=wcIwWIimubbAbfubOsdEudhcYuqxgOeTOU]UN_efcF_cVkPf_Tvax_iHocHFt;FuhQt_XctOitWiqqwgGgcGlJ@lbggggdPodx`hcQtbIt]x`iouVatNabn?bpQgf_gvixQyeGgcGw_WOq^`of`sZ?`>ir?YeTOepqwWYoixoygvDi\\\\XZH^duq]onqWip@>rZIrWV_[WhmciuuxgREoDCYkAqnfdUt>ob@oyxqyFp;QadXoeXmtfhd?gb?oylDen@mR@MKCDKSQuTqN_dN_pn`pkVDQLIsCIwnIgCpkCqbCF[CVl`fctIx]yb>_b>oeXouKX^A?\\<WiqqwGYsEYQiiUMTLMV`mVPoeXoSn]SpKxpqxXuixey^IKy=yjINxlQxmsVHQLPlLHtKItNMOOYtMYx\\irEpTPmTGisGaRAaVQpj@pJETKEXWQqoW<Qj=nj@pjLQtLUXmUxMynIwkIxkIMSDM`mV`UWPao;qQO\\uEAuRAMuDRuXtjXs:<JHYvHPK`lOhlo`pn`XvSDl<Qr<qV`mV[Iv[iogho>lJeAWSQp_EQsDQIxMylxnaxNtLQtwralCHkC]SF]kmXpmqkWTQXtQx]uMuKkEXkeJ?dJfySDqL?ir?qpppptrqsWXAuRAun]E<sbFmFuKItkisUx@mSHPj?TKdMWd=mnYxditexoYuqlxQilyhquwXw]YvmhfgF<]b[Gf[ura_f_gfIsEx[YyqywAyrAygSUp_xNYRXmUX`r>mww\\upPWOQonaxnyqyqyuAv;YjWpSMUPlLPDPkDPujHV=qqwUy\\TN]TYdIv_YsQHysIyfuKt<J=mjFDsHqsHIsCIuqxWYTQtyKGdKg]Wf]VAusVENytQYxsiYyWtLQtR_PTCpS;iPRUoZMmTPmlTPmTUTMUjxjNMOoYrAxKf=SOIuUypiEL<MuTQuWtNdAwbatQytILl=DSItMx\\yuywyxSWPQodXdathUMJ=ONXSQpOSLMTlypYuieWgeWWqpClKHltNatnlPplxpqxxaxcYLuTx\\ysUYuuHn[HN\\LN<mSHmoUqJdPodxKX\\QbDOcDKB<KZMtIikUtPneXoEp?@PBmymUy\\HqsHYaqsWpV`mV;ER;eQG<VbuVauvcIwsEylivn`pnpWU\\V`mVH]mrDT;ER[evDilKETKUjaPQiYkRAuRAtJAt:@j:pmHeu_TlCyvIymYdPd]luXqudk@UwphsOY_dAwbAfyYy=pxRXn>`j>Hj;HZUPaqOhlOlOhloppppqpgwTvyV`aQq_uVauOsNH_VOqD>v\\Qv?YkTOeTWjvg\\R^aR?oZ?]FnrPioUWb=WbGgCQr<QrgYuqwuxgYuAx[YrXmUX]wEybCYsEYRBCcDOcp]eBgIfkGhkVqauuQFr;IRuRAuVwQyoaSTACCCCW[Ir=HeSGeixeytFMe_eV_EyrAyFSEp[CuAD]uww=duIymyvGWEqPyeyotLQt\\SThkRDP\\EwLin[DN[dQOAXgAp?@Pv=yjmWSUlYtQx]S_PTweYwEmYpMkXYqqWkDPkXsQxOmDWMEUSEYwQyoUMUTMOdLOhletTxdYtalelYLpJAtJeHocHqtPqlDW]<NZ<v]YvmIymyvr@qrlNGApyiY=UR=mOgpvA<osHqsLQtLYOQoOMSDMSREOMuUYuSn=OHPodPo<qT;dV_eVxaO_=yveLbYQPLOR@kB@k?TKP<YsEYw]yrItDQsDitOitKItkqywYykHpk`wEyjcpohpRw\\Tj<uM]jumxfIUYmjHuUj@V;@lJ@tmxVIQyLyNpINPytQyrx\\rYxQymr]DOU]N`l^f_gfYsSHZHn[Hf\\Of\\iyuyxw]wsWpt^auVau;h^_wlRAuRGgcGwXwjhWlJ@lj`pn`w]Q?]TN]UyoYwmtfGUTMUTmWhmWkIxkYbsABMYtawSgggggB?cBSwHUWHamcb?gbSSe?BqeTmAIdMWdMrDEE?eR?]gNGykYvACt[?IdWVosikhkv=Y:HoMQOj<Wy@JCPR<qqMtxfIuMYwSlXhl_<NZ<NkEXkAx[YnidatcxUqYeggggujGV=QeoSWf_gfOipwXlMXDQsDQwEIeUGf[GfEoDgKyrIx]Ah[UrtgWZeV_eDMSDMgdOgHv=yjqxCoixoiAsCX[irEx\\ygyoyTiweoFH]ebsGisWb=WRKETKuemb;?fMIwsIysaDDcfMywiMEGoR`Sducdocgggg\\Qv\\QCDKCWUycSGeSVliC?EfJ]Gf[OcEW?`j>`vayvqxunmJQTbWNeXoeXigdpqrIx]ybSGeS@j:@bAYZb^[@VnohpoXt\\Gr`N_cF_CHkChhUid?gBaVaIIS_SPodPoy_ydYmUv?YKyibgutAx[YrBGD][dOgducTCiYQMUTMuRAmMAtgeWgeWnMQwXt@eqghoGHrZ]XuXpdHn[Hnn`pNHsVmjGTMp@WKQNytQyXVAWusXhawy\\phEyuYyiYqqwOqtPqwYisVj;Aytixe`mV`mN`lNwrcaddfhBAl[fmxvd?hJ?dJ?d\\Of\\utxMsEYsS_wi=fJ=GMufHetQytIkCHkVliXKyI@qr@aTdchUaTW?VYGvXUWo[bJcc@Uyxiyu_iv_yJGF=MyRSveyti_SdaTcEWcUIuSiIuexchpoh`sFasxkwsx?WcEWKkDPkwtyIr;RocHosIx]yJuTQuw]Uy@qr@ywYyimCWZwfawhrEx\\YfAdQr=xZqywYykAsryMQxOYogWQagf_g^iiIZLOdLO^^^^NYtkhxh@migZBaflalcVdPv_X_w^av^V^]VjMobhYlKHlkIv=yj_WsPHpjNnWhMuFcCGsuwXiInyu;oT__f^?Imebj_hn_H<=gwayU[CpmiUugU_E]SF]OuTQUpiV==CoohpoUx_YSmUXmUPmTpWvnaeV_ESEUSqSYuusEYsMETKEMwFImwTySf]WfSdYEe=qbGShn_hNkDPkrekXaKWdMWwce>YtewsYlYpawSplPplJ@lJUy>ymytY`yvaYocHoo]OPMmTPmxpYwQWdMWdHn[HtguTipUwPVLErbYweyxt]JdxuF]SFMyWuL@qr@qLN\\LnMo:LSEUSeQwdaxnghT@uJAtZGgcGuoXlvayvo^aNieN_dnsSX@_hn_xmYxeyUBqUoUedwGbaXtivEydAoCWKId]tbocMyWWQiOixmeXuqxgqe@OGxEx\\iBMWF@OytQyMufHhYU<p=PkDPSiXYKQuTQuhyuyxUUUUemWhmQ\\]rB\\um\\Ut`XcxnDlRJ=TjMx^IsPlLPdv_iv_ifkwmoNbBweYwi^AsK`wbIqIP[DN[Xfat_tMYpDN[DVx`isUXaqowKYnAGuN>fDalcfyxI]=X[`Ye;VZ=VjcYTYt`gS]yvlivy=HR[C@Sb[IwcIsbYeOWGQMwdQwpif_Qt_WSAmcVCuQodqywYyRBcYvAykwf@SeqsW@=C_cF_cXV?igUup[bJyuyuyWYte_sGisggggWyL;VZaDOcDQigUutcM>wLipkMMsEYsc\\\\]wrHhhUIkMXlMwtyA^=Wb=YjAv[x?yjIZeWxQyeyG^>PxmYxkisiXoeXyeyoypxuivCGcC?[[@xjAxHX\\MOdL?\\<G`kRAIcQugXeRBcVauVqatOqrGWEuoG>SB=SbpibZeV_eHoMwNqYAewPkHVaU>]jxuxjxXiqu[TR@`Pn\\Pn]mbqv`qn^`nNIo_aoSUp@qkWTuguN[EV[eUYYqv`qvqpgUuXeqtetTQuDAVj<ptlqaxkJuq[eTKARt=tNatVmqvEYaHkRIs[eMa`tPqtDLKDLytQypUuCQuoXWupO;HV=qZrP[nQyoGtynb@obHqsHiqpVrxftBFnXpyMvZbXwhh];Gb;iZEn\\VgqtgplPpLVg]wfaw`x_yr_iaYkW_vy_yrIhvWq_gt=yJqgY;BcCGcgDekTvCYlaBUeBR[C@cb<EwcYFNyW[CF[;C[OdLODvUi_etlgVEQYWeB:MYtMyGWEq;EFkBEyXO;cIwcYOH_MCewgT;F_eV_]bJER;HKMlNnxS>qYcxXtIjE]lsXXaqR>]R>lJ@LSB=SjDWpUypiwpp`Wq]nWw>Ar:ArCIsCItKItRAuRvqR`wlnhfAesGisY]qBpohp_sUmyoytYMItKIWoGpkwCoeXoulivEIi\\EFREUSEyuYyAgb?GIuSImCWP=UR=y\\irEgUuoXoQu[_f^TUUUUAuRAIumxVmxWAYMHpvHimuUypiwTPmTlvuAShquwXS]HttQpD<weYwiTUp`WjhyiypYxj;qqwEjRDJ;DJeTOetRAWxaysiYyk>[XOroWo:nwrtD;D<ghDkfj?hjYsQlxhiuEqnndQ;QKQxOYmqn]mRhlOhNeTOUyw]txrQXmUXupYwQy[XRApkWTQPYTUPkDPk=yjItsRHP=HsHyv;IyghueLK?Pp_UcxnaxFxkIxWq]ZVr>wbAwasOx^asSX`FYiMitOiekPf?vhg^jCYlavkSV``Av;Yjpppp`cd@uwVipAdb^lGV]p^xNAb<Ob<qsHqkUvqoxphgutGwLin=v:[SxyYeUWeeYweYakSV?Ip]wRqeTaCWKINIuSIeuoyqIX>mFMgGgcGQ]gREHimuvox;[IsQSuQGjSWPaGKCDKKf]AD:WcxEiKkcoOK<MR<LRBXxuAV`xSYpO]TNmaysYxpyMihv_ivcEWcmsHqs=`vpxp]xRIpXoeXwDX\\ajPplPupQ\\lPeTOEUUUUQytQYPSllqAsKXNTLMT\\UtLUsxjAxrgYuqhwgiwY`QsMV\\MVLip;MV\\MvlivEyrFnfMqnG_ctIuuxhiIymyvkiaSpk=>c^NtSYpawnIwmhwgiw]PboeG\\=EFkbYweYyUyeyO;DJ;tMII:UTaoSg[Gf[E^yhfcwCGhkGhuWiuIx]yro_hnoXfAuKih;eWgeGpeFT=Yr=YIUR`aEr;X:eUWeeeqyqIXNgeWgsv=S<kupCV<aBdcdDqiMee@sIyuYymwWQCjmEeUccCF[CRKETKuUYueGEWtMFf[GfIv[Ix^IsMox;[xhsUx_Gf[Gv=xZIRHsF[Mv^IsMhgiGulhfSQp_SpmXuax`of`WIqmwFGEmkFmSHmqtgWUFmX:AWcEWkuwAsTF]SfKGdKS<MR\\Mt^GS;CB;cdOgdgySOwdQWYuUYU=UR=geWgAwbAWHy?c=UTMUdEuHZmv`qvQmgVEYoQwOAikUv<Yr=YIX?YXodPoV]UVmwYyqYQsDQguuwXqat=_eV_EQodi;e]sRH_GYmiVYr=Yr;Ir[SF]SfwMYEplAtKX\\kUtPhDN[Dv`isUpn`pnwdx:XyO@NVujYXsQ\\jJ`of`Oytli<kEyp<\\mAQuH\\ktQytibinwcyxMVegquwXqf`oFqtPqtWUicGgcilevDiyuyxkii\\?Y:_B?cBiiuuwDR;Er=wJIfUuhhEwbAwnsHqsUsOX_;Hj;h[Gf[Mv>IcKCDK[rXwvIqWtMYtuWXaiSIh]urxgYuaiv_ijWBvmGhkGRAIkYWQqgwCX\\aBQuW[WY_av^af]WnOitoEv<ijLPlLPv\\QvOido`pn@oNOo<Pj<VlevysWZ?PbsYwixq`ncV@ijAv;W\\MV\\GgcGQplPpb@obXaqowNitOikWVapqrGX]]qrGX^tn^:>jA?pPGrvIyaymfOsKY_DfjlOynIgiwgiygYqqK@c^XZAn[FNl]ybWFlB_^qwhqi`eot>xjAxr@qrHf]t^dR?eRAtJAt@qr`xuQN_mw\\sFasX_QoofiUiCIsCI]SF]tLQtLsDQsujGV=giwgyZCIaQeWasFasLMTLmeysYXCESCeQwdAUfKaTN]T`usXgW]UV=ayfsWXGv\\Qv\\awfaEOcDoAykYvLOdLCR;ERwcIwSEUSeSSH`=DlYvA;B:Yg@cUKHQcEWcIryxkKmR@mVGQmoTWPao[>\\<A]R>]nivlW]Xgb`VlaosVHamovFOn=@\\@OdLOhsQx_YsQx_aNaBBZiVj]iG;B:;B:[MN=P:>:;XY;gZ=B:;fiOuIev;WXt=BZ[EN=H:<ni`KF\\KjXPlxVFAm;]XP<JriMQhmCYK:<J>LlLPlDqsHqyjIv=tQYHoG<rZDJO\\K:>f;PmTPmTd@]XD;B:[E?MB:;B:;BQKbDtMCqsHqkGhkgxoixNt<K[MKDLKXpQwMUPmT@]XJLrvuyxiQplPp@nZ@jbA^MWeUWy\\irEpkqiyZY_YxayoipawSghog`KIbBbN_dvSYpagj?hJ?wZ;BA;T;Ax?KIWoi[Ur@grEwDAar>AeSGe?ir?LQKDJHxMylWhmWxaxcYtsYhy`isQ`KIhB>hgQuoHd]pbwNinAgsQx_qyxqy>wr[>rexdipjGV]pwxhieIwcIilevdpYqYpr@qbVVdk_kaxnaamsVhX`asO`wOynAxjAh\\XvJ>^^^^^_xbItkRFQd_SSH]erCRn]Ej;TJErjibMyfIuUt_XcKGdKS>]R^SGeScCiykGYO]SF]shgUuOb=WbG]SFMtLQtH_EsKRnMFHUSIuSYuhheu[WRAovHieUOdLOXrAx[MfMCXTeV_hjEtLhdUt`XuqxgIkCHkQyoYuyvIymToW`pohpSXmUXsBAsVQqoUkWDNSyvtixeyRIp]aqsWf`ofpFasFYvAykMfmBXtLOdLo`f?uj_wRIpSV``_qwWyPx[QGZXYZO^[iYghogxNinAohpohppppxoXgQA\\<oj@pj>wj\\a`YweYO[?P`gOunXmqvgphpoHx[Q\\jyxqyggggo@pj@quwxhWdMWtjHf=AkH_rcwvIymi`of`mkVf@yayayMoeXo_gf_g`of`sdw^SF]SFcCGcgf?=lZlX>`VMlJ=HXbAt[D?GgcGwoYwQIEFkBYkg<kYxmYnMIWQr<QvHiMTMUT=yjEKjqMrpLCxxwtYxaqf`ofMunHWBDnEulhdqwUypUuphW>uj\\AOddltQyoYW]TN]DPkDPytQyHp]urhMunHkbATVdxmyvIAsBAScD_=wjHfuoXgQPplPxDh\\e>kHRTieusXJKR]wRIoevCYleWgewfGUm_r>arRew>oR]GVy]hn_hZaeIgeXiiuudUWeucYtaXLCcN[LbIumxVUupheNt\\LAetQyty\\YrAT;ER;UR=UViquwPUTodipeG_hb>`J?d;Axxxlive\\^j@wkXfkJNvIYaHnqtgxDfyqG[F`]sNh^AsK`baNvn`lNdcGgCasFDk>MtOitoqxpqNtDLahTN]T^uVaUVU<P>@lQxlQV\\k_\\pP[RPmTP^>`sGisGiSMfMCXTMV\\MFGoR=qd:oixoIYkg<[ICkc\\Cxx_tNaTnyuisGxaBE=vWYiq=wygHVsYDeSGeVj<ypEKZUo:tux>[P@ZIPjDnjqiyuywy@kyxpYAuL>vay_i>e<^ix`ZraygY^ROZvN[HP^kaoB@kBxkYvaLIwnQn\\P^[F^[^wtIfKGdKoysnyW@lJ@\\Yv]I@\\DWcEWbBfr>arvHimEMGshkGhcyrCB<WE_]V^]It]xBcyqAF<YwQygEWcEGD<UgQugPMTLMFr[EA]DQsDYuixeE[[xqyuyUF>OXmUXIoEwKcJKUj?V;GhkLj=IpYYvAykkxKyynIumJLRIlMv<kHpk`@TbtqwqxUdj<ENtdMa\\n`pnxDYlaJ[\\xtixe]jJ]Yv]yQy_\\^jPioUw^iv_I?hr>`Z?d;Ee?gb?gtOitYuqwWFkB=UUUUEUSrD=R:wcxyrywYyqUWeUWAtJ`of`SPmTPDNNeUWeS[@T>dJ?DkHpr[dV_eVRyyumUXmm:@j:`lN`LpAlyml:eV_eNpqlmMXl=L<MKDLKRYRxDuxulN`lNuTQulQxlq\\Pn<oeXoyAykYJ[\\^N_lIouxNyiQ_:wNygYuiDSKPdLOdohpo`DlB]ymPKjqPxLuXHxUtLQtL>@t?Y[XqqwWuPqtpBB;FtCDaGIr;Ir;QreytixsXXaasFasrAXC<UTMUTMe^PdcxbIp]on`pnv=i^jNf>Ak:@JGrZ]Ur?X;]R>]vVIim]YO]riOUoOC[[DXkExEyliVEUSEmIvABREUSEUSPsGiswlYvAQpIVZLQK<rM\\mATr]QPmTPKLR`lN`\\RADNF\\O;\\WC\\kTdPD@wZ\\jsqxgYUweYwHlKHLYelidwZeL:hT:xT;eZAIrQx\\fFZROZvoQlI^qEN_Rn]QHlKH^\\N^<ys]xc<ys<g][Fb:>ZZRLCTJctEkixWHlKHJsEiCBrAB:Qle@n<Hv_er?irOeTOmr@qrvIqmaMMHmSHO`lN`xnaxRn=L<AVUyWxmqH`LAQOPuTQuTR=URDXIQxvIymyVhmWhpn`pNpMPutYDAc;O^K@n<Hvw^yuHf]yZjYs]@pj@ptPqtOr>H[vYhkibaf_gRHmSHOeTOeV_eVCtS=CMGeSGcQqBFmUXmyoYwQIsCIsVQXUmbfawfqhpoHxmyL;Wf]WvaysYhHocH_f^_FKIU:ksZOb[iVYkIv=RBccRCH<?wZ[b;gFjIwMyFTcc@ybqKTbutVauVWeUWg[GNTMUTtlHdSGeSs@gJ@pD^fawfMIwnoiXOZv^[HP^kQ`f__soiXQiwhiuq\\;Q\\ZywG>e@ob@fk@WvUi^:ve<>x_>r=An<Hv_?ug@brIffItX@f=Nl<Q\\:h^jYsiB>uB[kBvEC:QG:YrZOb[IUGcCGCYsEYlQxlaYlkYvuhXyiyucJKHlKH\\KIBCVjgF:ysYuuvayS;fMIwSCESKR<MRtQytaRaEFF[g<[QN=PvTOgdOghoghs<Qr<@wZVdOgdoixeUrAx[QsDQs>uNFLQWpmTPmdTOeTsIyLMXVAHT`msVHkEuWFlJ=IuSIUGeSglN`lJQpKSQOqtPqpohpW\\arC@uoYTv=k@UnwxYyqUSO`N?`vF[d>]XhjgiaXh`eo\\KIbBVlPpl@AfjnfIqmG_hJNRGiswIxHV[EV;ypQPVKAWn`kF`K=UR=ePodPVMQvyxYyYi]urHTV]Uv=yjIVVMQ^UOrQLBQcOauVaa]orFN\\C`bno\\:xab@frcXoeH?DTGH]mBKIRBSbgiI@gF:wthyBh]dMWdMatNab]QDb]oBhyKAtJAjQumfYjwEKjYxA<JPEJXqJO\\KIEKItKQeTOexlQx<=KwXYqqsVauv=wJIn>uj\\AoNatNeQwdq?UkPDVyUOdLOlYejveypiWFal_v^HcM@\\<GocHo\\N^\\n[Hn[>wj\\AotQytW[EV[wgiwQodP_fw^>Qx_YsCp[?IakGhkOmTt`isUGD<uwXiim;Hj;EqkWVCt[?QhmWhHpkHPp=JwdPodTF]SFqsHqkbAdU?rr?`vffyqywi^_f^sHqshj?hjSHmSHf[Gf>w>Hp]urxtYxaO\\L^@WnwFilafuqxgQ^\\N^>wj\\uvIymIeSGelKHl[Xtcy[YrAWWPagK]TN]Ft[DAeuywQV]UVDmFmykwkAx[YncWPaOauVambAdVXveYwU?dJ?lMXlMwDirAyrYgIumdFmviwUdwVHaeCQsDQgf_g^=HRsyvYxIQyoYwsIYvKVXqBO[CIEtPqt`SdCyrIwEYyhiueoghoggggGKIcrcSUUUUeTOexIyIyaCF[CN]TN]ukWVACtC?qPplP`kF`sGYmqtWYWqdPoDX_Hwt:ylPplP@pj@xcYtaXsEYsYfat_xditeNnMFhNpppppXpmXijEv\\vgiwwrHh]uphgQe\\X\\kOmPplP`qv`yGX]qnoVGqLatNavgiwGKZuLb@VrMSj=XjxlQxtThPe]SGoZAvZMf]A@ZAn[V>nKAgXpmXPeTOekGhk_irG[@XKQTOeTo]wRIH_cF__b>_Bx[yoII]mrFWXaqsWqiwUI`kF`kNFtqGdVpMx^ISitOinohpJxjItMlYuH<M>@lUXmUeWgeoYxmYPkDPSv]Yv`lN`LKIk:Tq:eJ=YTN]d>`j>@\\WDL?gb?wCYdaCcHER^KC?OXjAv;MfM=DfytYuYwixQyUCoS;]CSCESWxaysMce<?S<Ob<wbHcE\\KI?;v>kiess;;B:;B:YBZOb;<Z:^uAN?;J:<JrxKN?:;BZ=XSqiwUipopIymytpIExoixOUTMUr@Aw=amwTYPESCEw_YsQ`R>\\MN<Xh@VpuwXiugirumyxqyExLilWgeW?yXp=J:<rCMWdMWRitwLqtPq>uV;\\qfTPmTlDenxuyxiqwMsAxKYLkEXkELKDLua`V_eVOhlOhXfPXriKHiLF@akY_Qoo^_f^_hV@kWWuc>^Z>^Z>ZQpa;>Zr@mTPmTYjABIsCIWhausLce?;xlwBIkEvwYyqEU[UUSX_QsOwXiquSUUUuhIECDKCtUx`isTgHe=cB;Ib;vVErrGisGsBAsnMiLgwnIwMiCGcCxkIx;yHYC:;Brss@qr`AykYvdKGd[RACBv_SLMTlWtJmR\\Of\\of`ofWsfBCCCCxUiG]KI;Ii<GdN_dnuXquCGckWITFDNNeTOeLN\\Ln`VCQLwOyrqsE>Z:>Z:^iEvymFiWauVav_ivwgI]w[IgMufTSEUCVBgG:;J:<rKlyO\\;pxgYuY\\Qr=TMUTMQuTQMN\\L^av^aJu<V:<J:rKSUhofXqhgUev_ivybIsEdKGdKeTOeH[Er;rHGi:;B:svsEYseSUoHgiwUyh>uB;;bYIh_ObKsDQsupgWUETKET?eR?Qv?YcoaxnAuksD:;j[EuSIuxmYxuOYmqnaxnaNtTK:f]up_iouphgUxpqxhUsPydW;HSGeS?KEtLh\\LKDL;IP=mSHmklPpllkWLJ:<yVeYweQpyROeTODpC=J:\\wd@VTyJiXWhmWhipklTr`TQuT]YQZ]SeUWe@pj@PHhM<>Z:>rZFrhP[`avCYlnOaWPb[@yrE[Gf[_sUSVaIy@ijUlPf=MHHM`lSV@OitOIXVA@J:<J:<M^<ulmMFEUSEUJ=TJpkHpk\\Pn\\=UR=uUxPi=uktL:<J:<JjiOp`TjtrIxMaHtbmr@qrlMXlMSDMSgYV=AJ:B:;X;wY?STTMUtEv<ibOWGQMcCGcKGs^iUuoXwiyqyujWE@;Z:>vBvyDnvrIx]ioghouyxiyrXNqr@qbPodPrGGl:J:<rKlsO\\SkEXkIymyvQeoTencHoChSKDLKDxjAxr=yjIVlMXllqmQJ:<J:<JYQrsPjsDX\\aJWpSqQxlQwrDXmqvGQWdMWXquXAyHYK:<Z:>yPnsO^kf`ofqvGYmUyh:Af>_b>ohgQu_Hn[Htx>cF>Z:>Z:>r:?vvn]Fwnwx_gqpgc[YI];B:;vvox[kfNeTOEcGMJ:qoKdw:<ZiItOitwVh`asUypiWitip@>ZZA]b@f:BZErPtpLdM;<J:@LUpRnXZ:B:;hO[L:>Z:>juU;AB:;B:;buAR?<Zj@vIxaxAen@gKynIwmBp[<>ZyXjmFi;>ZZxox`isQpcWt`^jJWf]Wv=yjIFkHXZ:ve=hijB:[xOeR?eBpyrqywYIcGMB:;bDkB:>Zj;<Z:iir`wv>mtPqt`xnahKGdKyexGy??eR?mbAa:J:<L=XmpIrVLQn=W`asSHysIykEXkmn`pnIymytNtDL:>Z:>\\=XgpIrVgqtgxBIl]veypiOOdLObBFcCGcSWeUwqycQYtMYNn<J:>ZZa`hAuAVb]HtpowVIwbAwBhli>[[vfawf[F^[XbAp[KV]F>Z:>Z:^jZqkDnvsYxaiv_ivMqnGWgYP^\\N^lnivAyB@kBpppp`<Vj[Y_Z>^Z>`j>pZ@n:@wZ^ZBf[GfxlQxDAsBA^t>[Kpex`IWiuwF_cFk;EFKfm?D]atcWTakSV?ypiO\\XjJlrCIscquwXYGhkG`RADN@MV\\MnUXmUMR<MJYqo<tRIpMwdXdaLymW?Ly[xQO\\KGpRuqxgYUuAqB\\MjqxgYU>@lHpkHurCPqtPqohpo`qnLP`mR@mjuXqupn`pnkHpkxpqxXhmWhDtC@Qa@ob@sIysIar>aRMUTMisGiOxlQXxKyPrdTOeTJ=TJGisGiLN^oVGqlN_dNoohPKINsRwYyiyiusXhatPqt@qT;_eV_E\\WDkMUb=WbQv?TsDQsTUUUuUupXgpohpkbaRVdTMUTmmvFImCYlaTsEYsmyvd<lKHlknkWfwUGZx^e?>e<Qe?VdWgegQwdQq\\grD@sBAs]vbH@yuYymH_Pw^YxayobBFkDPkp_mBhaf^_f^vFoZHOsDQslIxkI`j>`:qa>IisGi>w^\\am<Pj<X`aosFGmlfbAwbAxmEGmeytiXuRAub@ob`gVAqKx[QNZpP[RN]TNx[g`I@\\doghokHpkXgpdglLPlLndDatQytMf]DXndPO[WO;TPmT`ysLmbIyT;oI\\EvFmu<Ob<GImmvfCUl_vvIqKLRxpqxpyxqyUuphelJ@lZUUvxybPodPRWMORDPkDP>@ToeXoTxQqvayvQmTPMpiTMH@pqHuKlx[lxkIxkLPlLXn]XVEqleNuqvXETKExhiuulxoysVutwpnYqqwUQmmfmvfHAgeWgUAuRAatNaHomvFmgH]xvixacZQ\\:wyg`tuNob@oBn[Hn[HbOitOiwgiwWcEWsrIwEIqi:[rxgYNIV>YupeePEbOSGP=himwOeTOeihCbpyCd?b:?BukDQufLehcGgcKItKItfkUv`TOeTOatNaTYuUYvxVtpgj?hj>qi@NqxQe=QosYwQudMWdmCHkCHo[T``Chi;N`lN`DPKkxoyueoUqOBHqsHAXwQsyyjZ=PR\\KIucFnnTQuTq^IomvFf<ajPqtP_gDPqtPq`pn`fk@Wwci^EwlhRHLlsupRXyqyw]\\jxlYvAuMUjsTX`AN>PplPptlSnIxkIRBdUt`XcxnQEmUXmUUUUuoXeqT@u_\\k]LK?PVcEWC@LDysIywEQjgYQWeUWMnYaUiqVIqmWxmYxW_eVodXdaTvuuxmV`mNKyWhxo@ikUtjJLQp]wRlqE=rIysI@wqmta\\LDdV`asS@kcyt?uyRDMSDLwqvtaRXmUx]sRHP]yrIxrqiwqtPqTLwqstQsNatNPR[@ytQy\\Yq>LR<MbwqstajFo^iPeoPodPoDvuqxsWOtMYti_urHrZ?`tQqInv@ikUFxkIxqyWIGNKCpcvWYiqMR<MR<KBV?iXSULMTLCFNQtLQtkMvIyeyCD<MF\\KFFyUeIv[IhvEylmp@XNyuYyqm@DqS`PcMl]Xn]hkGhseytixmxdYDqksxsWXQQiuWimWdQqir=xJIlOV=qJiwMMqtPqelTf@Xn]XnlPplVemJYuUYUXmUXpps<Hq>`j>tWiuwhumLmTPmUv@YkXn]yyeuwXYv\\MSyyZyasFW`WahM`hSFkLfbhfoEObCG\\Coooi[[gumw_qopYVkoXgWyhQ@eqi^qAyhF_LO_[F\\\\NbqFeWYcTfe`OgTpfHywIxvqxvovq<GtV_kxvwybSwVXWxVwsscskmImaeaIIAyfIuexKeTOelMCZKItKUHeGqCtHieuSF]SFy;yKCy;Kw]xNgdOglN`lRXTWqUXmUUmpVG`QTmWttKItkIlUhDvj=QhqwhavyDjSTP`]LN\\LBYVgYXaqsoIxkIlAWmbF_cF_b>_bYjYF]UV]uQytQYkIHoK_yXuTtmuvHipheuTmSGxP?qlgTU\\UV]uQrILw=KBYyyMROLtNay]uyxiyTMUTmUXmUnESUqpgevMLtA<MTLM<<RGeSG`X[DcbIwciitGuhgutHoDyuuAwKYnoQcbar?p]?aiqqwWGaghmEivLp[XfnrGx\\ibwP\\eV_eH_MonbNxjgwSYpaP\\qAZ:^`VBJIcEWf]WFsIxZKDC_vQ;bluHY;BHaesSTi_bVKBXmUX]XqCVTMUT_ePqWdMWd_xw;rZ=H^wuDuFhKytQylqUughoghlux:UriwhnMv<uyxmdYsVauVMSDMCYigvMkcWSIPug^=v:IbXmUXUf@ecLedMCe\\cHcSbK?S^CsCIswYyqyvj=IlqCbYbBmhNwdQwvZAv:uDPwdQWB:gdOgdLMRLWg@GcEUs[?y>ive[tjCXcEWTkFhcGDObMsdi?d<WDQf_vA\\bOn`ffj^ixveb^\\dFhyNlKYkyaymyknGfTOeTpqxpyq```HsDQSKCDKxkIxcIumwflWVK]H=UR=IYmqvsAyraCX[IrgVxyb?;BtKItsuyuywwcIwsjGV=adoYW;Eit[XbAh`esTsEYseiqiuqSSIhbsbeWgeAukpkYtQXElW`uYuKgeWgMx=lrWiuwHtKLJYaNEUSEAnZ@NiuWiqeoQdp__d>nCG]FpkHp[QXsg?exPioQwOV_P?]SRlocdoIQuTQeEWcerAyrivEydMODXscqAykYvCUd`ChSaWsugWEVTMxgkbwayvaT_=iL_yFcEt[TcyTk[deeutgXDqC[GXQygYucCGcSEilefvkyeYyRAHZoD<IuSIuSffAGnFg_sa_jiZTPiy>m_WsPhr@qrLYfcGyvoylivEiwgiwO>lx@Z:pn`pvLh^EO^]V^cIqpG^[F^fo`uYf=q]KNbBo]lYxmybH`]shiuqx?V[P>_un\\>PetpnH`vWOqnGgGgcGAp[WrV^]V>cXVviywiWgeW_IAuxymoYwQYxr_aiv_ihvEylQxlQxwVIQcXdad?gb?Or<;RBCfvHyLDk>lQnUxX\\jJPjodP=HVj<My\\yjYrThPe=yvmq<lW[utJtj=IKHlKh<Ob<sBAsZ=PRDwcIwDEK=DN>@L<uU=xsuXmETlCaThmuZmV`mV`_cCHZZ^jJNbbYgZP]Iqn@?[[^jJNl@H]FNbBF>ct=GEFKRBCF>_TIkVj;C[>coAf@Vn\\?s]WdbNkLhgmP`i?dh`vnHyoq]CWt\\@oJy\\:v[;>lU_pgFyJ>bd@[m>]OVbXNlLodPo^UqfEWcEgluabPqnMytQyiqqwW`gUa_gf_?>Z=VZ=FupV_I^gpVqOWoPO`YYZiquwXd[x_:>v[>^ey_:@bZ>:USEUSpgsDIcvqx:ohpohfUe?MX?GEFOckcHocB:Ob<OBSkhSEUSEUSPln`yoYPmTPe\\Of\\lgUm^uYdPs>eYMUTME=mYxmiDcWx;stADJKC?gf_gfdOXB;eTOePcDOCspgsLOdL;Bj[Hn[dgUhlMFIWRZ_f^_RWeUWSHRct<GEFOc[sfSwHimuBAhGMtTOCW?rr]IXCYlCif_v^avj;EFSDMSDSkhcsI`mV`MhwQB:;rUwHi]T_YCZsc==FqsHQOfboffIBGeSGMx<EcaOImSHmCb:=RlmCSEYpawS;BnmwVIU@gWDyCQWsOGy[;xfIumSWeUW`SDIIcd_ByQUdkrRAmghog]R>]jFTuvPYoQOMHsV\\Qr=pFTuNn_hB:;spuC>]R>]xeytIeTt?tW]UVMDLKD^=YScfb?gbIr=wB^urxeynaxnawgiw_mYB;HR[c`_w;oWWQiGMenCcEivxysyayI_C=;yf[FHAxjAXSkhSkDPkV\\MVLYfAuCSkhclJIlMvAv;YJSlX>EK>Ljb@obpLxaUOeT>HMFPwkQxlQkEXkePodPlOUj[Iv[iYtaxklPpllOUjletuxXimOQXY_QsODUo<UTMUtuwXiQitOiDUo<OimUXmUoeXoMPv=kk]V^]n>MNKeow<XaqsWlMIxNepJ=Yr=YqquwXqqwUy@UWlDmFYtaxSaiv_iKYlQVmTeuyVmXpmXPplPPPv\\J>QVkitexTw\\Qv\\T_xJ\\]xbItLDk^QwOYolPWjlOhlSZ<Lb@t[<jBDMyuUqtWXaqngnGVsyAy]yksXhaqtOitCqhog_MxpqxhGgcGIl]vb^OtTOcDOc<Ob<ajCV\\^OtTPZj>]FH[Mn^VoqvGayvaYo^Gn]r>h:O^K`kUv`Ho^gH_:yhYiiaGgcGqiwuxFmnpbK_txhiuQqnGw\\wfaw^MpZO>rUYuupohpwZIr=P`cg_gREgcGgT[WR:;BvgiwwgXeqoYg_OtTIqmwvDWcEgiv_i^OtTPZnWwPisPqtpwuxhilPmMh\\V^]VqpgsSIuSmFgGF?IfbKc\\?goSWPATl?hpewTmDEgdXoeHETNarCWDu]xbIRK]T?eR?Gf[GvRIh]uIp_t?WCQ;BZcOT`S\\=nsLQtLYsEYCqpGyo>AmkTVF\\KFluwXYQay`pjItMhMWdMUOeTOay``L`@qr@UAuRaYyiyqQHSMeoTeplYxmYWxUTD`Xdatc<Jr@X[QRmYmtTX`aK:\\j@pjptqcdRlixoitMYtedOgdWxUT]mrFHWUqpgeR?eRmYmL=mqxWYQwcIwsQytqPyHoTPmTTKETKatNapvqdnBuLilU><jMxNImPyHob@ob<JRyqyuYmYm<MkKPlLPXdatcLk\\`VVHrNplPPwbAwFumxdmLPsZmYwixQmJ=HxrIx]ykgdjS\\saQSGeS_EpRUkQtOhmVu\\n]LyIxQxAlC]TD`LN\\L^pn`pXqqwWqVpXPamsVlKAXlSHmcTlb`L@]OPtxditeXXaqs_iv_iscujAYvSEUSexcYtAMNK@sdlP?ASIuSaUpSqyxqyGaWaLOdLk;AVfuuxhU`DTcLt`hSU@mFmvGYmqTmSqs@ikUDMFlrWXQq]VLdl<AS^LLAtJApkWTQpTxA`m:=NbsMQuTQipohPmTkGFsUdQmB=ESoUrJ_C`GtH;EDSHRwGlYrIsQ:XnAukxEXEDWcEWtQytqkHpk<EnJmj;HO@eV_eVQqoWeSF?lS_^Yov:Ij=>:MunGS@Gbc[swWYqatOitwcIwcr\\ExQghJuTQuv[Iv[Gf[GxZIr=Cu@DPp\\WRAJ:tYxIyayLq@lOhlOQqoUwxdYtatNatndYcxJIlM>tJATOwxs@xsayxfIumhSUpPixUypy\\qRhdUt`r^MPaqsWXOu@qNtNsDQSUSEUWRAp[MNK@wEQUJ@S^TLalSNUTMUkCHkKhWf=Sh`vRHrJiuj\\N=HWnXJ@PrFlvE@k?QVitOidXoexiTqN@lKHlKIoMuNmTPmPj<PJSxr`@MSHmShoUuphquwXYHmSHyLflYpawSmKAXPh]urdleqYZhyoytY=JjTX`asi<ysAONLKa]sRHJ:DN[DNlAkGEJ^LLCAykYvSaWpImm^i;QvSGeSo`pn`@qr@ymoiysWypiotPqt>ZFQmoVwEnddVeyaYYV^]nPqtpTQuTyElLI`kF`tKItkMXlMT?yuj\\rSYpaEMFlrNnnvodHNcNitOi_SOp>>Zxwywyhs_r@`vAokS^[oygq^kaxnahmWhe]h]j^\\`?`YOov`qVir?ij;AfvAy]ykYhhTnkDPkl>`j>`mV`u_xbIlvQrM?jUypiwphguTAuRAa[F^[HwEGk?QvZ@nZnZ=Hv`qvPGeSG_y@xN>fEqlg^[@VrSIus`n^`ncYcOv\\QVasFak>]FhoUwpDy_pfZb`of`]p^gRVj;A[DN[taox@oR@mRVb=WrphgUq^_f^wotTvwYyqIobJNuUYuyofjPhkwwXia]V^]p`gOuvow_anWVap?pR_oxhiuq\\Qv\\EI_pfrRipew\\MHsn_hn__f^?oiNEUSEeuWiu;BvAx=yClYcGCsCpVj\\nUln]urHpn`pnGpX:ATRHrnTjJ=OVpQwMQ:<QtLQpdvDmXxmYxaoSUpByyVEYsEYD<kJmuLYtMYQoMw>qVmxLgLUNalm@ygYuqhMV\\M:<VpawSyu@iliYpausd=Wb=MUTMiYuqxoKqwnQuT_fTij`pn`IymyvOV\\[`eC`b\\@j:@:[EV[Ehuuxgubey<Ob<GimuvdGgcgXgQuoYCtoGxohFkb\\?gQugXEuRAubGgcGyuYyqcvfkeN_d>mwbSvgiwGyvmiDJCfvgyqyiyitLQtdUt`gsiyiyqubuYLeUWeu[WRA_sFasr[EHUXhOr]cFLwW@SRK]tDgDe;eFmfTOeTwfawV]gdkSbcmf]sRH?dUIctWQy\\YrAxUypiUwO=LDdjQuoXemwTYpppppPAXrC\\KF\\LB\\JDEKOmMDUSEuvGYmapn`pneXoeywiyMOdLOAx>mULMTl=wJIn[Ur@HJ:tlEiQp]wRPP\\dlQ`v^aVlDLNQuTQY]qrGHocHoGTwvdYtaX=qjGdmtdX<<ZAv[h_xqgjdGasOx^vlEiZ:Hf=qjwOyJ>gOQoOvj=Iel`fCYyqywy@f?we[oZ=GdNvkAYen@gKFi`otVHamO^]V^UrsEWcEwKYfAuRH_m;AVnhWUqPr<QReXixmp\\lLPl\\gtO>Zff_gvtixeYPlLPtjpsmyVyexMyCqjGDyCyXyqywerAIk^MjHAVR\\L?EJ:QuoXWq`WSQN=ISTiN_dNVmOqpohpOcDOcxWYqqYpovEx\\iRiuWiIL]lRbAwbAsjljRAuRIJ=lJ>hj?HsjhsipLYxsyYvIxQHemtdxvIymmLEhV\\MV\\EV[EV\\MVlqywYyVauVaqv`qdQwdqPgMuFXMqlWoQwOqTPmTDqkQmxLQtLqpheuTlLPlTPmT`hn_hVhmWhmgVwdQwpj@pjisUx`?ir?Qfk@uHqshOsNH_Ex\\indOXuie_Qx_YsuqxgYcEWcMCc>mb@obgQuoWWYqiwcRKEIsCIsEYseV_eVVkCa=sJGFEkDf;EwKYnOh=gdwkIYwiausXWdasSxsYxaUGekkHpkhj?hjcHocEUSEUXmUXdYB\\kWTQpexdGc`vx?NlLPlBw]XhqwhilOhl`cq@nsP`mV`qpgWQisQx_QtLQdGgcGOhB>wcIwOf\\OFl=?nhpoHqtPqhLanCGj;HjlhyIqxeFhoQwOiquwx@ar>atPqtppgWQmEivT?eR?`R^[l?[vXIWTMUTmEXkEeqsWXAykYvkIRVQgeIwMyfcGgcWdasSPwT@SB:CB;CBcEWcutiwUi]h`]Wf]wdgTe_VuoX<IsCIWqqwWQxbEyegdXoeXkEXkeOgdOWeUWUN]LQuTQauVaq=ujHTjAtKX\\Qr=PEhrLmX:Px_LLCpWXaqsUwPioqtWXav^avjIyvULMTlpiwUYUSEUGPMoLSOmMuQtV\\QXtOv\\QvIx]yrsHqs`v`xYgQuoXPqtPqxpqxMoLWNDYjXxqhOgdOg\\Qv\\yOYoQ]vJ<tMYtmtPqFf[Gv\\Qv\\awfauFYbZYgHAfBPqtPqrAyrAYkeVKB^IfggwTihmOhlHwcIWeUWe`w:dvh`qv`Qv\\QvDQsDmvAY=<Jhtlemgvxdipe]pbGPdOx^JXnI?d>oZM_eV_mQxlQYqqwgSq`E@\\<Oslixa?`BfimAwFnbGoieA`pn`PglAgwZ^jJBLeGdGxVsG>?D<=KLAP=HRBDN>ft=H]FNB=C[ct=RBcHOSeGqFi;IVkclUF;=C[mB=?lTPoAukXdyuyxaUpSYKQlONmXf<Ko`Xl]mE`jJLRYAMPTkO@mR@UWeUgHocHofAUJLWcApIlJ[\\jxtK`xOBdYG<P=HRBjd;=C[:cY@_uVauBAsBQitOI_uB<?TEubS[C<Lg_iv_ieuphoAxjAeuphgPp]Gbbhn=a[@F^>PmdfawfqdPoD>Z\\Of\\_lWV[<g_W:CF>_LFC[[Zoe;A>Pgqav??[w?]IxruOx^ICkEx[XbATIsCIcBigipoPtMYtikUtPDQsDqYtIwadJihM[\\xoYrx<M>@tA\\wSYpAisGisWiuwuthhU?ibO^qpy\\inerVauv[SN`^GulhfCGcCwmh`ibAt[pqwWyXoqvGekFpo`]ewthh]r>hZOhlOplXZ;?w=A`=HbBfi:Qv?YkMXlMXipawCNdI^fP?mhheupuuxhI`sRognI_JIr;IrIv]x^akOv>Pb<Wgc^^LFshheupwXiquGwLi^_wr<@tAHvO_^>@tAGwcIw;W\\lSH]XoeXUOhpyIxAqcYtaxvIymi@lZPUDlNMHYvAykYqquwHYmqtSSIpZ\\H>;cf[Gf;KsEAVBQuUcw;KXpmXpmpf@lBPUPHkMtNH]mrDTSITZ\\xK=YODK[\\xKMwdQwZ`ke@SYUrTIL<uUs\\w=HRbhRMTk?ILKDL[NbLXLeXoeXuSIu?b:?b;WBAKdIEwfIbIyviiuuwxTttlYxmiOgdOamsVHweYwEuPlewTipwTYpalQxlQdLODweYwuTQutoXeqTar>ajvMYiquwhMulX^qv`qtPqDPQsDQ?lJ@LuRAu:<RGeSGMWdMw=xJILV]UVuyxiyq^EsLhSUpPWMqnEWZAr;xYxIyaDwuIVj<M:<LPlLpytYuYw`YsQTAuRAYr=YVcQt_PytQy<EnjirE>s\\q`pn`Un`f?_xOmHIl:>ZTFpC_b;_DYsY_IsMXyqqKItKYoPeoT\\Pb=t@hKULn\\PndLOdLYnAwkPWOQOAuboqx:_f^_v_XcQP`mV`YpawOuhhEmwVIixoix_V_OETKETOeTOtOGeFyyuitAQVkoIpWS?OR[qiwUy<Qr<QgdOgXiiuuV[EVkKX^X_VGcQ?nbNwyxywyw[XbAPpmXpo_hnoquqwuHoMwn@wbAw[SN`>auVayKYnAGxkIx?gb?wiyiyqFoYGeSGmLPllAv;Yjb@obHempfsWiuWtGgfawfyIyaymCISmSHmcXoeXyYxYxYgFEmdJ_sI_gbQv?Yc[Gf[GIsCI?ir?qxpqxEqdgSFy]U;?Rj_XcQtIgW<QuoWWEKCDkEv;YJcEWcweYwucXdatLOdL_v^av>ar>AwbAwMyfIUWcEW?cB?cuwWYqohpoXJAf;uIvAx=ghogXwwwOIimhR@mRxPYoQOeTOeXTapSEylitMl\\VBDyNUUUUUSeMu=wUPRK]L?ETesJ=C[oD`ohpohyuyxYTaoSGCCCCCCLPwMynmNMHs\\Ep\\UV]ES?Ll``MsLX>quXqYVAqkUOP]ojuXquNaEx:Ar:MTaesThPpmXpuWYqq_tWIymyto_hnoUypiWDPn>MNK=VZ=n_hn_YbYNlIwmwVi`Wf]Wr[AhHh]unbK_dv_iv?b:?ZCihpngVAcagb]pbGPnbNkVPra`cSPp^GsLpuwXiAnZ@niyiyqQytE:[XgQuo_gf_wxiyuIb;Gb`qv`ABj_VCQDDOf<MR<]ywiyCIukAsKWFhmWhuuyuywQwOYgCIiMgs`uurGX=ouvEfJ=Ix]yrUIuSif_gfKc\\OCESCCIuWGs^MER;ER;MrTX`aSwhQPeUWeu[XRA<JRqpgUuAtXc@RZ<Xj=XRhQumXWeUWdRK]YxtY?QkOLQtLQnejrAyrIv=yjY`QsMTb\\LPmTPmmvDYlXUqpW^UoMMTLmTh`USypiuU:<wOYoQdqBijEtL`ysYxoghoG<J[D^bQxMv^H?eTOeXYqqCiUR=URSaWpWdMWTgeWgcRKeDO\\Qv\\QvayvaJ<DJ?ETvlMi]xbItflLeatcXTNdRO`lN@mUXmA]R>]uyxYydN_dvOYoQusYxQiAukXN:<yrAyVMqnEW[Qr?`VN\\t;XJA<ODPukXVAdY?EOv\\QVIr;IVXaqsUOQmo^TVwhKF\\KlTPmDw:QSDMSV\\MVlRF@M;mqOtsYxQqP`?oxyHj;Hj[Hn[YnAwkTFydO^nIhcF_c^ve_kS^[<g_QvmIyplPp\\vvTOfGQmo>:_EsKdvgFccboghoYhausbQIausXgFaMhrAyrQb<OB`SdsYxIyIEuHucYtaxasSX?TNchcUt`;BBOcDOdxax_YsQ_WpSUGeSGoIGGyuYy=;bOgdO=Xj=X;ER;qdgSU`esTgRwYe;AWeUWAsBAStEwv_ivowWYqE:kvIyeIMSPegTeB:SgPeg\\WwnAwKYB:kBF;EJ]TN]RQKd[oiXmUX]XCygyoyD;BQmgVEfEMHmSHS_S`sb=IGeSGuAuHUghooKHlkIpIukXdQDn]yniffebwgiwcX_]r>h:hr\\grAyrEwitqvGY]lHm^iwOX_Q?ZZxiyqyoQepGhkGZ:@tJevgyuywyGEFkrSYhaefeaSUoHG;BpqwWYSdYUR=UB_R\\KyMQb<OBpSegwfawFJ;ClSHmCsHmfGAekSB:[EWLlFxj\\@OIuSI=JrlYvAQsUOK@SNatNAJ:ytQylIyvMPRK@S^QwdQ[^xc\\Vdapc?>jfawfOq^^av^]:^_f^_xnpYA\\dOaFAfJNbNfbKwwYyqQpiuWwPi_:>wLinEFiEO`RXrAx[QYeD`mGw\\gNenQv?Y[:>]n>gJfiDWnbNwWYqqO^K@o\\Pn<WcEWsBAsbHvDGso?lCX\\aNlq`^?FxpqxhT]CEFWeUWUwOxwYyqYB:Gf[GFsUisUx`=BRuixeIWEVJAf;]fe?RtEGLKgWgeWcUliuquu;;bnMX@ETNufHee:;FocHoGVRiS;mWxwhheutCc>MRQkDQsDM]DOMUTMg_gfOAHoCGcCG;;BhsdEmu@yrAYB:WcEWSwOW]wRIodHyhB=ximuvGdhWhquwX=BRcIt]xGYeqCBZMr>GCoQE[cY[CXkEXOeTOuyvYxIcUx=v:IBL_RP_dN?t?Wd`cS<;bmuvHIt_cgUuh@;bQygYUSqGETKEDMtTKxPMFK?Wb=WjCeFEwFAUZ;DjCeFQY??CwEEtSb;IXj;Co@sOPjV`mVxbyncHocx_xbI\\:>lYPunVdMWttWcsGisguvHimv^avnmwvHaehbmuvHGhkGhUWm[XRAPqtPqpewTiL:Lv\\Qv>LJ;DYWukMXlMijEtLLTLMDsUMPaAkF`kc=sFasfpUCAwKwsYxayiuuxhvoaYWeUWmFVyJp]RPbT^`n^`NpeD`exOob@oZXc>Qfk>ZvvixauHqsHp_f`of``lN`dx`dXncauWiuQyOyynYtIurHgEUkIv=iUWeUWgeWgkGhk;B>]R>=C>KBtQeKccVUx\\wBiDrQYyM<t_aVmDYvlu]yrIHJZarCNeoPg_hn_hbdan^`nJxc]Wf]GZZvayvieqtgPqtPqnqs[@_D`dJqtPq^Qhn:>^[F^[GsLh^tPqtHf[Gf@ob@w]VWnnG[CYfboZ@nZ:>dSGeCouL`tGO^K`qvGyLpuk`ixve\\FlF>]j>vMVvA@\\taerv\\CFnPXc\\FlfausXpEwlhVt`hcef_gfxpqxXIqmw^nFftahUp`g?Z:weYwm?QfWwqxginAwKQ\\C`vlivEYkQv_hqtgXeaqsWx]x^iR?eR?ykhrg^_f>ZZPodPct@pXOrkI[^pntPqtfi`qyZNiNi_;wnB^pkYvAYZ:quwXieOgd?cCIr=xZYqqwWyuywyxikAaMqiwU[Gf[giuuxh;Gb;Il]vBanaTmTPmHPMoLkAYv_uVaUryxPsHWbYp``UKpSW<Jj\\Pn\\lXIKHmSHupheuttYxaYKETK<JbMWdMMR<MBuNGTaXiy^ISMySCDSEUSUfAuKPTki\\Ur@x;aXmHntUQppuxPVk@U]urHhJ:hMulXJ@NcLktIyaymo`pnpXiqecYuB@d]@pInZ[pleylYoiSwphgu@ikUvtixeIOclPpl@vYIwy>ZZFlBoar@fXoeX>ZFf]t^\\:NqoWwpGylifK@cN`lN`\\Of\\oOv>IkFasFIwMyniXeqp[:NxmYxUn_Ho^rALkGvYuQKtJyfQqw`qv@Mv^ctBIsLMi;EwLKY]_fQiDN[D>aVlsxhiueUV]UH^=sJ_gfdpohpKETKmWhmWY\\UiDTWeUWXmUXusXhYVojFf<ajCV\\`^lQxlAir?ibAwbYVap__\\N^\\WsPh_^xs]itexdoQwE`b\\>gJp\\NY[XpkV`gfFwsVZ:Hp]wrp^w[VjyWaV`CSdsWXaqY\\UUDYsEiiv_iDQsDqXgQuo[WRAhIkgkYCp]wKWFA]CGcCCaBqouwWYa_f^?EUSEakF`KdkISBCsDkVj;Co_U^]ShCEhARNYIsctPqtx=X;ab>_BhsdeYv]YdMWLodPo]vBIlfmPu=v:Ij=tJH\\KF\\KnppppsGisW\\Pb=LEhrd\\Of\\SIuSiQt_XknQvsDQs<J:mJp=J:eXoePwyonLXduWrmOI=SB=J:LYl<PS=lhyR[xUE\\J<Dw_@S[`xPDpR]o:@j:`uVauHemtdSR@P;uUYuqXixKpjraYxulhdUlYxmyPimuV\\LN\\tjPR>]R>ukXdQFisGixnax@qkWTQp]wRuOitOItKI`uVauCYlaTJ:]UV]U?eR?`XI]KSaSTDwFHvmIyoQUxeytiPWtqkHpkH`]Qv\\QvRAuRwayvq@HfnwwXi]:ngWQq_N\\CpaPYq]N\\C`yvayLQtLq^IomV>=Kt_yGYmi^=HRkHpkH^ucCuyW=wy_dHocHcURAXAQWeUWAcB?cDN[DrQytqxeytIAsBAStoI<Mh<wTK?DdEiBmF;uCGCGisGYEh\\ebneBlMXGeSGedh[ixeqr@qrXlatSd=Wb]LPlL@ubPpyNAr:AnWWqpWZ@^[ZQhsX`aos>>jgVeptPYYwQqVmOqpUDLtjV^NN[;>^]V^=OyVvyxiyuikUv`@^Z>>lX>^ryxFN_w>r?``?wkFA^BibeFw`PgeWgugxdixjIv=ilevdTOeTo`Tpq:>rEx\\i>ciP\\wWpPPiLPlLPtLQt^XcBO`[AwbAa\\_rBp[WNaNodPoZ>^ZBwn_wnIwmPpoIOrBgcGgiyqywferhiuqxFD=oua[S`SXKQf?=BjoWWdKuEq>LJ;xpqxpSHmSmYxmQS<vVuwM=JJ@c`osVH]KF\\KYqqww=yjIVtwpg:>h`U@_VE]VqkHVIhLiFjyWlgFWGrvYxIyIpmXpMItKIMsFH]hn_h>ax?CsCkx;An_QMv<Yj=Yr=yNIoMeywiys]QXMWdMwvIymYr<QrDTKEdr\\EPEhrdTOeTJ:hPemtv@YkQrMYtMuUYuQkDPkqywYyCIsCaVZiWkEXkirENytQypywYy]:>_DPar?xZGdKG\\sV_iQuoX_mV`mAykYVoXgqtiwUIIvj=GDOupgWUiyuyxigUuoRh_XJ]D?mgDCdnMSTscAYB:_f^_fxgYuqGX]irgYuqx?gb?wrIwEYaisUhnuiKmWhmGvYI;mb;AVNatNaiwUyPKEVug[CEFCigqEsWBGmXpmHSSe\\Qv\\QFWYS>QVk_uVau@icUsTiQsH;So=Cw]wDsTkEXkqwWYiugpG`K:modPoTEqlenMXlMxqyxQUhsxDX\\arjIv=yytYwixtixUIEmldRGeSglQxlmVij?ptxhYuqXgQu_iv_IQtLQHUmpdk;AVVaqsUtUYuuxSYpQqtWXaNshJsYnViquuxTipeeUupXWmqvEq]Xn]Hj;HR@mR@qqwUiRIp]xiyqyQn_V?hqwhyiXxpheuTxPimmohpo@Tb\\qkUv@YvAyk=Yr=ylhdUtMx^ISgeWgiMulXJxQqDsEMKETK=UR=urGXMalLEHsBmNlXkBqnK`yiTQuTmFAuLpukHQsDQodPo\\Vbxw]xRI@YvluSXPa=YvlmnARfeKGdkkXVAQtqip==oS@M^AjVUqpeW=yuC=K[xWUESCEsfIumxwXia=IvFGmlffmqvGij?hj^qwkPwdQwEwlhfykyrYv\\f>ejOwNIoj@pjPsDQsHgmtfyrYvIpixoinycpYMYeuoXgQsDQsdOgdOWMqfGSb;AwQygYqbGSEBawU;BbggggumwnwTYpaTQuTUQuTqtOitoYwQ?dJ?\\SfkuWv@uRIh]]Xy?CEgrdIumwFswFG;BJGYncf_gfyeyoyDsgYgasSWHqkWVASIOBC=SB=uywYycyeyeGpPkDPCYsEYnmaKgdOghoUupL@VLYtMIsJaM:<XpmX`dYRtRIpMWmpfEmB]N\\TvvUWeUWcYsqDj;HjGtRXpN_dNs<Qr<J:hqwhYlMXlUrWMyUyWyhjAxjauVaUpR]OWdMWlKAXveYwu@WKQNtQTHYlatSxmysyv^av^mPUhQn=wJymxMyCxsaYmUXmUQuTQlsqu:<xjIv=iVEqlw\\YrATb\\Lt<Qr\\WWQqOIsCIWWQqoEwcIwdMWdMQtLQemtfHwRIp]`R\\DQjGj]yrIxawOyN__PVeUshmWhUCQkG^wrbaisUx`yvYwYxoXgQU;ER;UwPiguexdiv]YvmcYtax\\Qv\\ivEydyMvEGH\\]rB?wbAWt=WEob@obhoghCeoiSbYweyEv;YJ_ixGX]qBsesZ=H`kSV?Ih]urOitOiYmYsiVmqvGQETKE^MTOeXoehnAXcIImmvvMVgACwMuMyfIUTMUTasSX_cqYb;=CcKBYwsawWOoxO?IqmwVudhcUpqwWYGNKCcQRK?SnwWY<J:IvjMWdMWdiOluyxiYlyYbdYMPq`YNw=SppppPpd=Ts`NLDshhUu`OgdOyqyuyWk@UFulmIyvMXWApeuthPSFtKwUJbYy;Avr<M>@l\\<WcEWOYY@AlleV^]VFmmvDuXquxEv<ijLYx;htNat`ysYxWiuWImsxPKB`RkTWK=metTh`OUmpfmrFHM]urHhlx`Kahn_hpgUupdOgdotPqtdN@xjx>`=HBeGKMV\\MfR]GhitewtAsIgOgdOEj;V:CEOIFi]vlQCSKfuiCrWXaqC:;daiFOYFNKkIEN:=osAP=HRBdp>]V^LPsXyxeQQxOYmYmqfYoisibkFlJ`[`puwiyNwlghog^i^wrxqyuywtPqtXgQqoO_hF?wUfjS^[<?o_Nhj?hRh`eod^_f^Qn?WkbIiEQZ;@fyqywYkQv_xVipa_s?qLPZJ`u?xr]iiUvlM`yvayVhmWxiuiwqh]unhJYjfXsDQsPioUwhnAwKAsBAclAfH_jTx[aWd]^jT?o=xZINqr@q>D[cuuwXihitNat^\\?GqtPqxFilancvx@HgxFnJ?agOun`xnah:>\\C`bhqwhqkHpk^IjXQoEXr[ab@obX^ar?xvIymYiqqW[Gf[HocHSaWpAgKUfLUTMeDmEVHchJ;e;AF>@TFmNmMsNHOMmnFETP=JdQwdyvHimMmtTivAUTMUPZ<NZ<^:Pp=FbYAavPk>@\\<gc?wuBvbtq^p@[[fn:a[@F^>PmdXcQp_^IqVYrAx[Qohf>[o`hrg\\CF^>PmDwdQwxsYxaImSHm=nZF>dp__BJFAVJLRbYPnhWUqpgUupPsHPJ[\\jQElJLRBDN^PjjTj;ObBF>AV@SJ>@L<MoATPR\\jJLRBDoXFrZB>?ltoZ=<e@B[c<B>::ZOYxywcO>\\DfjSIuSQsGfZ[^jJNbbYtlQxlAsExyEAfVauVqgVAq[`qr?\\<?;Cf`CXoeX?;B@cRKMsH_B[[bJKRbYxZAIR[bJKRBCgX[sZ=lJLRBexZmJ=@\\JbdIrFkB[[bJKRdwBm;E>F>::JO;\\jNusa]VjLVk@QitOi@pj@p[iSjQOdLOdQwdAseElB]r]Ix>MNKyrTILC`RsEYsEuSIuohpoxMf@RQXS^LLXtkAupvIRLDk^tPqtpdPodYLoMxlQh`qvD_^LxcNIbBF>[f<MeNGrN[DN[sXlpUXmUyKy\\yjdXdaTWdMWHl]tRPeTOej?hjg`UsPXJAn;mj@pjSIuSIysIy]lRF@TQuTieuthpxpqxaxcYtmYxminUISF]SnQxlQwQyoY=VZ=nYxmYHpkHxVHQm=SW`kF`kWUqpesVHQmXVAqkylyrYNYxsY`PcMlPplPUwPioUqpgUqdetdPYcqk>MNslXfAuRHP]mRIpMgIwcIo]Xn]QwdQYlavCAtJAtJSf]Wf;BJ]Do=wJIFQuTQiREoDsIysIER;Ef[Ur?hv_iVmXuuC[[bJ`l>PWFeXoeXapc?nZ@Nt_vxiyuQatNavkAiCHkCxnIwm`?`R>ZJF\\KFvdQwtXiqqwMynIwoVGqLwcIw[:NuqxgYOeTOcPPal_vBpj@prOX_Q?wpo_V?q:Qfk`sFasXwqxgylivEYvAykUIuSIZ:xqyxqQxlQqnGWmHimuvpgcGAtJAD:kvGYeAuGRuTQuHv=yjUSEUs\\Of\\KTlYuiuiKgskMXlMEt[XbIt]wR?KB;AekSVv_ivOgdOgBeeb?gbkB=GViuWYUUUUubqT][bJKRbYWPAY@SXsQx_=Br?YkDw<uSIustBsegeWgE;BxmYxPR[dU[TPmTtBAsB<J`]sRHRK]tMynIEQVlsnHWMQwolMR<MB<JHqsHavgxqyxQ:\\XgQuoiwUypnemutXhAJ:pohpOWMXdatc<JRqqwUQWMNK@SthXeqJ:tlhdU\\dNmqvGYJ:`uVaUcitsXquXJ:IqmuvTdud]jJLRBdYGQMyPk>aVlDJZusXhQSIuSaX[=Yr=QEhr\\toUepdeJ:tqxQyetj=Ine\\Xdatceytix:<RXDYwXYqqwTQuTIL]lRNYWvEr<hJ:<XeqtgxVIqmK`P?<J`pSWPu`hSULqHAr;XJG`kFPOdLOdL_JP\\Lq^c`cj>]FpuwXi=>ZcXxxiyuYfAqkS>]R^pewtHOio_^EIcF_cf_heH\\<?[[^xoVde_p@XpmXp?hj?isUx`g`ofPqnGwl^hbAdqv`qvdQwdlgmB>ZNatNAvYaa@OmUt@;B<Cb:;B\\Qv\\AB:Ws_qteWVgeWgWf]WTSEUsaxcYthiuuWhSaW:;tPqthwTGUSEUC:KgeWgCmt<mtO_dN_HqmwVMiHmWhmg`on[Xb?>jAykYV[?PbpVmwymyayAWcEWcWgeW`ts_xbI\\=HrZXhi^jJNBMGdGxFkRQuTqqxgYuygypYUn]XnYxaysMYtMYb=WboaxnQr=YrAcCT[xCgBCmuZUV]UB:cV_eVZcHCASTgb?gRdMWdyfa[ECuxhAB:agSUhHsEx[YdaLxmYxUR@`K[@OdAt[N\\LN\\Hf]t^fdOgD>Zvn]IBwcIwgtewTQYuPoxgYuMICGKRBCF>_TNUvS[C:;eUWeiausWD:kuxgYuUv@icgWUqDSCEuvHYm]V^]vallDAsBAJ:Hl]tR<<jCHkCeR?eRPmTPDw]Dl`lLEHJ:QuTQM:<sV\\w@XtXHODPJ:LQEIwSYpaMV\\MvphWUauWiuuuxhiOPTkg\\OfLlLPltmxfISd\\pgUuP<JXyqyuumxVIMt?]jJLb<wuLprAIr>_b>_r>arJxt@ob@Wl`fcDHkCHvj?avoayYtEnmxfiTAr:AfHams>ZZIwcIcTPoQwb\\Fl^av^AeTOet>ar>Z:gcGg[:^dQwdQYo@Oc^XqjOuoXgAGdNqpgWuhiuuxxZIr=X[Qn_JIwE>ZnAwKYnOWoP_ixvmH`][^jJ:aC`?gb?GwcIwyygSr^MS^KdkSnKpOvtYxaqnYumuvHiRAuRyiyqyu^mRLQwOYoG`kFPN\\LNLLLL\\nehj?hjOatNaJAtJMHpc\\NMEYyqyweqR<sGTw^XPUtXquxJAtJI_HgyZ_stPqtXkQv_@>jsWx`iqrGx<Oy]Pj<PjqwwXi`t<dIPrlqvGwjIv]p>`j>hpohpV`mVsFasF>[B>]ynivFmBfcmyxqyauoxfAt[Xb?Qfkiquwxr`ehYtaTLoi:TV]UvjAxjMX=LqZAvZIKMlN:VcQp_?nZ@nmxfit_rBH\\Of\\OvoYwq`V`Lp]x^irawSY`EWcEOiBw_CAf<Yr=itOitg`of@ZZ@ob@ohpoHauVauPqtP`sPP^f_gfoTytqmwVIYMqfGugXeitsYxaYioUwoFH]eRYgQuGGcCGwFIme^sFasrAyrEqVaIF>?D<=SC=ENUbA]BNYXeqtgWwQygauVauv`hocHocAt[XrNIoMenu<Vf\\OfLXlMXpxWYqY]qbiquwXpn`pF>[BBF;EJAhcOhlOh=ubHcR?eRO[DN;Xs_ux`xS]pbELS@xvuwXiqtEk?xnaxNsHrW@UflukXVADONatNaUl`VC<JvpYwQu=Yr=`uJtK:\\NLDSsOxQx_YO[>NjHh]unqvGyL`[QiqtgxdIymyvmV`mFefnlghogxjAxjQxlQns?ObBF^>`dWWvS^c]@c@Vr]IxnixoifLVd]Pb<ObP_oRGpkWv@OhUQaTGb;Gj=Xj=oeXoeV_eVXkEXk\\Oj;?[[B^?Yl;YpcHS_SNayF=gCOGdKGP[GR=tkWVAQYcYKjTPmTMylYv\\yyYmWIN>@L<=wUYN=`K@`SZLNyQO:mYxmYOeTOdQ<qnXxTipUSMUTmXiquWEP;[JPdBa_=HniGyivgPodPof`ofCF[CfxX^iG>ZkF`kF@hquuxLXYuQN>@\\JedmW@STWeUGmFssDOcDCQFXork=IVDN[dpohp=mZlGylifXvkan\\EX`lN`pfgTapnGwLY[Qn_r?ir?_`N\\>@\\<?[cVcmpblqoTgpdIwMyn_hn_@ZZXoeXgf_gvOwNI_cIqGQxM?eR?]LN\\lAx[YbXvkapohps_QhAakSVvhqwHxhZibBF>od:mBmEdJKZJNdjfbnylZ^jJNBMhoyi:ihO=XXAVDiWv;B:;B:MTKWDKWgJ;eZ:::::3:\"\{\}-%+ANNOTATIONG6'-%)BOUNDS_XG6#$""!!""-%)BOUNDS_YGF'-%-BOUNDS_WIDTHG6#$"%qgF*-%.BOUNDS_HEIGHTG6#$"%SFF*-%)CHILDRENG6" The Keccak sponge construction is the special case of this algorithm based on the use of the Keccak permutations Keccak-f[b] (which play the role of the permutation f above), together with multi-rate padding, described below. As mentioned in Kreference, the design philosophy underlying the Keccak construction is the so-called hermetic sponge strategy, consisting in the use of the sponge construction for obtaining provable security against generic attacks and calling a permutation that should not have structural properties with the exception of a compact description; this philosophy is explained in detail in Csponge and, more specifically for the case of the Keccak permutations, in Kmain. There are seven Keccak permutations Keccak-f[b]: (\342\204\2442)b\342\206\222 (\342\204\2442)b, of widths b\342\210\210{25, 50, 100, 200, 400, 800, 1600}, but here we will consider only the values of b which are multiples of 8, i.e., 200, 400, 800 and 1600. The reason is that our implementation will be byte-oriented and so all the bit strings or bit lists we will handle will have length a multiple of 8. This is not a very serious restriction because the usual messages have this property and, on the other hand, the lower values of b are weak from the security point of view and, in fact, the only value used in the SHA-3 standard is b = 1600. The permutation width b can be written in the form b = 25\303\2272\356\223\201, for \356\223\201 ranging from 3 to 6. The permutation Keccak-f[b] is described in Kreference as a sequence of operations on a state a that is a three-dimensional array of elements of \342\204\2442 of the form a[5][5][w], with w = 2\356\223\201. Here, a bit string s\342\210\210(\342\204\2442)b whose bits we assume enumerated from 0 to b-1, is mapped to the state by assigning the bit s[w(5y+x)+z] to the state bit a[x][y][z], and the state bits a[x][y][0..w-1], for fixed values of x and y, constitute a lane, so that the state can be viewed as a 5\303\2275 array of lanes. We refer to Kreference for the description of Keccak-f[b], which is an iterated permutation consisting of a sequence of nr rounds, where nr = 12+2\356\223\201 and each round consists of five steps (Kreference). As described above, the permutation width b is written in the form b = c + r, where c is the capacity and r is the bit rate. The message is padded to make its length a multiple of r and the blocks of length r are successively absorbed into the state, each of these absortions being followed for an application to the state of the Keccak-f[b] permutation. Although this is not necessary, we will for simplicity assume that c (and hence also r) is a multiple of 8 and, in fact, we will require that r be a multiple of w, which is always the case for the SHA-3 hash functions included in the SHA-3 standard (see SHA-3 Standard). In the original proposal, Ksubmission, it is suggested, for security reasons, the use of c = 2n, where n is the size of the output hash and this suggestion has been followed in the NIST standard. Thus r, the number of message bits processed per block permutation, depends on the output hash size. This way the rate r is 1152, 1088, 832, 576, respectively, for 224, 256, 384 and 512-bit hash sizes when w is 64, which corresponds to b = 1600. As far as possible, we will keep these notations in our implementation. In the NIST specification in SHA-3 Standard, a more general version of the Keccak family of permutations is described and, in particular, the Keccak-f[b] permutation is equivalent to NIST's Keccak-p[b, 12+2l] so that Keccak-p[1600, 24], which underlies the six SHA-3 functions defined in the NIST standard, is equivalent to Keccak-f[1600] in the terminology of Kreference that we are using here. There are many possible choices for working with the data involved in the algorithm and, in particular, the lanes in the state might be represented by decimal integers, by hex strings, by lists of bytes or by lists (or strings) of bits. In this implementation we use integers to represent the lanes and the bitwise operations on them in the Keccak rounds are performed with the help of Maple's package Bits, with the exception of the cyclic bit rotation, for which we use the function Rot defined below. When converting between bit lists and integers, we will use the little endian convention as suggested in Kreference, so that bits will be enumerated in ascending order from the least significant to the most significant one and the number defined by the bits bi will be \316\243bi2i, and a similar convention will be adopted for byte lists.

Requirements: Maple v.14 or higher \302\251 (2015) Jos\303\251 Luis G\303\263mez Pardo, Carlos G\303\263mez-Rodr\303\255guez

We start with some auxiliary conversion functions that will be used by the Keccak algorithm but are not intended to be called directly by the user. Thus bytestohexstring converts a list of bytes (as integers in the 0..255 range) to a hex string and hexstringtobytes reverses this process. Similarly, filetobytes reads a binary file to a list of bytes and bytestofile writes a list of bytes to a file. Some of these functions are combined in messagetobytes, which on input a message given either as an ASCII text string, a hex string or a file, converts it to a list of bytes suitable to be processed by the SHA-3 functions. For speed, these functions use tables to convert between bytes given as integers and the corresponding hexadecimal strings. LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2JVEocmVzdGFydEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIjpGJy9GM1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRj0vJSlzdHJldGNoeUdGPS8lKnN5bW1ldHJpY0dGPS8lKGxhcmdlb3BHRj0vJS5tb3ZhYmxlbGltaXRzR0Y9LyUnYWNjZW50R0Y9LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGTC1JJ21zcGFjZUdGJDYmLyUnaGVpZ2h0R1EmMC4wZXhGJy8lJndpZHRoR1EmMC4wZW1GJy8lJmRlcHRoR0ZULyUqbGluZWJyZWFrR1EobmV3bGluZUYnLUZQNiZGUkZVRlgvRmVuUSVhdXRvRictRiw2I1EhRic= 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 The next function, checkkey, converts a key, given either as a text or a hex string, to a list of bytes that can be used by the HMAC function. If the string contains some non-hex character, then it is automatically regarded as an ASCII text string, otherwise it is regarded as a hex string. We have imposed a lower minimum of 128 bits for the key, so that the supplied key will be rejected if the hex string has less than 32 characters or if the text string has less than 16 characters. The maximum length will be 512 bits and if the supplied string is longer it will be truncated to this length (i.e., to 128 characters if it is a hex string and to 64 characters otherwise). Of course, all these conventions and restrictions are easy to modify and, in particular, it is possible to define a key type as hex or text according to whether we want the string to be regarded as a hex or a text string and the size limits can also be easily modified or even lifted. However, we feel that these restrictions are reasonable and make the functions easier to use. The function checkkey takes as input a key given as a string (either hex or ASCII) and, after checking that the string length is no less than 128 bits, converts it to a list of bytes (at most 64 bytes, corresponding to a 512-bit key as mentioned above); if the supplied key is too short, then it is rejected as invalid. QyQ+SSljaGVja2tleUc2ImYqNiMnSSRrZXlHRiVJJ3N0cmluZ0clKnByb3RlY3RlZEc2I0kia0dGJUYlRiVDJT44JDkkQCU0LV9JLFN0cmluZ1Rvb2xzRzYkRitJKF9zeXNsaWJHRiVJK0lzSGV4RGlnaXRHRiU2I0YwQyRAJjItX0Y2SSdMZW5ndGhHRiVGOiIjO1lRSFRoZX5zdXBwbGllZH5rZXl+aGFzfmxlc3N+dGhhbn4xMjh+Yml0c0YlMiIja0Y+PkYwLV9GNkklVGFrZUdGJTYkRjBGRT5GMC1JKGNvbnZlcnRHRis2JEYwSSZieXRlc0dGJUMkQCgyRj4iI0tZUUxUaGV+c3VwcGxpZWR+aGV4fmtleX5oYXN+bGVzc350aGFufjEyOH5iaXRzRiUyIiRHIkY+PkYwLUZINiRGMUZXLy1JJG1vZEdGJTYkRj4iIiMiIiI+RjAtSSRjYXRHRis2JFEiMEYlRjA+RjAtSTFoZXhzdHJpbmd0b2J5dGVzR0YlNiMtX0Y2SSpMb3dlckNhc2VHRiVGOkYwRiVGJUYlISIi The next function performs a cyclic bitwise shift on an integer n. The parameter l sets the integer length, i.e., the number of bits that are going to be shifted (this is necessary because an integer that is represented, say, by a list of 64 bits, may have one or several leading bits equal to 0 and the result of applying the cyclic rotation would be different if these 0 bits were not taken into account). Finally, the parameter s (where we may assume that s is less than l or, otherwise, reduce s modulo l) sets the number of positions that the bits are going to be shifted. QyQ+SSRSb3RHNiJmKjYlSSJuR0YlSSJsR0YlSSJzR0YlNiNJInRHRiVGJUYlLCYqJi1JJWlyZW1HJSpwcm90ZWN0ZWRHNiQ5JCkiIiMsJjklIiIiOSYhIiJGOClGNUY5RjhGOC1JJWlxdW9HRjFGMkY4RiVGJUYlRjo= We will use the following function to convert a lane, given as a list of bytes, to a w-bit integer, note that for this conversion we use the little-endian convention. QyQ+SStieXRlc3RvaW50RzYiZio2I0kmYnl0ZXNHRiU2I0kibEdGJUYlRiVDJD44JC1JJW5vcHNHJSpwcm90ZWN0ZWRHNiM5JC1JJGFkZEdGMDYkKiYmRjI2I0kiaUdGJSIiIikiJGMjLCZGOUY6ISIiRjpGOi9GOTtGOkYtRiVGJUYlRj4= Finally, a function to convert a decimal integer x to base b, where the base-b representation is the list of digits in little-endian order, and l is a parameter that specifies the length of this list, so that if the integer has less than l digits in base b, the list of digits given by the function is completed with zeros on the right up to the required length (we will always assume that this length is greater than or equal to the bit-length of x). QyQ+SStkZWNpbWFsdG9iRzYiZio2JSdJInhHRiVJKm5vbm5lZ2ludEclKnByb3RlY3RlZEdJImJHRiVJImxHRiU2I0kieUdGJUYlRiVDJD44JC1JKGNvbnZlcnRHRis2JTkkSSViYXNlR0YlOSU3JC1JI29wR0YrNiNGMi1JIiRHRis2JCIiISwmOSYiIiItSSVub3BzR0YrRjwhIiJGJUYlRiVGRg==

We start the implementation of the Keccak sponge function by giving the Round Constants, which are used in the \316\271 (iota) step of each round of Keccak-f[b]. The 24 constants are initialized as hex strings in a one-dimensional array: PkkmUkNoZXhHNiItSSZBcnJheUclKnByb3RlY3RlZEc2JDsiIiEiI0I3OlExMDAwMDAwMDAwMDAwMDAwMUYkUTEwMDAwMDAwMDAwMDA4MDgyRiRRMTgwMDAwMDAwMDAwMDgwOGFGJFExODAwMDAwMDA4MDAwODAwMEYkUTEwMDAwMDAwMDAwMDA4MDhiRiRRMTAwMDAwMDAwODAwMDAwMDFGJFExODAwMDAwMDA4MDAwODA4MUYkUTE4MDAwMDAwMDAwMDA4MDA5RiRRMTAwMDAwMDAwMDAwMDAwOGFGJFExMDAwMDAwMDAwMDAwMDA4OEYkUTEwMDAwMDAwMDgwMDA4MDA5RiRRMTAwMDAwMDAwODAwMDAwMGFGJFExMDAwMDAwMDA4MDAwODA4YkYkUTE4MDAwMDAwMDAwMDAwMDhiRiRRMTgwMDAwMDAwMDAwMDgwODlGJFExODAwMDAwMDAwMDAwODAwM0YkUTE4MDAwMDAwMDAwMDA4MDAyRiRRMTgwMDAwMDAwMDAwMDAwODBGJFExMDAwMDAwMDAwMDAwODAwYUYkUTE4MDAwMDAwMDgwMDAwMDBhRiRGM1ExODAwMDAwMDAwMDAwODA4MEYkRjJRMTgwMDAwMDAwODAwMDgwMDhGJA== We now convert each round constant to an integer that will be XORed with the first lane of the state in the \316\271 step. For this, according to the little endian convention we have mentioned, the bytes in each constant are reversed before converting them to an integer. Later, in the absortion phase, these integers will be automatically truncated to lane size w whenever w < 64, which happens when b < 1600 in order to XOR them with other lanes; this truncation will be forced by the use of Bits:-Settings(defaultbits = w) in the function keccak below. QyQ+SSZSQ2ludEc2Ii0mSSJ8aXJHJSpwcm90ZWN0ZWRHNiNJK2J5dGVzdG9pbnRHRiU2Iy0mRig2I19JKkxpc3RUb29sc0dGJUkoUmV2ZXJzZUdGJTYjLSZGKDYjSTFoZXhzdHJpbmd0b2J5dGVzR0YlNiNJJlJDaGV4R0YlIiIi Next, we set up the cyclic shift offsets that are used in the \317\201 and \317\200 steps of each round of Keccak-f[b]. The offsets are the elements of the following two-dimensional array: QyQ+SSNyb0c2Ii1JJkFycmF5RyUqcHJvdGVjdGVkRzYlOyIiISIiJUYqNyc3J0YrIiNPIiIkIiNUIiM9NyciIiIiI1ciIzUiI1giIiM3JyIjaSIiJyIjViIjOiIjaDcnIiNHIiNiIiNEIiNAIiNjNyciI0YiIz8iI1IiIikiIzlGNA== The next step is to build the round function, for which se shall assume that the lanes are given as integers. The bitwise operations on these integers required by the Keccak permutation are then performed using the Maple package Bits (plus the function Rot we defined before to perform the cyclic shift) and it is important to notice that, for these operations to work properly, it is necessary to set the parameter defaultbits of the Bits package to the lane length w which, as mentioned, is done in the function keccak below. Note that Maple's convention is to number the list elements starting from 1 (instead of the numbering starting from 0 used in the Keccak reference) but this does not cause any trouble. The bitwise cyclic shifts used in the \317\201 and \317\200 steps are right shifts according to the little endian convention (bits are shifted from less to more significant) but sometimes they are called "left shifts" because the big endian convention is assumed. The cyclic right shift of size s is obtained with Rot. We remark that the Maple code for this function is an almost word-for-word rendition of the pseudocode given in Kimplementation. The inputs of the Round function are the state A, the permutation width b, and the round number rn. The output is the modified state. QyQ+SSZSb3VuZEc2ImYqNiUnSSJBR0YlSSZBcnJheUclKnByb3RlY3RlZEcnSSJiR0YlSSdwb3NpbnRHRisnSSNybkdGJUkqbm9ubmVnaW50R0YrNilJIndHRiVJI3diR0YlSSJCR0YlSSJDR0YlSSJER0YlSSJ4R0YlSSJ5R0YlRiVGJUMtPjgkLUklaXF1b0dGKzYkOSUiI0Q+OCYtRio2JTsiIiEiIiVGRi9JJWZpbGxHRiVGRz44Jy1GKjYkRkZGST44KEZNPyg4KUZHIiIiRkhJJXRydWVHRis+JkZMNiNGUi1fSSVCaXRzR0koX3N5c2xpYkdGJUkkWG9yR0YrNiQtRlk2JC1GWTYkLUZZNiQmOSQ2JEZSRkcmRl9vNiRGUkZTJkZfbzYkRlIiIiMmRl9vNiRGUiIiJCZGX282JEZSRkg/KEZSRkdGU0ZIRlQ+JkZQRlctRlk2JCZGTDYjLUkkbW9kR0YlNiQsJkZSRlMhIiJGUyIiJi1JJFJvdEdGJTYlJkZMNiMtRmNwNiQsJkZSRlNGU0ZTRmdwRjxGUz8oRlJGR0ZTRkhGVD8oOCpGR0ZTRkhGVD4mRl9vNiRGUkZicS1GWTYkRmRxRl1wPyhGUkZHRlNGSEZUPyhGYnFGR0ZTRkhGVD4mRkM2JEZicS1GY3A2JCwmRlJGZW9GYnFGaG9GZ3AtRmlwNiVGZHFGPC1GY3A2JCZJI3JvR0YlRmVxRjw/KEZSRkdGU0ZIRlQ/KEZicUZHRlNGSEZUPkZkcS1GWTYkJkZDRmVxLV9GWkkkQW5kR0YrNiQtX0ZaSSROb3RHRis2IyZGQzYkRl1xRmJxJkZDNiQtRmNwNiQsJkZSRlNGZW9GU0ZncEZicT4mRl9vNiRGR0ZHLUZZNiRGXHQmSSZSQ2ludEdGJTYjOSZGX29GJUYlRiVGZnA= The next step is to build the Keccak-f[b] permutation, which consists simply in applying the successive round functions to the state. The inputs are a state A and the permutation width b; the output is the modified state. QyQ+SShLZWNjYWtmRzYiZio2JCdJIkFHRiVJJkFycmF5RyUqcHJvdGVjdGVkRydJImJHRiVJJ3Bvc2ludEdGKzYnSSJ3R0YlSSJsR0YlSSNuckdGJUkiaUdGJUkiU0dGJUYlRiVDKD44JC1JJWlxdW9HRis2JDklIiNEPjglLSZJJWlsb2dHRiU2IyIiIzYjRjc+OCYsJiIjNyIiIkY+RkM+OCg5JD8oOCciIiFGSSwmRkZGSSEiIkZJSSV0cnVlR0YrPkZLLUkmUm91bmRHRiU2JUZLRjtGTkZLRiVGJUYlRlE= Keccak uses multi-rate padding, an algorithm that pads the message given as a bit list by appending a single bit 1 followed by the minimum number of bits 0 followed by a single bit 1 such that the resulting length is a multiple of the bit rate r (see Kreference). The next function implements this algorithm but adds two variants: for the SHA-3 hash functions the application of multi-rate padding is preceded by appending first the bits "01" to the message bit list and for the SHA-3 XOF's, the four bits "1111" are appended first. Having the full message given as a list of bits is not convenient if the message is long and hence we will consider the message as a list of bytes (which is not restrictive in this context, given the byte-oriented approach mentioned before). These blocks will later be divided into lanes and these lanes converted to integers in the Keccak function below, just before their absortion into the state. The inputs of the padding function are the message given as a list of bytes (i.e., a list of integers in the 0..255 range), the bit rate r and domain, which can take the values 'hash' 'xof' or 'kec' to apply different paddings and implement domain separation by distinguishing the inputs corresponding to the SHA-3 hash functions from these corresponding to the SHA-3 XOFs, with the value 'kec' corresponding to the Keccak function itself. The output is an array containing the padded message blocks, each of which is given as a list of bytes. QyQ+SSRwYWRHNiJmKjYlJ0kobWVzc2FnZUdGJUklbGlzdEclKnByb3RlY3RlZEcnSSJyR0YlSSdwb3NpbnRHRisnSSdkb21haW5HRiUtSSppZGVudGljYWxHRis2JUklaGFzaEdGJUkkeG9mR0YlSSRrZWNHRiU2KEkkcmJ5R0YlSSZudW1ieUdGJUkkYWJ5R0YlSSdibG9ja3NHRiVJKmxhc3RibG9ja0dGJUklbGFzdEdGJUYlRiVDKT44JC1JJWlxdW9HRis2JDklIiIpPjglLUklbm9wc0dGKzYjOSQ+OCYtSSVpcmVtR0YrNiRGR0ZAPjgnNyMtX0kqTGlzdFRvb2xzRzYkRitJKF9zeXNsaWJHRiVJLExlbmd0aFNwbGl0R0YlNiRGS0ZAPkZSLUkmQXJyYXlHRis2JDsiIiItRkk2I0ZSZio2I0kiaUdGJUYlNiRJKW9wZXJhdG9yR0YlSSZhcnJvd0dGJUYlJlQjRkpGJUYlNiRGO0ZSQCcvRk0iIiFDJEAnLzkmRjQ+OCg3JSIiJy1JIiRHRis2JEZobywmRkBGam4hIiNGam4iJEciL0ZccEY1PkZecDclIiNKRmFwRmZwPkZecDclRmpuRmFwRmZwQCUvRkdGaG8+RlItRmduNiQ7RmpuRmpuL0klZmlsbEdGJUZecD5GUi1fSStBcnJheVRvb2xzR0ZXSSxDb25jYXRlbmF0ZUdGJTYlIiIjRlJGYHEvRk0sJkZARmpuISIiRmpuQCdGW3A+JkZSNiNGXnI3JC1JI29wR0YrNiNGYXIiJE0iRmdwPkZhcjckRmRyIiRmIj5GYXI3JEZkciIkSCJAJ0ZbcD5GYXI3JkZkckZgcC1GYnA2JEZobywoRkBGam5GTUZeckZlcEZqbkZmcEZncD5GYXI3JkZkckZqcEZhc0ZmcD5GYXI3JkZkckZqbkZhc0ZmcEZSRiVGJUYlRl5y Next we give the function that absorbs one block into the state. For this we use Maple's function ArrayTools:-Copy, which copies a one-dimensional array containing a Keccak block into the zero state. The entries of the block are copied to the state in Fortran order, which Maple uses by default, and this corresponds exactly to the mapping defined in Kreference, so that we don't need to make the mapping function explicit (note, however, that if we represent the 5x5 state array as a matrix, the x-coordinate serves to enumerate rows and the y-coordinate to enumerate columns, in contrast with the graphical picture given in [Kreference, p. 11], where the x-coordinates belong to the horizontal axis and the y-coordinates to the vertical one. Independently of this pictorial representation, the indices of the block are mapped to those of the state in the following order: (0, 0), (1,0), (2,0), (3,0), (4, 0), (0,1), (2,1), ..., which is precisely Fortran_order). The function inputs are the state array, the block given as a list of bytes, the bit rate r and the permutation width b. The output is the modified state. QyQ+SSxBYnNvcmJCbG9ja0c2ImYqNiZJIlNHRiVJKmJsb2NrbGlzdEdGJUkiYkdGJUkickdGJTYlSSJCR0YlSSJ3R0YlSSJUR0YlRiVGJUMoPjgkOSQ+OCUtSSVpcXVvRyUqcHJvdGVjdGVkRzYkOSYiJCsjPjgmLUkmQXJyYXlHRjg2JTsiIiEiIiVGQS9JJWZpbGxHRiVGQi1fSStBcnJheVRvb2xzRzYkRjhJKF9zeXNsaWJHRiVJJUNvcHlHRiU2JC1GPzYjLSZJInxpckdGODYjSStieXRlc3RvaW50R0YlNiM3Iy1fSSpMaXN0VG9vbHNHRklJLExlbmd0aFNwbGl0R0YlNiQ5JUY1Rj0+RjItJkZRNiNfSSVCaXRzR0ZKSSRYb3JHRjg2JEYyRj0+RjItSShLZWNjYWtmR0YlNiRGMkY6RiVGJUYlISIi The following is a different version of the absorbing function which is functionally equivalent to the previous one but does not employ the resources of Maple's ArrayTools package and is closer in spirit to the description in Kimplementation. To force the function keccak below to use it instead of the previous function it suffices to drop the 2 at the end of the name and to rename it to AbsorbBlock. QyQ+SS1BYnNvcmJCbG9jazJHNiJmKjYmSSJTR0YlSSpibG9ja2xpc3RHRiVJImJHRiVJInJHRiU2KUkiQkdGJUkid0dGJUkiekdGJUkibUdGJUkibkdGJUkieEdGJUkieUdGJUYlRiVDKj44JDkkPjglLUklaXF1b0clKnByb3RlY3RlZEc2JDkmIiQrIz44Ji1GOzYkLUY7NiQ5JyIiKUY5PjgnLUY7NiRGQSIiJj44KC1JJWlyZW1HRjxGSz8oOCkiIiEiIiIiIiVJJXRydWVHRjw/KDgqRlNGVCwmRklGVCEiIkZURlY+JkY2NiRGUkZYLV9JJUJpdHNHSShfc3lzbGliR0YlSSRYb3JHRjw2JEZmbi1JK2J5dGVzdG9pbnRHRiU2IyY5JTYjOywmKiZGOUZULCZGWEZMRlJGVEZURlRGVEZUKiZGOUZULChGWEZMRlJGVEZURlRGVD8oRlJGU0ZULCZGTkZURlpGVEZWPiZGNjYkRlJGSS1GaW42JEZdcC1GX282IyZGYm82IzssJiomRjlGVCwmRklGTEZSRlRGVEZURlRGVComRjlGVCwoRklGTEZSRlRGVEZURlQ+RjYtSShLZWNjYWtmR0YlNiRGNkY+RiVGJUYlRlo= Next we give the squeezing function, which extracts the bits from the state after processing them with the Keccak permutation. The inputs are the state array, the Keccak width, the bit rate and the required output length in bits. The output is a list of bytes corresponding to the required length. QyQ+SShTcXVlZXplRzYiZio2JkkiU0dGJUkiYkdGJUkickdGJUkibkdGJTYpSSJ3R0YlSSJ6R0YlSSJCR0YlSSJsR0YlSSJtR0YlSSJaR0YlSSJoR0YlRiVGJUMoPjgkLUklaXF1b0clKnByb3RlY3RlZEc2JDklIiNEPjgmOSQ+OCcmLUkoY29udmVydEdGOTYkRj5JJWxpc3RHRjk2IzsiIiItRjg2JDkmRjY/KEYlRklGSUYlMi1JJW5vcHNHRjk2I0ZBKiY5J0ZJRjYhIiJDJD5GPi1JKEtlY2Nha2ZHRiU2JEY+Rjs+RkE3JC1JI29wR0Y5RlEmLUZnbjYjRkNGRz5GQS1fSSpMaXN0VG9vbHNHNiRGOUkoX3N5c2xpYkdGJUkoRmxhdHRlbkdGJTYjLSZJInxpckdGOTYjSStkZWNpbWFsdG9iR0YlNiVGQSIkYyMtRjg2JEY2IiIpJkZBNiM7RkktRjg2JEZTRlxwRiVGJUYlRlQ= Now we combine the previous functions to obtain a version of Keccak that acts on messages given as lists of bytes and produces its output also in this format. This function is used below to construct the Keccak sponge function and the SHA-3 functions, as well as the SHA-3 based HMAC. As mentioned above, all of the numeric parameters b, r, n, are required to be multiples of 8 as a consequence of the byte-oriented character of the implementation. In fact, we will require that the bit rate r is a multiple of the lane width w since this simplifies the implementation somewhat and is not too restrictive in practice (for example, all the values for b, r and n used in the SHA-3 functions, and hence on HMAC based on these functions, comply with this requisite). Here the command LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYnLUkjbWlHRiQ2JlElQml0c0YnLyUnZmFtaWx5R1EsQ291cmllcn5OZXdGJy8lJ2l0YWxpY0dRJmZhbHNlRicvJSxtYXRodmFyaWFudEdRJ25vcm1hbEYnLUkjbW9HRiQ2LlEjOi1GJ0YvRjUvJSZmZW5jZUdGNC8lKnNlcGFyYXRvckdGNC8lKXN0cmV0Y2h5R0Y0LyUqc3ltbWV0cmljR0Y0LyUobGFyZ2VvcEdGNC8lLm1vdmFibGVsaW1pdHNHRjQvJSdhY2NlbnRHRjQvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZMLUYsNiZRKVNldHRpbmdzRidGL0YyRjUtSShtZmVuY2VkR0YkNiUtRiM2KC1GLDYmUSxkZWZhdWx0Yml0c0YnRi9GMkY1LUY5Ni5RIn5GJ0YvRjVGPEY+RkBGQkZERkZGSEZKRk0tRjk2LlEiPUYnRi9GNUY8Rj5GQEZCRkRGRkZIL0ZLUSwwLjI3Nzc3NzhlbUYnL0ZORltvRlotRiw2JlEid0YnRi9GMkY1RjVGL0Y1RjU= plays an important role because it forces all bitwise operations with the integers representing w-bit lanes to be performed with w-bit width and, in particular, if the lanes are shorter than 64 bytes (as it happens whenever b < 1600), the XOR operation with the 64-bit round constants defined above is performed over the first w bits, which is equivalent to the truncation of these constants before XORing them and makes it unnecessary to perform this truncation explicitly. The function proceeds as in the pseudocode given in [Kimplementation, p. 9]. First, padding is performed with the previous function pad and then the state is initialized. The next step is the absorbing phase which is performed for each block by the function AbsorbBlock and, finally, the squeezing phase produces the requested output by means of the function Squeeze. The inputs of the function are the message in one of the three valid formats, the permutation width b, the bit rate r, the output length n and, finally, domain, which is used to select the type of padding that will be applied and will take the values 'hash' for the SHA-3 hash functions, 'xof' for the SHAKE functions and 'kec' for Keccak. The output is a list of bytes which will be converted in the function Keccak below to a hex string to obtain the message digest. QyQ+SSdrZWNjYWtHNiJmKjYnSShtZXNzYWdlR0YlSSJiR0YlSSJyR0YlSSJuR0YlSSdkb21haW5HRiU2KEkibUdGJUkid0dGJUkiU0dGJUkjbmJHRiVJImlHRiVJIlBHRiVGJUYlQyxAJDQtSSNpbkclKnByb3RlY3RlZEc2JDklNyYiJCsjIiQrJSIkKykiJSs7WTYkUTxiLXZhbHVlfm9mfiUxfm5vdH5zdXBwb3J0ZWRGJUY7QCQ0Ly1JJG1vZEdGJTYkOSciIikiIiFZNiRRU3RoZX5vdXRwdXR+bGVuZ3Rofm5+PX4lMX5zaG91bGR+YmV+YX5tdWx0aXBsZX5vZn44RiVGSj44JS1JJWlxdW9HRjk2JEY7IiNEQCQwLUZINiQ5JkZRRkxZNiRRTnRoZX5iaXR+cmF0ZX5yfnNob3VsZH5iZX5hfm11bHRpcGxlfm9mfnd+PX4lMUYlRlEtX0klQml0c0dJKF9zeXNsaWJHRiVJKVNldHRpbmdzR0YlNiMvSSxkZWZhdWx0Yml0c0dGJUZRPjgkLUkkcGFkR0YlNiU5JEZaOSg+OCYtSSZBcnJheUdGOTYlO0ZMIiIlRlxwZio2JEYySSJqR0YlRiU2JEkpb3BlcmF0b3JHRiVJJmFycm93R0YlRiVGTEYlRiVGJT44Jy1fSStBcnJheVRvb2xzRzYkRjlGW29JKU51bUVsZW1zR0YlNiNGYW8/KDgoIiIiRl5xRmVwSSV0cnVlR0Y5PkZoby1JLEFic29yYkJsb2NrR0YlNiZGaG8mRmFvNiNGXXFGO0ZaLUkoU3F1ZWV6ZUdGJTYmRmhvRjtGWkZKRiVGJUYlISIi Finally, we give the Keccak (sponge) function for ordinary messages. The input parameters are message, for a message given either as a text string, a file name (including the full path if the file is not in the current working directory) or a hex string, b for the Keccak width, r for the bit rate, n for the desired output length in bits (all of them satisfying the requirements stated above) and, finally, a name (hex, text or file) to indicate which kind of message is being processed (with text being the default). The default values for the width and the bit rate are those suggested in Ksubmission. As mentioned in Csponge the resulting capacity value of 576 precludes generic attacks with expected complexity below LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUklbXN1cEdGJDYlLUkjbW5HRiQ2JFEiMkYnLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGJy1GIzYnLUYvNiRRJDI4OEYnRjIvJSdpdGFsaWNHUSV0cnVlRicvJStmb3JlZ3JvdW5kR1EsWzIwMCwwLDIwMF1GJy8lLHBsYWNlaG9sZGVyR0Y8L0YzUSdpdGFsaWNGJy8lMXN1cGVyc2NyaXB0c2hpZnRHUSIwRictSSNtb0dGJDYtUSIuRidGMi8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGTS8lKXN0cmV0Y2h5R0ZNLyUqc3ltbWV0cmljR0ZNLyUobGFyZ2VvcEdGTS8lLm1vdmFibGVsaW1pdHNHRk0vJSdhY2NlbnRHRk0vJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0Zmbi1GSDYtUSJ+RidGMkZLRk5GUEZSRlRGVkZYRlpGZ25GMg==The output is the message digest given as a hex string. QyQ+SSdLZWNjYWtHNiJ0KzYnJ0kobWVzc2FnZUdGJUknc3RyaW5nRyUqcHJvdGVjdGVkRz4nSSJiR0YlSSdwb3NpbnRHRisiJSs7PidJInJHRiVGLyIlQzU+J0kibkdGJUYvRjQ+J0ksbWVzc2FnZXR5cGVHRiVJJW5hbWVHRitJJXRleHRHRiU2JEkibUdGJUkibEdGJUYlRiVDJT44JC1JL21lc3NhZ2V0b2J5dGVzR0YlNiQ5JDkoPjglLUkna2VjY2FrR0YlNidGQjklOSY5J0kka2VjR0YlLUkxYnl0ZXN0b2hleHN0cmluZ0dGJTYjRklGJUYlRiU2IyIiJiEiIg==

The process of SHA-3 standardization by NIST was completed in August 2015 and includes four hash functions with output lengths of 224, 256, 384 and 512 bits. In all these cases, the width is 1600 (i.e., the underlying permutation is Keccak-f[1600]) and the capacity is twice the output length. The capacity works as a security parameter, so that security is increased with higher capacities, but there is a security-efficiency trade-off and speed may be increased by using lower capacities (see KParameters). The function SHA3 below is an implementation of the four hash functions in the SHA-3 standard. It is an indexed function which should be called in the form: SHA3[n](message) where n is the output length in bits (which must be one of the following values: 224, 256, 384, 512), message is the message and there is an additional (optional) input parameter to specify the type of message (text, hex or file) with text the default. QyQ+SSVTSEEzRzYidCs2JCdJKG1lc3NhZ2VHRiVJJ3N0cmluZ0clKnByb3RlY3RlZEc+J0ksbWVzc2FnZXR5cGVHRiVJJW5hbWVHRitJJXRleHRHRiU2JUkibkdGJUkibUdGJUkibEdGJUYlRiVDJ0AlLUkldHlwZUdGKzYkOSEuSShpbmRleGVkR0YrPjgkLUkjb3BHRis2I0Y6WVE8b3V0cHV0fmxlbmd0aH5ub3R+c3BlY2lmaWVkRiVAJDQtSSNpbkdGKzYkRj48JiIkQyMiJGMjIiQlUSIkNyZZNiRRQCUxfmlzfm5vdH5hfnZhbGlkfm91dHB1dH5sZW5ndGhGJUY+PjglLUkvbWVzc2FnZXRvYnl0ZXNHRiU2JDkkOSU+OCYtSSdrZWNjYWtHRiU2J0ZSIiUrOywmRmduIiIiRj4hIiNGPkklaGFzaEdGJS1JMWJ5dGVzdG9oZXhzdHJpbmdHRiU2I0ZZRiVGJUYlNiMiIiMhIiI= The next procedure implements the XOFs SHAKE128 and SHAKE256. These functions should be called in the form: SHAKE[n](message, d) where n is now the "security strength" of the function which must be either 128 or 256, while d represents the bit-length of the output, which should be a multiple of 8. QyQ+SSZTSEFLRUc2InQrNiUnSShtZXNzYWdlR0YlSSdzdHJpbmdHJSpwcm90ZWN0ZWRHJ0kiZEdGJUkoaW50ZWdlckdGKz4nSSxtZXNzYWdldHlwZUdGJUklbmFtZUdGK0kldGV4dEdGJTYlSSJuR0YlSSJtR0YlSSJsR0YlRiVGJUMnQCUtSSV0eXBlR0YrNiQ5IS5JKGluZGV4ZWRHRis+OCQtSSNvcEdGKzYjRj1ZUTxvdXRwdXR+bGVuZ3Rofm5vdH5zcGVjaWZpZWRGJUAkNC1JI2luR0YrNiRGQTwkIiRHIiIkYyNZNiRRTiUxfmlzfm5vdH5hfnZhbGlkfnNlY3VyaXR5fnN0cmVuZ3RofnBhcmFtZXRlckYlRkE+OCUtSS9tZXNzYWdldG9ieXRlc0dGJTYkOSQ5Jj44Ji1JJ2tlY2Nha0dGJTYnRlMiJSs7LCZGaG4iIiJGQSEiIzklSSR4b2ZHRiUtSTFieXRlc3RvaGV4c3RyaW5nR0YlNiNGWkYlRiVGJTYjIiIkISIi

One of the most important applications of hash functions is to the construction of MACs (Message Authentication Codes). MACs are cryptographic schemes designed to prevent an adversary from impersonating a legitimate user and from modifying a message without the legitimate users noticing it. For this purpose, two users share a secret key k and when one of them wants to send a message m to the other, she uses a tag generation algorithm that computes a MAC tag t using m and k as inputs and sends the pair (m,t) to the receiver. The receiver verifies that t is a valid tag for m by running a verification algorithm that, on input m, k and t, checks whether t is a valid tag for m (this is done by computing the tag from m and k and checking whether it is equal to the received tag). If the message has been modified by an adversary, this will be noticed by the receiver because the adversary, not knowing the secret key, will be unable to compute a valid tag for the message if the MAC is secure (see, for example, [G\303\263mez Pardo] for the precise definition of security for MACs). Thus a secure MAC gives the receiver assurance that the message has not been modified (thus providing message integrity) and also that the message is authentic (for only the legitimate user in possession of k should be able to generate a valid tag for m). One of the basic ideas to obtain a MAC from a cryptographic hash function consists in computing the message tag by hashing the key together with the messages. There are several concrete ways of doing this and the most popular one gives rise to HMAC (Hash-based MAC, introduced in [Bellare-Canetti-Krawczyk]) which, using a hash function H, combines the message with the key and some padding and computes the tag t = HMAC(k,m) = H((k\342\212\225opad)\342\210\245H((k\342\212\225ipad)\342\210\245m)), where \342\212\225 denotes the bitwise XOR, \342\210\245 denotes concatenation of strings, ipad is a string of bytes 0x36, and opad a string of bytes 0x5c, both of length equal to the block size B, a parameter associated to the scheme (we omit here some details and refer to the HMAC papers page, or to [G\303\263mez Pardo, Algorithm 5.4], or also to the Wikipedia HMAC page for a more detailed description). HMAC is used in both the Transport Layer Security (TLS) protocol used by web browsers for secure connections, as well as in the IPSec security suite. It is regarded as a secure scheme although its practical security in some settings has been questioned in [Koblitz-Menezes]. Although HMAC-SHA-3 has not been standardized and the Keccak authors mention in their web page that "Unlike SHA-1 and SHA-2, Keccak does not have the length-extension weakness, hence does not need the HMAC nested construction. Instead, MAC computation can be performed by simply prepending the message with the key" , we give here a SHA-3-based implementation of HMAC (see, for example, SHA3-based MACs) which uses any one of the four SHA-3 hash functions defined above.The parameters B (input block length in bytes) and L (output size in bytes) are computed in the following table (see FIPS-198-1 for a detailed description of the NIST HMAC standard or also [G\303\263mez Pardo, Section 5.6.5]). In this case, following the recommendation in [Ksubmission, 5.1.3, p. 9], B is equal to the byte rate and L the output length of the hash function in bytes, which is one of the following values: 28, 32, 48 or 64. The table is indexed by the four output bit lengths and the entry corresponding to each of these lengths is an array containing the values of B and L (in this order) associated to it. QyQ+SSNIVEc2Ii1JJnRhYmxlRyUqcHJvdGVjdGVkRzYjLUkkbWFwR0YoNiRmKjYjSSJ4R0YlRiU2JEkpb3BlcmF0b3JHRiVJJmFycm93R0YlRiUvOSQtSSZBcnJheUdGKDYkOyIiIiIiIzckLCYiJCsjRjlGNCMhIiIiIiUsJEY0I0Y5IiIpRiVGJUYlNyYiJEMjIiRjIyIkJVEiJDcmRjk= The next function, HMAC3, computes the SHA-3-based HMAC tag for a message. Like the function SHA3, HMAC3 is an indexed function which is called in the form: HMAC3[n](key, message) where n is the output length in bytes and must be equal to one of the following: 224, 256, 384, 512. The key, given either as a text or a hex string, is processed with the function checkkey above and hence it must have a minimum bit length of 128 (this seems a basic security requirement and, in fact, in HMAC it is advisable to use a key length greater than or equal to the output length). However, if desired it is easy to modify the function to allow for the use of smaller keys (for example, for testing purposes). There is no maximum length for the key but keys longer than 512 bits will be truncated to this length by checkkey (a key length greater than 512 would not significantly improve security and would, on the other hand, have obvious practical disadvantages since keys have to be shared through secure channels and stored safely). The message can be an ASCII string, a hex string or a file, with the type specified through the optional parameter messagetype, which has text as default. QyQ+SSZITUFDM0c2InQrNiUnSSRrZXlHRiVJJ3N0cmluZ0clKnByb3RlY3RlZEcnSShtZXNzYWdlR0YlRio+J0ksbWVzc2FnZXR5cGVHRiVJJW5hbWVHRitJJXRleHRHRiU2KkkibkdGJUkiQkdGJUkiTEdGJUkickdGJUkibUdGJUkia0dGJUklaXBhZEdGJUklb3BhZEdGJUYlRiVDLkAlLUkldHlwZUdGKzYkOSEuSShpbmRleGVkR0YrPjgkLUkjb3BHRis2I0ZBWVE8b3V0cHV0fmxlbmd0aH5ub3R+c3BlY2lmaWVkRiVAJDQtSSNpbkdGKzYkRkU8JiIkQyMiJGMjIiQlUSIkNyZZNiRRQCUxfmlzfm5vdH5hfnZhbGlkfm91dHB1dH5sZW5ndGhGJUZFPjglJiZJI0hUR0YlNiNGRTYjIiIiPjgmJkZlbjYjIiIjPjgnLCRGWSIiKT44KC1JL21lc3NhZ2V0b2J5dGVzR0YlNiQ5JTkmPjgpLUkpY2hlY2trZXlHRiU2IzkkPkZbcDckLUZHNiNGW3AtSSIkR0YrNiQiIiEsJkZZRmluLUklbm9wc0dGK0ZjcCEiIj44KjcjLUZlcDYkIiNhRlk+OCs3Iy1GZXA2JCIjIypGWT5GZG8tSSdrZWNjYWtHRiU2JzckLUZHNiMtJkkifGlyR0YrNiNfSSVCaXRzR0koX3N5c2xpYkdGJUkkWG9yR0YrNiRGW3BGXXEtRkc2I0ZkbyIlKztGYG9GRUklaGFzaEdGJS1JMWJ5dGVzdG9oZXhzdHJpbmdHRiU2Iy1GanE2JzckLUZHNiMtRmByNiRGW3BGY3FGaHJGanJGYG9GRUZbc0YlRiVGJTYjIiIkRltx

Here we include some Known Answer Tests taken from Keccak Code Package Test Vectors and KATests. Note, however, that the tests in the latter reference have not been updated and hence give different results for SHA-3 and SHAKE because they do not take into account the new padding method introduced by NIST. We start with a few short hex messages. Qy4+SSRzbTBHNiJRIUYlISIiPkklc20xNkdGJVElNDFGQkYlRic+SSVzbTY0R0YlUTE0QTRGMjAyNDg0NTEyNTI2RiVGJz5JJnNtMzIwR0YlUVtwN0FCQUExMkVDMkE3MzQ3Njc0RTQ0NDE0MEFFMEZCNjU5RDA4RTFDNjZERUNEOEQ2RUFFOTI1RkE0NTFENjVGM0MwMzA4RTI5NDQ2QjhFRDNGJUYnPkkmc204MDBHRiVRY3c0MzNDNTMwMzEzMTYyNEMwMDIxRDg2OEEzMDgyNTQ3NUU4RDBCRDMwNTJBMDIyMTgwMzk4RjRDQTQ0MjNCOTgyMTRCNkJFQUFDMjFDODgwN0EyQzMzRjhDOTNCRDQyQjA5MkNDMUIwNkNFREYzMjI0RDVFRDFFQzI5Nzg0NDQ0RjIyRTA4QTU1QUE1ODU0MkI1MjRCMDJDRDNENUQ1RjY5MDdBRkU3MUM1RDc0NjIyMjRBM0Y5RDlFNTNFN0UwODQ2RENCQjRDRUYlRic+SSdzbTIwNDBHRiVRaWpsM0EzQTgxOUM0OEVGREUyQUQ5MTRGQkYwMEUxOEFCNkJDNEYxNDUxM0FCMjdEMEMxNzhBMTg4QjYxNDMxRTdGNTYyM0NCNjZCMjMzNDY3NzVEMzg2QjUwRTk4MkM0OTNBREJCRkM1NEI5QTNDRDM4MzM4MjMzNkExQTBCMjE1MEExNTM1OEYzMzZEMDNBRTE4RjY2NkM3NTczRDU1QzRGRDE4MUMyOUU2Q0NGREU2M0VBMzVGMEFERjU4ODVDRkMwQTNEODRBMkIyRTRERDI0NDk2REI3ODlFNjYzMTcwQ0VGNzQ3OThBQTFCQkNENDU3NEVBMEJCQTQwNDg5RDc2NEIyRjgzQUFEQzY2QjE0OEI0QTBDRDk1MjQ2QzEyN0Q1ODcxQzRGMTE0MTg2OTBBNURERjAxMjQ2QTBDODBBNDNDNzAwODhCNjE4MzYzOURDRkRBNDEyNUJEMTEzQThGNDlFRTIzRUQzMDZGQUFDNTc2QzNGQjBDMUUyNTY2NzFEODE3RkMyNTM0QTUyRjVCNDM5RjcyRTQyNERFMzc2RjRDNTY1Q0NBODIzMDdERDlFRjc2REE1QjdDNEVCN0UwODUxNzJFMzI4ODA3QzAyRDAxMUZGQkYzMzc4NTM3OEQ3OURDMjY2RjZBNUJFNkJCMEU0QTkyRUNFRUJBRUIxRiVGJw== Here, we use the Keccak function with b = 200, r =40 and c = n = 160. In this case the output length is higher than the bit rate, so that the squeezing phase requires more than one application of the Keccak permutation: QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjSSdLZWNjYWtHNiI2JzcoSSRzbTBHRilJJXNtMTZHRilJJXNtNjRHRilJJnNtMzIwR0YpSSZzbTgwMEdGKUknc20yMDQwR0YpIiQrIyIjUyIkZyJJJGhleEdGKSIiIg== Next, with different parameters: QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjSSdLZWNjYWtHNiI2JzcoSSRzbTBHRilJJXNtMTZHRilJJXNtNjRHRilJJnNtMzIwR0YpSSZzbTgwMEdGKUknc20yMDQwR0YpIiQrKSIkNyZGM0kkaGV4R0YpIiIi Let us now compute the hashes of the preceding messages with the four SHA-3 functions: QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiRDIzYkNyhJJHNtMEdGKkklc20xNkdGKkklc202NEdGKkkmc20zMjBHRipJJnNtODAwR0YqSSdzbTIwNDBHRipJJGhleEdGKiIiIg== QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiRjIzYkNyhJJHNtMEdGKkklc20xNkdGKkklc202NEdGKkkmc20zMjBHRipJJnNtODAwR0YqSSdzbTIwNDBHRipJJGhleEdGKiIiIg== QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiQlUTYkNyhJJHNtMEdGKkklc20xNkdGKkklc202NEdGKkkmc20zMjBHRipJJnNtODAwR0YqSSdzbTIwNDBHRipJJGhleEdGKiIiIg== QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiQ3JjYkNyhJJHNtMEdGKkklc20xNkdGKkklc202NEdGKkkmc20zMjBHRipJJnNtODAwR0YqSSdzbTIwNDBHRipJJGhleEdGKiIiIg== Let us now apply the SHAKE functions to some of these messages setting the output length equal to 4096 bits; the results agree with those in Keccak Code Package Test Vectors. QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkkmU0hBS0VHNiI2IyIkRyI2JTcmSSRzbTBHRipJJXNtNjRHRipJJnNtMzIwR0YqSSdzbTIwNDBHRioiJSc0JUkkaGV4R0YqIiIi QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkkmU0hBS0VHNiI2IyIkYyM2JTcmSSRzbTBHRipJJXNtNjRHRipJJnNtMzIwR0YqSSdzbTIwNDBHRioiJSc0JUkkaGV4R0YqIiIi The following messages from Keccak Code Package Test Vectors have byte lengths equal to B-1, B, and B+1, where B = 136 is the byte length of the blocks in which the message is partitioned when a bit rate r = 1088 is used. Thus they serve to test the different cases in the pad function according to the number of remaining bytes after partitioning the message in blocks of this length. Qyg+SSdzbTEwODBHNiJRaVtsQjc3MUQ1Q0VGNUQxQTQxQTkzRDE1NjQzRDcxODFEMkEyRUYwQThFODREOTE4MTJGMjBFRDIxRjE0N0JFRjczMkJGM0E2MEVGNDA2N0MzNzM0Qjg1QkM4Q0Q0NzE3ODBGMTBEQzlFODI5MUI1ODMzOUE2NzdCOTYwMjE4RjcxRTc5M0YyNzk3QUVBMzQ5NDA2NTEyODI5MDY1RDM3QkI1NUVBNzk2RkE0RjU2RkQ4ODk2QjQ5QjJDRDE5QjQzMjE1QUQ5NjdDNzEyQjI0RTUwMzJEMDY1MjMyRTAyQzEyNzQwOUQyRUQ0MTQ2QjlENzVENzYzRDUyREI5OEQ5NDlEM0IwRkVENkE4MDUyRkJCRiUhIiI+SSdzbTEwODhHRiVRW1xsQjMyRDk1QjBCOUFBRDJBODgxNkRFNkQwNkQxRjg2MDA4NTA1QkQ4QzE0MTI0RjZFOUExNjNCNUEyQURFNTVGODM1RDBFQzM4ODBFRjUwNzAwRDNCMjVFNDJDQzBBRjA1MENDRDFCRTVFNTU1QjIzMDg3RTA0RDdCRjk4MTM2MjI3ODBDNzMxM0ExOTU0Rjg3NDBCNkVFMkQzRjcxRjc2OERENDE3RjUyMDQ4MkJEM0EwOEQ0RjIyMkI0RUU5REJEMDE1NDQ3QjMzNTA3REQ1MEYzQUI0MjQ3QzVERTlBOEFCRDYyQThERUNFQTAxRTNCODdDOEI5MjdGNUIwOEJFQjM3Njc0QzZGOEUzODBDMDRGJUYnPkknc20xMDk2R0YlUV1cbDA0NDEwRTMxMDgyQTQ3NTg0QjQwNkYwNTEzOThBNkFCRTc0RTREQTU5QkI2Rjg1RTZCNDlFOEExRjdGMkNBMDBERkJBNTQ2MkMyQ0QyQkZERThCNjRGQjIxRDcwQzA4M0YxMTMxOEI1NkE1MkQwM0I4MUNBQzVFRUMyOUVCMzFCRDAwNzhCNjE1Njc4NkRBM0Q2RDhDMzMwOThDNUM0N0JCNjdBQzY0REIxNDE2NUFGNjVCNDQ1NDREODA2RERFNUY0ODdENTM3M0M3Rjk3OTJDMjk5RTk2ODZCN0U1ODIxRTdDOEUyNDU4MzE1Qjk5NkI1Njc3RDkyNkRBQzU3QjNGMjJEQTg3M0M2MDEwMTZBMERGJUYn The result of applying SHAKE256 (which uses Keccak with bit rate r = 1088) to these messages is the following (the same as in Keccak Code Package Test Vectors): QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkkmU0hBS0VHNiI2IyIkYyM2JTclSSdzbTEwODBHRipJJ3NtMTA4OEdGKkknc20xMDk2R0YqIiUnNCVJJGhleEdGKiIiIg== Next we give a "long message", taken from KATests. C$>I(lm34304G6"Q[c\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he 256-bit and 512-bit hashes corresponding to this message under the SHA-3 functions are the following: QyQtJkklU0hBM0c2IjYjIiRjIzYkSShsbTM0MzA0R0YmSSRoZXhHRiYiIiI= QyQtJkklU0hBM0c2IjYjIiQ3JjYkSShsbTM0MzA0R0YmSSRoZXhHRiYiIiI= We next apply Keccak, with b = 1600, r = 576 and output length 512: LUknS2VjY2FrRzYiNidJKGxtMzQzMDRHRiQiJSs7IiR3JiIkNyZJJGhleEdGJA== Next, we include a couple of text messages and we compute their message digests with the four SHA-3 functions; these results can be checked against those obtained using the online implementation of SHA-3 at http://emn178.github.io/online-tools/. Observe that a small change in the message produces a random-looking change in the hash value. QyQ+SSRtdDFHNiJRTFRoZX5xdWlja35icm93bn5mb3h+anVtcHN+b3Zlcn50aGV+bGF6eX5kb2dGJSEiIg== QyQ+SSRtdDJHNiJRTVRoZX5xdWlja35icm93bn5mb3h+anVtcHN+b3Zlcn50aGV+bGF6eX5kb2cuRiUhIiI= QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiRDIzYjNyRJJG10MUdGKkkkbXQyR0YqIiIi QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiRjIzYjNyRJJG10MUdGKkkkbXQyR0YqIiIi QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiQlUTYjNyRJJG10MUdGKkkkbXQyR0YqIiIi QyQtJkkifGlyRyUqcHJvdGVjdGVkRzYjJkklU0hBM0c2IjYjIiQ3JjYjNyRJJG10MUdGKkkkbXQyR0YqIiIi We now apply the SHAKE functions to both text messages: LSZJInxpckclKnByb3RlY3RlZEc2IyZJJlNIQUtFRzYiNiMiJEciNiQ3JEkkbXQxR0YpSSRtdDJHRikiJGMj LSZJInxpckclKnByb3RlY3RlZEc2IyZJJlNIQUtFRzYiNiMiJGMjNiQ3JEkkbXQxR0YpSSRtdDJHRikiJDcm We create, in the current directory, a file containing the sentence "The quick brown fox jumps over the lazy dog": QyQtSSxieXRlc3RvZmlsZUc2IjYlLUkoY29udmVydEclKnByb3RlY3RlZEc2JEkkbXQxR0YlSSZieXRlc0dGJVEtc2hhM3Rlc3RmaWxlRiVJJmZhbHNlR0YpIiIi We compute the hash of the file with SHA3-512; the result is the same that the one obtained for the text string: QyQtJkklU0hBM0c2IjYjIiQ3JjYkUS1zaGEzdGVzdGZpbGVGJkklZmlsZUdGJiIiIg== As another example, we compute the SHA3-512 hash of the original file containing this worksheet, namely, "SHA-3.mw", assuming it located on the current directory: QyQtJkklU0hBM0c2IjYjIiQ3JjYkUSlTSEEtMy5td0YmSSVmaWxlR0YmIiIi An example of the use of HMAC3 for authentication would be the following. Suppose that Alice wants to send Bob the following message: QyQ+SSRtc2dHNiJRSVRoZX5tZWV0aW5nfndpbGx+YmV+dG9tb3Jyb3d+YXR+MTE6MzB+QU1GJSEiIg== Alice wants to make sure that the message that Bob receives is exactly this one and that Bob knows that the message really comes from Alice. For authentication purposes they have agreed, through a secure channel, to use the 256-bit key with HMAC3[512]: QyQ+SSJrRzYiUVtvYzczYTQ4NzVzZmYzZGNjYTUwY2IwNDljZWNlYjNhNWUyMzBkNDVhNjQwNzExZGNkYmRkMDEyNTc2ZmZlNmYyMEYlISIi Alice then computes: QyQ+SSN0Z0c2Ii0mSSZITUFDM0dGJTYjIiQ3JjYkSSJrR0YlSSRtc2dHRiUiIiI= Alice then sends Bob the pair (msg, tg). By repeating the previous computation using the secret key k they share, Bob observes that the value obtained coincides with tg, which gives him assurance that the message really comes from Alice and has not been modified en route. In this case the message was sent in the clear but it is also possible to combine authentication with an encryption scheme to obtain authenticated encryption. Next, we use HMAC3 to compute a couple of tags. First we compute the HMAC tag for an ASCII message using SHA3-256: QyQtJkkmSE1BQzNHNiI2IyIkYyM2JFFJMGIwYjBiMGIwYjBiMGIwYjBiMGIwYjBiMGIwYjBiMGIwYjBiMGIwYkYmUSlIaX5UaGVyZUYmIiIi Now, the tag of a hex message using HMAC-SHA3-512: LSZJJkhNQUMzRzYiNiMiJDcmNiVRSWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFGJVFfcWRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRkZGRGJUkkaGV4R0Yl Another example is the following: QyQtJkkmSE1BQzNHNiI2IyIkNyY2JVFTMDEwMjAzMDQwNTA2MDcwODA5MGEwYjBjMGQwZTBmMTAxMTEyMTMxNDE1MTYxNzE4MTlGJi1fSSxTdHJpbmdUb29sc0c2JCUqcHJvdGVjdGVkR0koX3N5c2xpYkdGJkknUmVwZWF0R0YmNiRRI2NkRiYiI11JJGhleEdGJiIiIg== Finally, we compute the HMAC-SHA3-512 tag of the file "sha3testfile" created above, using the sentence "This is my not so secret key" as key: QyQtJkkmSE1BQzNHNiI2IyIkNyY2JVE9VGhpc35pc35teX5ub3R+c29+c2VjcmV0fmtleUYmUS1zaGEzdGVzdGZpbGVGJkklZmlsZUdGJiIiIg==

We have used Maple's capabilities as a programming environment, to implement and explore the cryptographic hash functions and the extended-output functions standardized by NIST in SHA-3 Standard. In addition, we have also implemented HMAC-SHA-3, the version of HMAC (Hash-based Message Authentication Code) based on the SHA-3 hash functions. These implementations use, whenever possible, lookup tables for efficiency and are able to provide hashes and to authenticate messages given either as hex strings, ASCII text strings or files. We have also included some Known Answer Tests to check compliance with the proposed standard.

M. Bellare, R. Canetti, H. Krawczyk, Keying Hash Functions for Message Authentication, available at http://cseweb.ucsd.edu/~mihir/papers/kmd5.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, The Keccak reference, Version 3.0 (Kreference), available at http://keccak.noekeon.org/Keccak-reference-3.0.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, The Keccak SHA-3 submission, Version 3.0 (Ksubmission), available at http://keccak.noekeon.org/Keccak-submission-3.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, Cryptographic sponge functions, Version 0.1 (Csponge), available at http://sponge.noekeon.org/CSF-0.1.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, R. Van Keer, Keccak implementation overview, Version 3.2 (Kimplementation), available at http://keccak.noekeon.org/Keccak-implementation-3.2.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, Note on Keccak parameters and usage (Kparameters), available at http://keccak.noekeon.org/NoteOnKeccakParametersAndUsage.pdf G. Bertoni, J. Daemen, M. Peeters, G. Van Assche, Keccak sponge function family main document (Kmain), available at http://keccak.noekeon.org/Keccak-main-2.1.pdf FIPS PUB 198-1, The Keyed-Hash Message Authentication Code (HMAC) (2008), available at http://csrc.nist.gov/publications/fips/fips198-1/FIPS-198-1_final.pdf FIPS PUB 202, SHA-3 Standard: Permutation-Based Hash and Extendable-Output Functions (2015) (SHA-3 Standard), available at http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf J.L. G\303\263mez Pardo, Introduction to Cryptography with Maple, Springer, 2013. N. Koblitz and A. Menezes, Another look at HMAC, available at http://eprint.iacr.org/2012/074.pdf R. Perlner, SHA3-based MACs (2014) (SHA-3 MACs), available at http://csrc.nist.gov/groups/ST/hash/sha-3/Aug2014/documents/perlner_kmac.pdf G. Van Assche, Keccak Code Package Test Vectors, available at https://github.com/gvanas/KeccakCodePackage/tree/master/TestVectors

Legal Notice: The copyright for this application is owned by the authors. Neither Maplesoft nor the authors are responsible for any errors contained within and are not liable for any damages resulting from the use of this material. This application is intended for non-commercial, non-profit use only. Contact the authors for permission if you wish to use this application in for-profit activities.