xapian-core-doc-1.4.17-150300.3.2.1<>,$4bvp9|aYē;jLCYv`ֻ(#ƨ#傻ɾ$8kOs\Gi}٥5~-S#\i/'!Vbb*~,-~\Lbwۇ/ѹ{R6e_nz+O.r(1U.~JόU`xѷ31f2c#>;?d & R# 9Lcit      H`>D\(*849:FGHI0XY\(]@^bcHdefluvezRdhnCxapian-core-doc1.4.17150300.3.2.1Documentation for the xapian-core librariesXapian is a Probabilistic Information Retrieval library. This subpackage provides the documentation for Xapian.bvibs-power9-13h+SUSE Linux Enterprise 15SUSE LLC GPL-2.0-onlyhttps://www.suse.com/Documentation/HTMLhttp://www.xapian.org/linuxppc64lev!!k7dD /D Dc B G^EPt B "B O;=<@8qs<1>yMD">D,@J 6cVO ipG -(3)'[as=X6s6u*[56 #L22Y<E0A!3 '4)ZZ/T (NNN1 "D0$ UD1 DT ^3441OCF; *z@18R t#0{-p`6  ft$@*73C+;$LZ!~D D )+~:$o<LWfBL2,j3X0P~-132@6&)b 0C*<H+2}O9YDX| ,C 4apw!Hk?I:/547+K9 *vdKK'B/( $ r 1tMu % kp& ,C= m#l Jv7j  F(Yo- %Y <._ p .!MN Ǎ5]VSaI I'#&#Fi@-x" VWuLWWBHR(V-HCin|!]:JY AJ/98_4BO_N.\7*!7=IZeA.h5.O=JC`1)/5LEAA큤bqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqbqc05ef5d3fd4f7b0437aea96853389dd9dc5ae12faa8ca083b9f758746f9c91d134ee018941b90d700ffa09dec32fa982031bc2881aaf534cdcdf49b35a68ae9d2b2897f422cd03831c27099c8116f39132da0f1f6c640267e16daaab230793aeae0e3f7c8b3a6c7ecaba68a257270501378acfcd44659a2015f750fd80c6264324f974c2dfdb608986041050cc3c9a8fd374131e89efd914f4a2f008f1fb05920ad7f6f5df00cd866667213e21ac59487dce11d096592c151d0fd1a2f9bf65854720a1920cb852480eed8abf56872e15ea0288cd1b36f5996a7ff9814d88a164f50c8aa8a7972b2793664e1a7a4fcf3bf9ae95931f9f50c17c5eaf5e63496f4510b879ec9b7a8ade4a848ea37f5cb1ea3647d7ec35044fe4ef8057ba370526bfdcc1a6a5a809164d0f39fb17e1939a782d2423106e9959a9fdc599ff10d5b3522bebfe8dabda640d9956b85ec3d984d42ab40d7c5fff27e8781b6c4e560a95a26464c48c99c336a2dc537dd5e630b00db3a63c93ed37c87d65bd3aa779ab0ba9dface4de984c3aa897f1bcca887edc71573f44cc358ee5341000522d6759169b4250aeb08d299ab94cad31bd7069ab6d66a961b2855480873947a8c73dd010dd2d63a75793f523e9123273190bb214773b7b9c03c8be1e70d422de5173fc414c727076f86d73b90b34291482beab5f526ae3bb1d521c4aba07fe56a9aa1d30f1a4cfc8e3a734c6055382f81ce8194c38726dc8ad817142c57e15643b48ddc66c484f741dc0ec2f09e027bb8aebccd06e2b80ed8dcd416a94fabe08e363b1e5ee508337924c551ee7f918b340b309537cffa66426b26538626d80dd7fee8c047fbba5e0993a473e8f2264a9d2d0f7eedfa67b330ce8bddf901463a954ea806cdd3d84f71126bab0c985ebda11db5c58e906c46ee51e5bcec70fe2d3b84277529abcdcb125c65fd65a20a525a2eaa05a3c8ed50f26dc411e1635f1de5ba83c38f249719cdc8d084b44d4071ab4fdf00143b248b5776905a09d620944c74f6e4b58e14d24811649ec985b6d34887100fec82b6fd70529983189927ba55323553be80cd32dc8748f6d69c3eb7f3e2439b417df3baa4131fdc425f99fa04b764343758a72c572a0456e733294b40874753bb049409417f2095e8b2b902c3cff85add3e14b8c603b36b76ac1464363534225f1e0599386dc683a26dc291ebe78395d20f40a8088d212e37107002cba888c0b96c648056ca5c765cc35181cedbe233811e11801005daf75e56c47435a64cea75b10d39854e76504fa105aaa4288c642a933959b8a540eb8758523965653b428ea353aba92d57dca226915138d134ae2b7a763830dbb282d6f0ab0920b08156396c61611cbbd334a19fd18a24005b80ecc6564bd4218b2449d4d78b4326814959240a2a6b02c67b63d4186a15e8ab0af4a8f8caf4ee9dde828ed915fe713d19262b1d1e31a59891e72220ad8330818b2668de6912a06295183a28a998727bb1a92874ac162f63d165cb5c936ac9ed41add20579608e676de6b40e170c275e78e059fe2a8238ee881d20c5bdf805310e1fcfd0efaf3224aae764b3d620e94805c490d30224682d360b4900f33958d4f5373242d7f9231852265ea138c28464070990a4240f4718f30608e6926be3b0868affe4c5bfd1d61741be30c613a01ea7e1c775b6ac30e9bfeb3cc0811f6bb97ee5d1ff927c6b490dc395d3d360366f0e2e09f3627044f51838b946627a5c13e109ed87a8cd517b7ad911f940e5bba7e3b08d7427b607d5e4421636910ab22ffd76bb9185ccbf8bd295103b863ce34e4df8a4240692cc8d5459846b75d370621afedfa2a0d100351919228eb7c1bb0cf52d0f7b5b4530c56769781709d540afd1cc72016165e33be93ffbe3760c8266e33114577948dc3b8507ffe8782cad2e10021d4da690f6d4ca9d523128cb1ef4840a6f2b52fba994c5352892d902440b56da42c42047f9c5e0e8e467e9ee5f9e969605e8f4988f180e06e1964132069190b7a85df3f98c89cd51020b3a956651c2a850ad37f66f6a85dc43412b30117c6cdf8050eb47851c17e1447816070f5d76ae8dc704c9889c6fe1c52c809d9540bc8b0c7f6a8e661938beb75fc1b00cf2c94692cdfdcacb25fd56604aeb0b510be8f1fc4939d036fea778d7b70a65dc4b26c61c15188198aa7c269be6efb1f01a89b68f4479a748d2258b0072a24b361c2652f8d13bf69bae8d77c904eac9a9db807b86f415530bd4ea57f311ae6d9d3b8ecfbac96c078322d527be1441bd2c5dcc2d87eca37f8aab4eae81658846c2b4e1921db561ddf994da8a69649d7adee53ed8a0497c68c03c80ceb9599def354854c608edc5150998e75ec39972744fb140bb18b41d6243b19acbee52156a9d5d243c8d5d7e4fb313ea543dc969fdc38baecc2e321b1acb39edc457e19f6c5f004371881f5ae7a7196990eb42a363e4abbb9c5d92d955be14bcb290602e8ea3a799d4a2cb70de65b7a5d92c3ce18b6f8687ca2c5a6c28ad42f3e5d6e60d39c16019371b938aa8b9343cbc51eb9c809ad3396dfac7afda9e8d275016fc0cbf3849856a8ee45d58a12ea83df237a895190fb32f199d9d056037ffbdd9d3b21309606ea1b88cd1f821b32f0191faaeca155bcce8b96658ad06f865e88119f2fe053509f85bf4018fdf298c2b4797ddeb221005ad816d71a9007c53760b589563fd4dc8a56505bba3e67c02f733d821739a4ea57a991a63ae2d175fc5590cba0e8200c271155956b9c84491d159c2e5fe9eb6a6dd9a7f5ebed4a5fa3f10e2c739910e377f3b204cd7b3db50aa2425417baae5f85f701ca2c05966bce99e1debbb5c017ff9c398544e9d3a67efa3cf22d2b48666e4fd56c478186ce287c8bbf181133f639d2064f096d4f2d69053a7da0800d094cf05412e7da047761758e90d90947cd92429deffd00af2e0a152b65bf7fd7416855e2988425e6f68773ac563a6f9a3624f31e80f18a9235b37570469d705c064deb54e9a5b97b631c42b32151d71680d9937c9cc12183918430842fd4a473f5c64a7a3bc5abf3d4a264f2b52023a5f4517629e93a755f7c8244481faebb92a0142f91b1e943910c867965191dbe2abc7290e39cb684f4be8317deb3ec15078909d60ec9fe787c37b9f5111dfe9b2b3d5622d647e2ebf20570ba5dedd0cebc6f8c8b7944c146f11e401c1ef242be68dae5ef20155ada529e57436b711a8d9219420d6fb8e9f09d128d451994441473520fe4a2ee5364400d9d43a703912dd76a75f89e84612659624168b6a7232b62ab714c14d0d89927a44529c40b9552aac1f6ced9407b28049e0c2978b1cecf3120994563943ed1913cc0379476e0537d1b88019262b12f48a332440a25efb11591d5bef26e30f55c6ccd8fa72ee66feca5fd302d79b4a6a37d31fa8c74b6bb28d7489657b29e3a5c9ea25dd9101fbf501707af8d46ff3c6f249527b617b85ab76aae0291f74527aefea21bc6a586761d98e47e3de00697622ff191bb6302328f6357312f9e52db3125f32513047a469d939e7dc23ec01c7e17c3b22945d45471e091db2a9d477f56662ff7507f2c7f1ac1d0d5e6d2dcabcd0f933d071e6a154f7722fda2fceb5deeec145242b9b20e681f153d7119417007c8ac963c35813ee991d082a036784edcb0e2e0098b3f94514ede0890c81e5334b4e9d0e23c7ad7016588e71b3f218f8db0a56045d3c97607f6141467ec1b3048dced681f0a20410cc4ed6e16320f007287948d6f8bf52472e1e8594a1c21cb43dafb187d813485ee8e1aaf30ea16d5393dbdf2f86507115491ab2adb4d137e6208220c556dec37f9169f3eb0702f2c6f62f33760a2b32db75df18e83e529dce70e8f71bb3db0fe485b7031736bf6bfc5bcd9dc29181b463d6a2406675395ed54701f793c9c1441b43c38a549882436d062376796926d408ec94becee964241c2ade110c6d5671c22b9a3ff84b604ae8c9ff43cf7debd0040078c7e66a49787da8e4343cfb2d332dcab7f11c1254d2329c1f841379a7b791cc5df4b3aa2913e3636fc44ab59f7ec17e21fb770801c77156049baddd43df5e513edd5b51fbd07e1e164beb3386d93047e0d1d1d3530dcb76fc0635ae7602611c5909fabdec323d013e7f9cbd46386e651ea0169475f5aaaa3e558a9fc67a936fa46379e3c9d0b0f597fe304f40660d0593b502b1198a946486db70e1d4c88264e7da1f16114715de0996ed9e73556292903326b622563109822a9663a80b9e4bddcf716eb3c7041d3a1536ee87486235d4c3d62f90c9a8de5f8b261b506e819214fe37d68c5c30915a37bad4b4da16f8150c9918850363681c6ab504567c9787495dab2720deebde29beb6c31886aaf6311fe4c1854c84219a0d4e55a73a0cfc7265fce18051fc132e1a270d16eb3e28b3bf8aa1eab719c9efde40686a7c7ce85515108221a262bb9000ee208e961f58a40b533b582a39346eb4164f171909f4a6ac99684be9f251cb502372853612786df764d1ff91493586384928d14dfa0ce65119ee69480f51a029ac7c044f00242ec3a57cd7d326851d960ad5b34ab389d03b85dc76d6563b91b7b1256c44464d83115d001b413181e0ea5f49aff809fbe17a5561dc18249f61e6f5d5deda441e1b4bc38194c4a54a39e09584f67f571492350220c30e8e413bfa81d8056a9abda39c42dfe35e9b647edaf0469e5688fd9da71417419611ed5f04094e77cba3c7e57bb33a428922d06ed2534ecf67d5f997e021e6dd077420b70319dcecddb4fc654212697f154be9c28006b6ceb242cfaeb2ea65d2c4add89b299b3d76dbf56edada12f694cc25ed731461da8e1e42e42c2d9e8ec502f367ae055f8c62445547b9d760100591d6879f68e9a14e8b44aa8009a329ebb9a8b449567b4f2161380da2a9b41f9d53fc4c129b1646150333362d2c781c1a1b0241a1503c586b070013894334b1dcb2a8c1d0709cfe502a76d75cb47a47ddb9592a1d7131a9ffb104be6e182762da9833ff838c0ebca4f506f1716d649524afde3cc324e459b0c919e87845508db50e0b13d5eed8c34f0a0fb83120813ac61f0c4c450162e6ff35c292bdee3edcb9b8cdcdd278dab0b649be5ff173da32c9cab36f9be550bbb0102c0303aa838112024a2e340a8d10e4f222c63b8d34179f0b98b4bb91abef35cd8f4f25b766377dd9f75fb58656fa6c0c2813e19f581550074a7a03a45bf2765b1c0d27bd543781b89b89282e88defebef3417cc5aabf45790937d6adfd81e255d4ddd7bdb6718541a7c33311fb230672d1073d36980d318212177ee4f9e56a3e7aaba38a92d745051772d1bffc3db80baffc93ce7507c2c6aac515faa9d5844f9a301a45d75a577bd6e65d63040291b121e918953c38461627c5d1055cd51a69164be929a40a281a94fe6e8de57fcd0e49beb2ef8ca5708be0a89be73a8b5ac953fed009457a2924d076d14fda9bd6392317de71699d0d54ec636840afb570e199856ffca8647a5f1328ba968deabcde776a613afb9bcee6baaf664c160e073b65a89b8c39f45edfed60de4322f2589d24ec550f150ae790c39ce6ffe962019f4f3b080938e71ba9b5f6bdb13a2f57c5b12217c561303d47dee5501a1e8a44517cfc594189f8ab5c1cfa8f9c0a3a2a516e371759bced033fd5c1401e1180e102679dc2ca617ef2bd5007426de6d7c3f48497c0ad4ff2bc6de13cfb485f3bc264fa6c2216c3f2cb5c93133327a8515ffd5c6dd27f2eb46f9614d6e9609f3536f0c63623ef6d0a9d8b4f2f4c78bd53a2ef97a8595f575baf01e08739061dc37ee068020cee8799d1445a8f49bed07b5ffc47d5900255266b0ab1852604159959bd99638e55bd92dc04078e4c50fbbf15297891706ec74baff9f738fb61519af71441470f275a57d3c5b39627bc05f9a0d65cad941856d22fb73b28f3ca383fe38abd26dc67838baedbfb6b7aeed21db5d2afe53fb4ff316dad2ee1cdcd82080fea06df923f4ed9fbcc429c27f4abb7b15c0349510e71ab844da1ddf87f79d93edb2c96615b02362602c537d688cdade0db9ab92b135152c1c073463022eb906d831b3e4833c2ac8d7b924fc9fab2692a6000f41529a37c7f61fbcba1de0843e17436cbc3597261c4276aaee7925f483110850a969245ddf90cc1b70b821e25d601d1634071012283dabee6bf0947747f4303b3596bfd9181b66ae857f5ae0416cb50015f6268b7ace26dbb64b1d7017412357f2d453b6ba59ca74c45867c57b265777de5711da7b35feed18ecba9de2e0e81b2e0c5aa952c434dbab563f54cd4bc75d94e2bfb647027e70915edd99aece18cf77ade4771eb98930c9df7e1eb900bd49098f8164240c37aabaa94dc81a857106662f04aa1b0cdca11771bb9b5f81659da3da6e2e98d9ab4af9d14de3282deb080857ded241d636c528413c4dfa9bc67ad4709f6de4ce54a804f24432db662c20df6a59db21bc60a5b018d050350a930b5a53b360d3063ccaeeddc19cc8ea89ef79829fb4ab3ab31f44d24136a305485975f39167ca08e2a36fbaa3d57b7312b8f5a4fb7a4bb10a16ae044bde2de5e460f51a28298b2f97a411f9b76563862e3cc609d848993c82e5083d41701c3ecadc5a7bf27474f85b7eba364c8b7e16b51004173ec4d39320c8a1e31bddf25e8339d58b1d935235240698fe87f158a8fa09d1b77fe8d5677ec9a596c85a37ea574749dcfd75188cfdf912b08178583fc8ec39811e1c2c36459b028ee15f4f775cc101b8f1fab1c09c26f0e04230bb9ac3d8dee72a0239b53f7ad654f0047e9a708f47214194bec2c94841312220aa5a98893b584f3b4ad1310281ecfddc4b689cc9e3fe299a49ce35055df2702ea5f95c7997086bde24b1bcea3da4cfa63faa038c3ff329f299824fd08fa213f4c68161695e00f1a11e4a170824e08a548e1d35db27c0da85735d2040831e6b456d077cb286a258d1e3da18735bf24961f087ea1fa3657280e137855a727f00f3f3912bca4ca8c0344320d047563151540063c9923594d865bcafa771bfa23c7827d6fd9a3b01bb454ad17a0693726d5f09832942cea7107935f7db513f7e43139f2cd97027d6f0c44061c8bf8fc9a3d65ee7150aa74a87c97462a20c6eb9246fce7a5cc88829623294cdbee6f76e07d79af4e51f4a789f0bdf92b6e76d5a44b6b19f3c18267bd5f84d0aa0d6b61ed0ea8756e18a6258a98c8e01d3fe26d1f405954574dbdece38f6d85ae17b7b87096b921c5a2795cf8173cb09e619aee1e0e39f2b3c5d06ebb7843320f98a853bc217949ce455afd9baf5434e7e5ea94c204374c567ae6b621955c68ff281c0254797327be255e54a8c2e7ebaed8f4bbaabf6ab81ebcdfb05a6fdbfc078ca38ef9eaa277c98077c15b949dfb244d11c97cfc087b2b400a1bcb715c20914de95db60127aa4896dd0ef98668e265abf35c1e3a221f23c994ef3fd0290c158665724ab5d7487d338b8953ef19a188fe8de8e4a9dbdfce10eda8c6fb962c9ef090916ee3d30feeae74a984b531d48280536f8eff61b71ac5446c76768f9a797e41a1a44d422a2dacd7a9b61e05c0a24872e2d12339cb0e09452a0f950e817d930618e957bc9e45a0aff127c16a77a09c0b762aa2e7aedfca7b3aa1108772ab6470921f8acdd79fb21c398785e864ceb9d2d70ba53126f08ab4c700ac59ca52a91fcb74652d9bb1f57cd7df99fbcde95f833537afcbc3f971969ba2d9bc4bdcba4d73f9ecf5564ce23617135036322c9b895e5ac6847a3c663953657b79441b11f3aa9a7348463d41b6a2ba604c602774709cf1848bbb94fd121aa601a053dd9dad3743e8f521a34c63bc30bc6ea2a5f643c990ca97c6ceeacde3738ca947f1bda532562d82efc93541e90e15a635f5563855d451b8dbfc945c0c7bf767f22ab9009d3993b3cabadd06e5e14837a669feb049030ed42a42eac2cbf9030be0538352269c42b1e33ff68d4f0926a39e4de00ecefb4d1188c5b428153e3bffc71b888b13a07939f964cc51addd628fd67fb75ea9cca6cdfaebfaba9dbb7bae4aca15d5da2e79c600d32ce4ebd98accb48cc584fef2c7ec9792af2cc7422d28b661d404060b5cb8f3ea579b4c95a256dda5344b178cf55159d2a8abcd039300246c499e3ed20ba147bc051e094397b0aee6483f517e86c14e15d4ea4c48edb6d756ae30733c924a372debb2560c4c9a37f575c46f8fa438362a6ce2cb0bc30f9e1a42cb2e0a0d6b75424dcc1da7d9dff152fd5841b1053597d63d610af661cee0e6572e7b7683f5764c4ee3268c2ae7ae6ef184e4c3a46d5f54d0ede5cba9eb031bfd227453795ca2c613d530ec3978fe36a7c489640658a44270e1d28012b9728d38502fca65a5f74033b98de3f5345d3b4a45a5258202444947b3140af0cad35603193f507a9b603ded20de3572a85bf12646429e033e6b2b689371697c3c05eab55209733171764792208b595badaf6d1c3e9a386b2733c1ca4ab511d7c01d99fcdcf36d5520ed63c59cb7042200c4581cff7aa12c90d26e3c79fa3d08b264a037c5bae9cf0aa642320fe68e3923f57902c733e260cd7cc9a51a96d6984405858b37b7b9cbdba3c20b3a95b23b81c0b4d42dcb2b2ecb0fc7d49de4f1db44c49d11bd8cef7cc3d6dc2580bb223966372c728ad5f134594f36ab91f8d6708e54d586931bbdda1f621727e7cb20fec0b56901b918535f32bb79b2f0a2cb59374c6a04787cb290863a9069d721ec8bcdfe34045dfe2e58ca94c59545bf9f8d8ac274e959551eebe9bc13de55290e4b6366979a48d64e075c3184b37ccff7550ff5520da2c732ce6499953767d3ac8fcd36a4330d6750960525c9b9ec3b40bbb3cc6036808df4190d34c100b7fc6e76739feee28e023822cbaf6a1f306fcb966fd997043040d44e7392c8c09c6039946172ecc31be063dd385a3b19d93748e2be64b74a6526a31547f188bec6d38e9f624300e97250040a05d21242da6150c782bec61daeca4f09d57101d9955972ef89c54221ead835b59c5dbe3d02b63d282a5ad8f71da6d6ce754bfd7585312f83c5eb9607e0a7314f4c91cf65e9ee80dbc564b8107e52a9a6360f6d0579204dac5c26c0ac90274802ed77037b8368717579ac552fa7d7474bca9f286bc563fb397abedc76393dadb25cc14fa888413076aec39993cc4bb620219bd1688b0ed5efc987a6ee2e62a5e0b63b4401e30904eb29c0af6decabe6b23ce788ff547c4a1745a2c933cde0aa7548d6de0654795da08d0f952ff9b8e9fdb0efa252c0e1c52226f29faffbcd341fb24eef6c0d3f093fb38810443b8767c2c18535847f10354e82abbab88a97467e8e78d642e414d00edf588104764f3d7e8bfb4e3afce1f9a5777e4391d171c973558ff58034de3d6f1546f9db0b9069895f637a1303bbb8505793e36afac982c2914cea9b28f2c51f75924768163ff4325be193cbdbf038dcf931d7bc80b844bad9d7fec41db9928fa14a57683f4816f18af5fa10ff07a84d7bcda78a5820491df11959818133c5f70c1fafd71f693a6cfe1993ede609166097daedfcb22c842e572e0c77e9409fe5e9e3ddfb49009f151a78a5ce403af65d0ca9a28a31bde2e523eea2955ed56885ec673f3b608c9c81b76d9cf24403935e5384657c3cdc970a93263bf3affd5d027678ea8af7c667e0e37387cd81ae18d05eb1af3e05edb1ac737a21f06eb894862c46819fc877a32f2e8d516f3d5451544f361af9dd0eba52c1582f1c2a1b83f5891e1cba65cd8067963626f5f83e0e8cf545c1ee8821d278372fc12f8b0e959dafbede525feb913369a38ba000b0bd26ca69333e2298b1a46bbdc02c4c3e0002e2b1b975aa617f25d1518125628788cacc0ece5c8ca0c5af22a63c50bdade6f02301b46db421e687e4bd3d0177e57f41d83a7437912fee0a0cb33710d73143a40a16ab46e279e8e0b7705d2c730d39d88ab61209ff5ac20953d654891e0eae392f3756c52edddfc272d07c7850128c0b08cd470bdd18e26695da0edb0cbb9b7460856df5184170efb2f65fda986094fc5b8aa44600368b0d54e36d11e1c83f981e6cf3f7b94a14b800183d2ac597a070f6b6a5ce9bfec33cd76cc526fb8ba669c617d5ae684f08b58d102d9e8abc9174dafcfc48eb36a4cb7076456880974ea468070baca7ed0d91d9fef8dd4428beb7ebd1eab7b0f967070db6bfe506dbfda254558846b177e43b9defafb2b9ea98c1bb1d7b895bdc5a651484aad107d2c24234d6fd54e87d757128d69c5d9ce407033930fd3ad6db18c3813b4ff02c371cd438fdb9adc8eabde264095c4e97369c7b8435ce7712a9a6be9912c7f0a1d333401199f535a30311defb741ff28b3d95abe31f25e268a129665110b0c08788fbaaca1f87f211915d16a7a1b509ee60a9978c2121670c65bbfef97110695045a066bcea875532780527c94bc6e7ad201adac1125f758b3b149a6a572cbb7e88c76230c1dab3a1682174481d5e6a893b24b882c9e3f58662637e7b8680d48cfbfc4ca0bf8d75f348fc3be4e1eed6092c6c107195dce2866d6d15ba9d77e488286fa8ee2660c91f927ad8556dddb797d420065f3235b60ab50f917accce06f2cb2b1951a0a1a9be847b75d1f96c552365e9a871f621745d48ebcb66321e1e6a8b55ea08f68234ad94be1f40ee1c927c1c64299187b6613ec00758856fc673a763aa4e714005db8acb62feb3dcecf346445f35c9c4ebcf114dad2de08ad33d932789739b0bc65bd6bf1ef733cd7884eec0b2759cfc236c385629ec41fbf7aa51113247bbd575354a31afe9b493385d672c453ec8c41bfb2ea6c18c5d5bf7f38bc52f56615b2456fc941edcd217c4133403cb952d859562700d95fc17a313b548a724fa0072db53d9988160d75d3fa56ea2c885d5631a8bed7e2a4d22e796e0ad3722bbd7ff6bbbdd66854333cd1d720fa28ad711eac62a9583749a2a6dde3c92338c962004208622abfcb5e19dcb5e4cc5530c1164375a1a3e8a2f31b062715a8803eb11d3b13c1ddac216b1f328b78118c3442cfdf59e734695107020ac744fcb6aa07133912cedbd49fce5c5d75e39246663c5f5a651986c583f3bb044bada0774853ea51a63b2e104d64637c32c65a8d8f2b83b45bcbf726e2807656d012309fc13e83049ba5577acdd3661207acdb255e4108d38f6b15541bdf87a5b07107668e1bae055c7fb53db4789736d002a8da891395a301774f69c9dda97ecb2e6607e901e83503ef420b6025a4d34ec53641fe68ecc388386170b6b8abaff2cd3830363434ecd5ad40a3385ea64923658355d109f2cc24cae882bb61ad4d6540d9fb23d1e02b26e78aae6c78a97a1bff53a3e41d4708f85de5c3f65677e63ce1fb99dba048a88926aca14951c5b5bb23e1691891ce4842ebb0ae3c88ad4d9d59519e162b7c5cc7cf4701ef733fdfa5f9e66b2a7ecc947507cc45c93de9ae5deee077ee97265e750fe1c635f11230d929543cdc943034d622d4916e5396f7140714d2bf6a3b958885030d346e8c06eee9b6caf9086888fe27e647b27ca1a61f38b3cd8db7a1bacfedff4172da8e7f290f0880e79164bf28468c2f29490054eb08786b63deb50d7c8461308ece5a77448736be91fe142f9e280299907963642559cb6b9857c9dace47126ba7e12e804d26042255a2a96aebe44a397f2fc76f9b0a68996f668e769353f9d1f3eaa64193ec791a57c2e8b1cf489e0d70262518946faed5f8d2ca5a4e6a37d5d9a51104f21aa11734a038502df931cdd330de0815aca1173eb680d245d6c9b956178fa85ee1a1827898d5059b333fdce19595bbf6ac9cf81a2ecf66a4f665d9f320968e1ba074cfdb3e7313ca3e35e8f0a82cacd4dfa6b38754aa4f7814723df6677d23be3cdd74fbfa4089bcfa51dc6769d23229cab7c802471a67924fbe155027df3d0e86dc0a5c5663ea9cec12176205db11a21dc3651628a462766359745a5d0e50239407db02f0b74c40435f0d117c9ba2d754f86496ed08e35eb122ab4af414e28c13648ac9b78740257d653a4e6ae144c1a3ed36d524b41333ac2f5c1874480bcbcc9470d1b8da3c7567a577d0cb90c2fb45aeaa0436dc0a22c152694de9a623c9139229572468b9eb560b319ce132215d8bb93c732466c5599dde889c08f33fc9724afdd2cd479b43a367a6432c0451d1a8a41fdf13399ad9fbb23181247e971ac2053443042267d8bc026f0cdbb3636590a782cb40eab4710adf972ba820f42051aba49567ef989a7c9a30f1ae80c419c41d18bf8b8dbfa8c2c8a29e5f43d7f1d1cbcbcd43017153dfc617009c8e609347b8949d6bd587fc26cf341748623419e9096ccb290ff1aa898aade0384c3741119b8c8231f0b49ed7d1336158e3032d21cb651d1580350bcc3119a55bc7750093fd12ee1e3159dfad8d38ca9b9ef21609c9e8341f7816a5b6e3275c3a91c4977598942dd3b7e6e8717be850951f45113d8ffccf2e76858cc353e2db6f141c6b8bbb017be55c024961112c7a6e6880888a44e1d9a24d6d00245919b3af2ee27627c834148983ee96593195bb0802d2896176cd16898e21683ac778479b93f9e604781f1c6e67244349d0f933a78137a2383193b13c6117525aba5d25836ab1ffd292e7239a7f03925e28b7ca8addc2b7ab2f45203e4e41df4775d1916aa9722ac1f55bead94a7a53c0c38cd6520d86fdaf3ff6ac2e579a361c5db0f79ccba66a390ce05220425aa770dc1019bbef42adb003e820f7829a258ecca92dcc1b32f8d3dece343ed9a2186d1e9a9dc93c3244b7e84d9b9d6a1f37797e3f9fc0c1575b1a55a466f06fff706bbef79c365115de4f1c876f30faab896cad48f1075baecbcd9f33698430a84c06c2f3e04b1f382a62abe7061f57eb835067ddcbbb54641569920f3ae722921e4cbc9ef4ea1d60eff806d41449b05b0d6df75e3030e7ba428a68886dcd821b1553ec9a878bcad309105e5c0789055203f9887952d649fedb4ece4e0435807a95242d1b8e1c8179773db2dac9a37603e93ee203aa7de2f142308d6a8436dc6d35b126c92e2a7f94eb76a67a95a473d4816753a478ea3548d22a726cafdfb44d9b353a1da08e889014faec5b218e8d40cec08e6150bafd94acce5cc6aa4f57b023976f4304566485d843b1b9fc6cce22ce1835eec899ea9af73199061d41a27dbf8099e1d8427989252cba719b753f4cd685527c2b7b39236ae7b77e75f4f9409c5fbb88d8648ad46cd6e5371d229be6f09df16fecd666d544a00a3c0bbf483973e2e5682ec4bb8d7c9367e6f834f9abd8864172a1722d8a8f3c9298c04807daf382da0379ec67797dc27d78369026732f6a179ef8c2fd3069d992d4118f48d978b9bb8c6b52b2f193ab36c0ce10a22206b5589252462a890dc3802566c029e5f0607e6a1de2cdb3624870652bab989226ee69bb7328162e602c0db8cab4c8535666b308dd418c44b7dcecd8e03b14ed1ef90c796c40e37e1b577a74fb71ac146276630cb6233994803152f9e2ec42ca60027c4e0b6b666c902caf8bd134cfe4abb221e974dca32b50563dbd2172a895134e6aa5ec8ba1887c16a34eea36cb113c0b121a9582c2f33029451fcd9bbab9f8ecdee6d172d3da40ad1644d11bdde47e269fe1bc2188de02688dd041ac4488952f7be86f29e09d1bf86308c432b58e1104736ae96cac87a3306aa44d042839083bc9d317657fe8175d15acb511c66050ee7277d56e413456009d5a259e4bb17690e9d643084b1197bd10a893946ffb8cd06b9d05782578f33e1e192de80f2182afefd1f83df8d6a56ace775d57ffe0fc2e51796033b5e502f535a773406bb751d645cbd4a93662b0d42fd0a34f982f6fffd5da588bae070e58113c67d804306a3d5b39d1b04ea9243d1ed413c1d36515ab7dd84c97022fadcc188ea94519cde8209bdb3aaef92dca1d94e3469b62328cbcd82021100af5c1ffbe8fe084b813899be5b14d495a32700a821f70ead0533b9a9aa639d425da2e6b837ea3682358097d6c40be1cf8063b23d60bd15602cae5ae33486084e6cdc3745e3318cb40c40d8b9efbfb5dc05d5a1d4317d045dd908c8b4d2b931a33b81b811f5736dd99ce6fd5f26b163a89974e17010e4057afd26fa81eb12499003026541eec15e719c134509b6e1ab7d746729e22f0ac6a3ccfe1fe161b539f906b79800d72da23aa32d0ef46cf2a4d395e0c1a88680e1ff1735875c0333a95a5e33c8991f90d78b8c8b155dd314a665e9c96e572113a0ceac716788d936b384ef08fa08a53a0d850cad1311820a6499611e7f96665499dc59a39bea0b38594cccc2da9061e9bf23edcb06058311dda23d9bf061fc59374ddd4c6fc48fc3103bbd20878f5579212061a9fe49c861f65530454aa7eb43eeca63535d58e2c023976ce03e24b52b780cc1eb93ae4817ba57cf7c94fc8528563d5b485bb08896b42a4ddadde3f58eb62be5ce9bc39e2d0d5b260df77e5f95c4354b6f6affed00704047e5409ba293617ba1c9dc3aae1e6b041f2422794c7c1abf290a34006417d978ecca554e424dab10e71b29d791740317be8edd032e8e021fb91fab1ba604e4eb7e7614721e50ddb14e13d9b2df34e5201c2405ac82641af341e50b77c7bb7f71c91c769eb305b9a6aaea5b6b177e7ac8af254d7ade4919827db281fdafd571db5166b9dda75cace28193c5696da2b24fe2d513924f5548535ed2e89c6e8652e9bc961dc11840e8adba96c7c76cf2bcee978fba76d4e3f9a1c15cd5dfcd4c133c54dbcb94d1d71f64c084a7a7734cb01d8930a8dfb224448e58468568e02cb121421c49d36bdfd8c8c80c56929b436fcf1886da3b794f70b05b827791e6aac14de1fd68e3a9cb6f3a79c23d8407b414c02907c2c9c562c5436b3ec7e4dabd673b6e40031d9f1e58e0ccfa1a8ed0d146aa8b19ec375eec81b8effe5ce00dae79293be2d3f131e68c24cfbf690a01b106a08e5d526705579d4d613bd0ccb7bcab4396f5dceb7c8260d35c1b05456b7af427acbe7026e8cc13fb52a8bd6c93ed97e1b094ee167226596fbb43d7ccfb22ba1da92faca071fca326d6cf4b2c82a21eeb68806a5b8dd512cd1e3c1d7fd65d76d678206ee7cb00c21612949eafa098c348fbc313e62227489318156d71f3889255d9bc39647914010cb2c403d9908290f766031a0cca52724742fdd0e31d2b339455f136e9833a11eeb209106f97f90d346d77c9d82f1019e63dde6b387359cba319fc2857cca3127e129400614c9b0963ff5ab6fd1c518763f6bb7dbe4df1f8579b4ec4a9d5889f1e9ff082f977427390529e375d0f30f50e5ec80a5db6d6606bc9452b16c73e466c3420bee0a20d17a82c1ccd323228c5474c26c32a518a6ee5bd7e24bad4b3a97560d363145a99d4c57dc188d4e3a28f8c1e3481c2a4ac16d6f9081a79a2a28a1c46d1edbb6bd63a75ffa68bcad27c4298b14a2606f8aa1a89f825b98314c619607394f81af848f48d8512e14114b7b4707e89786809b35962160477048d7bd21ff667aca626961f81771c2bb0f0ab25e5eaa1614c0d875acc0f717f9125a19c700b1fd56cfe242e485ea383f00eec9c5f09368318c922fbd6f73bc712c41b8d14cc599d49571591643fb061f4a16941451d73da814ac8ba048671d97bc8620477d67febff37e3635f22beb94dfc6991177cc4fb4eb7db072b272c8bd9f056f518bbce8eb4dcb68a4a3048e03c2ba76a186f63a6e85b7f76a1c51e4e94f57d69d9e310ee2534d07d51a4275889d1e73cac1dfaa9ca132b40f6491e5264b96e6cac880056108b8a87ba116598dd4f4b98f396b6396c58af9f9965ee39f39f2d56a207d88e492424a3eb2370be909121690d74a6845433578d80140e5a846a8630073728c2166f699a2115bc7b47654ff9c5f98606b6ae1722a747ced167ed2a6d6dd8fea9bc026c71458bf64195e6092da235434a98f67ad6f4fb5ca236cc2df89c930cf0c7a3912202c00c7d4eee5f07c80ec1386847aec1b4904fead776493ab4fc63a2e54ae4420c6418cf4193d41ea3b77ca5bf072b7a5d904428d4e1ff4da4a136bdef5cfd89b0d776bb0cf2e54144f455e9343d5c3b039551f384328f21c32e4f12bfa33474480dd0e2d084ae8172a13884f3b50e1a1c8b315c5225098a1f60da0390b72d39cafa1cc4c8bdece2e56803063049e125111c0238fecd5c298395fbaf2c6abef8d892d50aed9aea516f0c880ef45469615be92039ba6e327e9f8ec2ebee9fd1c4c77d818facd9e85342e1956f5fb35975270350262abcf1fe1066cfe98472256119b5901ce4f24fdebd7b2140bf7aa92d09f68943b1ad58732a90871b3bb346e591bfed666bd16cff9176282fac62fa2673b90e20502feee12577e277d9a0acf0c3ea5748514205ebe07b767342712120d3a84f5d2739b038867b8336ce46840480ec4412e636fd3b3c378646e54054333b908d41bc54be2df8a044cbfcdfa210ace8b1444fef059313dafb380ae30437bd5a4636d0b6a1ee5fb6cea8a3cd14bf660ca580151adcf534af704d782b85b45a3fc03742bde4dc5338bda6b837402b68fd0e4ef01a3f044811d096da3baed7b7699254bf032ed08934403cb730b0e35465e59d23a3e1624c09e33e2774d4022397e208bac76393b6da820b40b50361e5ec0854cf68fc46f235fb789426ade5501ff8be7321c3889f7ca2f7967411ee08d9860e1bc85253b290dd5ad3870a7b995b554afbb335e29193969364bdb98ca785921bd680a3ffb3debe4aa6fb7c531b234e65114a34f159cb18935fde0e4b9227f18d0c857739c23a9f5fafe29dea2bce086f46b2ab23170e61758ed6e32ea892715f07b1d7c5bb33e089d0ef08ad61208ef4dd9b2a62db24ac7c9ba2dd6288dfd00720a689092430210e9f088784222d0edca51d7cb8cf2aa5c55b8710f41e7f39e0a84bc8cfa863ef619ae5aff36f9997f8e04bc2a8ee7b87eaf2a8b20244ab3ad78faa880c4d1b5b01258036ef429f208d64c9d75c0c1abfc66430b280c9eae1030215b649a6947b91b7c20124cc7a98c8df91aeb125d09c622aad3c1eb700ee6b79129cd85b834e0e2a0f12a89f44984aafdd0f00e396a0cdb9b944d9be570a8d3a148c733c37afac1239e21274336bf5758c916e2b601332a58114a120c5ea2b68e0bc77b198d909900386b252ff07af59c42fea55c8575223141c99faf217f4a892fb9d485c7e52a26814c0730512b4e19a0a317ba1956cdf5ae159d3198405477a74847b4c1eaa6413c8c9d5546f64c1b8fbf185b4d84179f588055f7cea71ca10398b7bdc6dd51bb8d7698ec8450ac7136016df24ff170153015f5d21e33d6a67fd25e15d9ab00f38746aeffca7674a16cb7b47df9543203f24da0557d96c8df6f6bb55e2c1951ec7940f983225f80a2bb01b4d15e88856821df91ca5cbbefcec4d75c97fab30a9ae6aec6a7a1d115bc9ada8a4fd97e41d8583f5f6fa9a5968cb80ea11d71f09b7d20f1aac858ac7bbdd7c3cc7cdba5a39a17fe586907d40d836a0f1ca4efb7694cdefca3b505701beb4c2e7a158ef9b511e651b461986430d5bd75037c2fed2443a4f2a6086085fca71ad260fe9ddc4815eddbe7210ee8786156c344545b1c26fe95beae9bf3c481f9125b9328574c17b6fe841f67ab65f1e2eff903cb5e85544cbb27c5f2ac51e4cc2291ec1ce7bb76733d91f2ee8ac101c849d432e9afd140c0509716c6699ecd87d5ce8dc1e500ea0d75490c88ab38ed3f32735081f7b7c9d1b65e7060bc88447fecbd35fb058f5b0737861880b493f88e731ffaff34948d338c68d1acbbb8c8d202a6f0a4c4958518e1a0b1439662585174521c84256da68b00f33fa4b7cdc8e8db8f1237888a9c73f114fc10d3b503b7efabbf530241365c99f2e2eee9c918ee3679fa36629fc7d0244c4ed6658f34f8804ea7a425edc3f7af47fa0cac430c0f0f6344dd4c84fe15e4d12a7a27e36d32a01dfdc0195e7bc5d7612b607cd9acaf92f9326896793dc30116e5f49e305ad0c6d61675c229ba2a22398c55e9af3536c402c652f8432fba86f7b724cced0aa638d8a51b3697209ff9e9e0dc96469b2d9c7292015dab0dd1569a70f680325f5ad4bbe5ceb15cbd5784d7c47c68b4b75a2f2b2627a8e6ec0cfcbfd6d80c7f2e7fb8871edeae2c4415d290da7d3eced573c851208637a9d28cbc844347c167f725bd231fed460708008124b0162411395a44ba26a0bec9d9c934aea89186a0c4c23d0bdb1c2561df758efd8eb78abe771c68bcc398a582abada562fbbbc9453fd17c35519ac18cefacca2eb87c76bbbf92c5ad39723060a6592efe49900e50d354650b37d7bbbde5aa349015559de56b48fc62a0197c06905be4cc2151eb4d4ad4a07bcd7f1499cc94397b9ae31962676a40cc24da417b7ab40176abbae3b9007daf7a4d7a550cb02a2c9e211212826b842c11dd0344b075b34e0848b269b15d21245d3d5d6308f98e80f41f05752df1e3724edd7643cec57de9f1d8422ce4ee982a6ce28520435341d157dd4dc803f408860fa62c09535321b53c771fa0b68c6abcab55dcfedcad2238076e8fdf7a500ea0069f539580d22d3e143180815af2a0ceab25dbed5fc0d25bbec61858c96442ec39df62662a75391aa4a0117940af98638963c2d76dd8eeffd42600481c2bf861356999ee0ce27134185898b149e1e10709a78219d0cbc8d181002db4fcb97bdb8a9e3d626ee23bc93ae5d78574124f6d2b57e05fd81009b5155157ea039272d772f80f106b598278c2c3d69597c292980d56225307cdf44526f801001de263d9783ff77f5204c5e1b887ee788b87462b7f46953244dc52cfd332c99ea308ba62cae4f457e6ac72f9a9358b92f9da27b14697b88bf62c65c712180d95e01833f5256bf930aab2cc899f87a49a2350b5a9cd6bb4a1855da7acbd29f64491351f7ad958f7cb360fd1decc481e17c8e4d22509110e569486d58c68c41a8ea3dceac07dea9357ca73f767e52167a1e47fa279d48d61275a29d533e0d932109a3b1081dbc70f283934a348452ac45acc9c98adfa44bc41df601a22efc6f4eaedc1e5783adc57f2c35c21192cb52d18608606a8c8830294735fbbbdfd8897fca2640bd4fc4ed41b697f58bbe78e4fed40cf8938b86972e72d0950f195cca60deb1f32281edb465d0ca35f2acafae03abb7fe4f2eb2724aa76ef57b4435bf7740226a903d80f55bdebedd14efc95665e691c5cf07fc0c20a0fced18f10bea30bef471ce69cc05f50da20e3553a292194850853da012690f5d3ec103bed491b39e03082c773f0f35be9b6cb64033c9a49e40f001793ef236295e3a2d418582ed16f6d66533fd606ee3fa2497a2a258c9c8bcd0e8720142c8ac62df5e8103df9c1e3cce377635762b2518a5673a0b3d9cfd6988775eb8ac774d1ac7372df39e0f47b171ee9264759f33f77df1509939825fcc9ec19afa21cac94545f9f9895024daa42f06999c6713539e928023499e5f17f80dfb92fd03a3ab0de7d2a7e3a04a181f347ade481e661e807b8ee1dcb63499c473483239b42811e58e9ada6402c1786e8fba2d1c7fa8f00bdccebee9fd8edc0a2e2e8486a0d9522da46c325f955cd16b68abb36894e52f5c8782d6978820eed1e598b697ebab874971b94a36d8977f7b263fd283ce970baa4559234c9ddc4cd44c93e03f7e65c105e2e15a12c0f4f158401b7eb6b3ac58c6d698ff8845a54800c3f239d578ba57af2bdcf345d4e34b39ad622f32855aac7ab48034c618c3d9a914f632d7fb05047fb3b157394b4a453da06a58bef0850d2be6063dc0b9a688504f47cb226c43c1f0835efae3576becfa11ada077514e1d5d78b4f7fcf8c36ee5e0356c465b0e632ca7d476955b951abc67736ce2170f2c43ed4459d18ecc36bfa6589cbd4ec10ea8db6a80e3a5d7c8a214358f58fb6445a93908222f1d8177a40c6cc90de0de4837126ecd2b2a0b6835bb65a44fa0887936b5ef378dfb85ae64e96543f7d87049a06e1320f7f8bc62f4ca6c42a06e02208f5ccea43edc2dc4331ffe45879a908a8a2085a3a259a73990f061dc5b74ab8dfbd5f978a1ada4e3217b5aa0eb5adab7baaa72b92d00f3cd1cb4b19280db0be3bc8247cf56127b62db34ad5f7b206fc574fa5c5cf12958d6a58296a8f4b2cfa5e74017b23435b8b99e3262f8867736a16070c8382b01b7da32df2e6a76f7639ff20070d924152ce516730b29f62132ad11cce1b28732925093048a9508643a6988435ed4d5cffcee7995f7e626c51a0e95b95393cdc640aa0f703bcd3be8dd2c2954d20f4942ccb79c2c7cf89a172cf7a758e5690fe4561ccb658f8cfrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootrootxapian-core-1.4.17-150300.3.2.1.src.rpmxapian-core-docxapian-core-doc(ppc-64)    rpmlib(CompressedFileNames)rpmlib(FileDigests)rpmlib(PayloadFilesHavePrefix)rpmlib(PayloadIsXz)xapian-core3.0.4-14.6.0-14.0-15.2-11.4.174.14.3_G@_7@^l@^[@[^[W[;e@Z2gYV=@XX%W@W4U]UD@UT!TFJalarrosa@suse.comdmueller@suse.comdimstar@opensuse.orgalarrosa@suse.comalarrosa@suse.comsean@suspend.netjengelh@inai.dealarrosa@suse.comalarrosa@suse.comalarrosa@suse.comalarrosa@suse.comalarrosa@suse.comtittiatcoke@gmail.comtittiatcoke@gmail.comtittiatcoke@gmail.comhrvoje.senjan@gmail.commpluskal@suse.commpluskal@suse.comtittiatcoke@gmail.com- Update to 1.4.17: + API: * Database::get_average_length(): Add this as an alias for Database::get_avlen(). In git master we've added this as a preferred new name - adding it to 1.4.x too will make it easier for users to update to using this. * Database::get_spelling_suggestion(): Optimise edit distance initialisation loop to significantly reduce the cost of a typical edit distance calculation. * Fix query expansion on sharded databases. The mechanism for passing in which shard a TermList is from wasn't hooked up and as a result we'd always think it's from the first shard, meaning the statistics would be wrong and that our suggested terms may not have been as good as they should be in this situation. * Enquire::get_eset(): Use string::compare() to avoid 1/3 of the string compares on average. + documentation: * Update doxygen HTML headers and footers to resolve issues with some interactive features of the API docs not working. Reported by Enrico Zini. * Stop specifying obsolete doxygen settings PERL_PATH and MSCGEN_PATH. * Clarify API docs for MSet::get_termfreq() to make it clear that this considers all documents in the database, not only those that matched the searched (it would sometimes be useful to be able to report the number of occurrences of a term in the matched documents, but it's not something we currently keep track of). Reported by Tadeusz Sośnierz and Peter Salomonsen.- update to 1.4.16: * MSet::snippet(): The snippet now includes trailing punctuation which carries meaning or gives useful context. See https://github.com/xapian/xapian/pull/180, reported by Robert Stepanek. * MSet::snippet(): Fix segfault generating snippet from default-constructed MSet. This probably isn't something you'd typically do, but it shouldn't crash. Found during extended testing of #803 (which only affected git master) which was reported by Robert Stepanek. * Remove trailing full stop from exception messages. We conventionally don't include one, but a few cases didn't follow that convention. testsuite: * Replace direct use of ftime() which gives deprecation warnings with recent mingw. Reported by srinivasyadav22. matcher: * Fix segfault in rare cases in the query optimiser. We keep a pointer to the most recent posting list to use as a hint for opening the next posting list, but the existing mechanism to take ownership of this hint had a flaw. We now invalidate the hint in situations where it might be indirectly deleted which is safe, but somewhat conservative. * Improve the optimisation of an always-matching OP_VALUE_GE to also take effect when the value slot's lower bound is equal to the limit of the OP_VALUE_GE. Patch from boda sadalla. glass backend: * Report the correct errno value if commit() fails. We were potentially reporting ENOENT from an unlink() call cleaning up a temporary file prior to throwing the exception instead. documentation: * Fix missing menus in API documentation. Newer doxygen generates .js files which we also need to distribute and install. Reported by sec^nd on #xapian. * Note OP_FILTER ignored subquery bug fixed in 1.4.15 as present in 1.4.14 and older. portability: * Use our own autoconf cache variable namespace (xo_cv_ prefix instead of ac_cv_) to avoid colliding with standard autoconf macro use if config.site or a shared config.cache is used. The former case caused a build failure for the OpenBSD port with 1.4.15, reported by Lucas R. * Use clock_gettime() and nanosleep() under modern mingw as these allow higher precision than what we previously used.- Update to version 1.4.15: + API: * Database::check(): Fix checking of replication changesets. This reverts a change incorrectly made in 1.3.7. * Database::locked(): Return false instead of true for a closed inmemory DB. * Database::commit(): If commit() failed with an exception while trying to add pending changes (e.g. InvalidArgumentError due to a long term containing zero bytes) then a subsequent commit() on the same object would throw the same exception. Now we clear the pending changes in this situation (like we already did for failure at other stages in the commit). This bug remains unfixed for the chert backend as it's harder to fix there and the effort to fix it and extra risk of breakage don't seem justified for a backend we recommend people migrate away from. * QueryParser::parse_query(): Optimise parsing of multi-word synonyms. + Testsuite fixes. + matcher: * Hoist positional check above OP_FILTER. * Handle OP_FILTER with more than two subqueries correctly. Previously we'd only check the first two subqueries in some situations. + remote backend: * For a remote WritableDatabase, the client now keeps track of whether there are pending changes, and if there aren't then we now do nothing for commit() or cancel() calls. In particular this saves a message exchange when the WritableDatabase destructor is called when changes have already been committed with an explicit call to commit() (which is what we recommend doing, since with an explicit call to commit() you get to see any exception which gets thrown). * When closing a remote prog WritableDatabase, previously an exception could leave the remote connection open with the remote server running, and we'd then wait for the specified timeout before closing the connection. Now we close the connection before letting the exception propagate. * Don't swallow exceptions from Database::close() on a remote database. If we aren't in a transaction and so try to commit() and that fails then previously the caller would have no indication of the failure. * Fix handling the reported term weight when remote shards are searched. Fixes 5 XFAILs in the testsuite. * Add missing space to mismatching protocol versions error message. + build system: * Fix to build when configured with --disable-backend-remote, broken by changes in 1.4.14. Fixes #797, reported by Дилян Палаузов. * The clang and icc compilers both define __GNUC__, which led our ABI mismatch message to report them as "g++" with a bogus version (the version of GCC that these compilers advertise themselves as, which for clang is always 4.2.0) - now we report clang++ or icc along with the actual version of that compiler. + updated documentation.- Update to 1.4.14: * API: + Xapian::QueryParser: Handle "" inside a quoted phrase better. In a quoted boolean term, "" is treated as an escaped ", so handle it in a compatible way for quoted phrases. Previously we'd drop out of the phrase and start a new phrase. Fixes #630, reported by Austin Clements. + Xapian::Stem: The constructor which takes a stemmer name now takes an optional second bool parameter - if this is true, then an unknown stemmer name falls back to using the "none" stemmer instead of throwing an exception. This allows simply constructing a stemmer from an ISO language code without having to worry about whether there's a stemmer for that language, and without having to handle an exception if there isn't. + Xapian::Stem: Fix a bug with handling 4-byte UTF-8 sequences which potentially affects most of the stemmers. None of the stemmers work in languages where 4-byte UTF-8 sequences are part of the alphabet, but this bug could result in invalid UTF-8 sequences in terms generated from text containing high Unicode codepoints such as emoji, which can cause issues (for example, in some language bindings). Fix synced from Snowball git post 2.0.0. + Xapian::Stem: Add a new is_none() method which tests if this is a "none" stemmer. + Xapian::Weight: The total length of all documents is now made available to Xapian::Weight subclasses, and this is now used by DLHWeight, DPHWeight and LMWeight. To maintain ABI compatibility, internally this still fetches the average length and the number of documents, multiplies them, then rounds the result, but in the next release series this will be handled directly. + Xapian::Database::locked() on an inmemory database used to always return false, but an inmemory Database is always actually a WritableDatabase underneath, so now we always report true in this case because it's really always report being locked for writing. + testsuite: * Fix failing multi_glass_remoteprog_glass tests on x86. When the tests are run under valgrind, remote servers should be run using the runsrv wrapper script, but this wasn't happening for remote servers in multi-databases - now it is. Also, previously runsrv only used valgrind for the remote for an x86 build that didn't use SSE, but it seems there are x87 instructions in libc that are affected by valgrind not providing excess precision, so do this for x86 builds which use SSE too. Together these changes fix failures of topercent2, xor2, tradweight1 under backend multi_glass_remoteprog_glass on x86. * Fix C++ One-Definition Rule (ODR) violation in testsuite code. Two different source files linked into apitest were each defining a different `struct test`. Wrap each in an anonymous namespace to localise it to the file it is defined and used in. This was probably harmless in practice, unless trying to build with Link-Time Optimisation or similar (which is how it was detected). * Test all language codes in stemlangs1. The testsuite hardcodes a list of supported language codes which hadn't been updated since 2008. * Improve DateRangeProcessor test coverage. + matcher: * Handle pruning under a positional check. This used to be impossible, but since 1.4.13 it can happen as we now hoist AND_NOT to just below where we hoist the positional checks. The code on master already handles pruning here so this bug is specific to the RELEASE/1.4 branch. * When searching with collapsing over multiple shards, at least some of which are remote, uncollapsed_upper_bound could be too low and uncollapsed_lower_bound too high. This was causing assertion failures in testcases msize1 and msize2 under test harness backends multi_glass_remoteprog_glass and multi_remoteprog_glass. * Internally we no longer calculate a bogus total_term_count as the sum of total_length * doc_count for all shards. Instead we just use the sum of total_length, which gives the total number of term occurrences. This change should improve the estimated collection_freq values for synonyms. * Several places where we might divide zero by zero in a database where wdf was always zero have been fixed. + build system: * configure: Stop using AC_FUNC_MEMCMP. The autoconf manual marks it as "obsolescent", and it seems clear that nobody's relying on it as we're missing the "'AC_LIBOBJ' replacement for 'memcmp'" which it would try to use if needed. + documentation: * HACKING: Replace release docs with pointer to the developer guide where they are now maintained. + portability: * Eliminate 2 uses of atoi(). These are potentially problematic in a multithreaded application if setlocale() is called by another thread at the same time. * Don't check __GNUC__ in visibility.h as the configure probe before defining XAPIAN_ENABLE_VISIBILITY checks that the visibility attributes work. This probably makes no difference in practice, as all compilers we're aware of which support symbol visibility also define __GNUC__. * Document Sun C++ requires --disable-shared. - Update to 1.4.13: + API: * Fix write one past end of std::vector on certain QueryParser parser errors. This is undefined behaviour, but the write was always into reserved space, so in practice we'd actually get away with it (it was noticed because it triggers an error when running under ubsan and using libc++). * MSet::get_matches_estimated(): Improve rounding of result - a bug meant we would almost always round down. * Optimise test for UTF-8 continuation character. Performing a signed char comparison shaves an instruction or two on most architectures. * Database::get_revision(): Return revision 0 for a Database with no shards rather that throwing InvalidOperationError. * DPHWeight: Avoid dividing by 0 when searching a sharded database when one shard is empty. The result wasn't used in this case, but it's still undefined behaviour. Detected by UBSan. + testsuite: * The "singlefile" test harness backend manager now creates databases by compacting the corresponding underlying backend database (creating it first if need be) rather than always creating a temporary database to compact. * Enable compaction testcases for multi and singlefile test harness backends. * Add generated database support for remoteprog and remotetcp test harness backends. * Add test harness support for running testcases using a multi database comprised of one local and one remote shard, or two remote shards. * Check if removing existing multi stub failed. Previously if removing an existing stub failed, the test harness would create a temporary new stub and then try to rename it over the old one, which will always fail on Microsoft Windows. * Wait for xapian-tcpsrv processes to finish before moving on to the next testcase under __WIN32__ like we already do on POSIX platforms. + matcher: * Optimise OP_AND_NOT better. We now combine its left argument with other connected and-like subqueries, and gather up and hoist the negated subqueries and apply them together above the combined and-like subqueries, just below any positional filters. * Optimise OP_AND_MAYBE better. We now combine its left argument with other connected and-like subqueries, and gather up and hoist the optional subqueries and apply them together above the combined and-like subqueries and any hoisted positional filters. * Treat all BoolWeight queries as scaled by 0 - we can optimise better if we know the query is unweighted. + glass backend: * Allow zlib compression to reduce size by one byte. We were specifying an output buffer size one byte smaller than the input, but it appears zlib won't use the final byte in the buffer, so we actually need to pass the input size as the output buffer size. * Only try to compress Btree item values > 18 bytes, which saves CPU time without sacrificing any significant size savings. + remote backend: * Fix match stats when searching with collapsing over multiple shards and at least some shards are remote. * Ignore orphaned remote protocol replies which can happen when searching with a remote shard if an exception is thrown by another shard. * Wait for xapian-progsrv child to exit when a remote Database or WritableDatabase object is closed under __WIN32__ like we already do for POSIX platforms. + documentation: * Correct documentation of initial messages in replication protocol. + tools: * quest: Report bounds and estimate of number of matches. * xapian-delve: Improve output when database revision information is not available. We now specially handle the cases of a DB with multiple shards and a backend which doesn't support get_revision(). + portability: * Fix warning from GCC 9 with -Wdeprecated-copy (which is enabled by -Wextra) if a reference to an Error object is thrown. * Suppress GCC warning in our API headers when compiling code using Xapian with GCC and -Wduplicated-branches. * Mark some internal classes as final (following GCC -Wsuggest-final-types suggestions to allow some method calls to be devirtualised). * Fix to build with --enable-maintainer-mode and Perl < 5.10, which doesn't have the `//=` operator. It's unlikely developers will have such an old Perl, but the mingw environment on appveyor CI does. The use of `//=` was introduced by changes in 1.4.10. - Update to 1.4.12: + API: * Xapian::PostingSource: When a PostingSource without a clone() method is used with a Database containing multiple shards, the documented behaviour has always been that Xapian::InvalidOperationError is thrown. However, since at least 1.4.0, this exception hasn't been thrown, but instead a single PostingSource object would get used for all the shards, typically leading to incorrect results. The actual behaviour now matches what was documented. * Xapian::Database: Add size() method which reports the number of shards. * Xapian::Database::check(): You can now pass a stub database which will check all the databases listed in it (or throw Xapian::UnimplementError for backends which don't support checking). * Xapian::Document: When updating a document use a emplace_hint() to make the bulk insertion O(n) instead of O(n·log(n)), and use std::move() to avoid copying OmDocumentTerm objects. * Xapian::Query: Add missing get_unique_terms_end() method. * Xapian::iterator_valid(): Implement for Utf8Iterator + testsuite: * Fix keepalive1 failures on some platforms. On some platforms a timeout gives NetworkTimeoutError and on others NetworkError - since 1.4.10 changed to checking the exact exception type, keepalive1 has been failing on the former set of platforms. We now just check for NetworkError or a subclass here (since NetworkTimeoutError is a subclass of NetworkError). * Run cursordelbug1 testcase with multi databases too. + matcher: * Ownership of PostingSource objects during the match now makes use of the optional reference-counting mechanism rather than a separate flag. + remote backend: * Fix remote protocol design bug. Previously some messages didn't send a reply but could result in an exception being sent over the link. That exception would then get read as a response to the next message instead of its actual response so we'd be out of step. This fix necessitated a minor version bump in the remote protocol (to 39.1). If you are upgrading a live system which uses the remote backend, upgrade the servers before the clients. * Fix socket leaks on errors during opening a database. * Don't close remote DB socket on receiving EOF as the levels above won't know it's been closed and may try to perform operations on it, which would be problematic if that fd gets reused in the meantime. Leaving it open means any further operations will also get EOF. * We add a wrapper around the libc socket() function which deals with the corner case where SOCK_CLOEXEC is defined but socket() fails if it is specified (which can happen with a newer libc and older kernel). Unfortunately, this wrapper wasn't checking the returned value from socket() correctly, so when SOCK_CLOEXEC was specified and non-zero it would create the socket() with SOCK_CLOEXEC, then leak that one and create it again without SOCK_CLOEXEC. We now check the return value properly. * Fix potential infinite loop in ValueCountMatchSpy::merge_results() if passed serialised results with extra data appended (which shouldn't happen in normal use). + build system: * Current versions of valgrind result in false positives on current versions of macOS, so on this platform configure now only enables use of valgrind if it's specified explicitly. * Refactor macros to probe for compiler flags so they automatically cache their results and consistently report success/failure. * Rename our custom TYPE_SOCKLEN_T macro to XAPIAN_TYPE_SOCKLEN_T. The AX_TYPE_SOCKLEN_T macro defines an alias of TYPE_SOCKLEN_T for itself which means it can get used instead in some situations, but it isn't compatible with our macro. We can't just switch to AX_TYPE_SOCKLEN_T as it doesn't handle cases we need, so just rename our macro to avoid potential problems. + documentation: * Improve API documentation for Xapian::Query class. Add missing doc comments and improve some of the existing ones. * Add Unicode consortium names and codes for categories from Chapter 4, Version 11 of the Unicode standard. Patch from David Bremner. * Improve configure --help output - drop "[default=no]" for --enable-* options which default off. Палаузов. * Fix API documentation typo - Query::op (the type) not op_ (a parameter name). * Note which version Document::remove_postings() was added in. * In the remote protocol documentation, MSG_REPLACEDOCUMENTTERM was documented as not having a reply, but actually REPLY_ADDDOCUMENT is sent. * Update list of users. + tools: * copydatabase: A change in 1.4.6 which added support for \ as directory separator on platforms where that's the norm broke the code in copydatabase which removes a trailing slash from input databases. + portability: * Add missing '#include '. * Fix str() helper function when converting the most negative value of a signed integer type. * Avoid calling close() on fd we know must actually be a WIN32 SOCKET. * Include not for std::boolalpha. * Rework setenv() compatibility handling. Now that Solaris 9 is dead we can assume setenv() is provided by Unix-like platforms (POSIX requires it). For other platforms, provide a compatibility implementation of setenv() which so the compatibility code is encapsulated in one place rather than replicated at every use. * Fix maintainer-mode builds on Solaris where /bin/tr is not POSIX compliant. We now use the simple workaround suggested by the autoconf manual. * Improve support for Sun C++: + Suppress unhelpful warning for lambda with multiple return statements. + Enable reporting the tags corresponding to warnings, which we need to know in order to suppress any new unhelpful warnings. + Adjust our workaround for bug with this compiler's header to avoid a compiler warning. + Use -xldscope=symbolic for Sun C++. This flag is roughly equivalent to - Bsymbolic-functions which we've probed for with GNU ld since Xapian 1.0.0. - Update to 1.4.11: + API: * MSet::SNIPPET_CJK_NGRAM - new flag for use with MSet::snippet() to enable support for selecting and highlighting snippets which works with the QueryParser and TermGenerator FLAG_CJK_NGRAM flags. This mode can also be enabled by setting environment variable XAPIAN_CJK_NGRAM to a non-empty value. (There was nominally already support for XAPIAN_CJK_NGRAM in MSet::snippet(), but it didn't work usefully - the highlighting added was all empty start/end pairs at the end of the span of CJK characters containing the CJK ngram terms, which to the user would typically look like it was selecting the end of the text and not highlighting anything). * Deprecate XAPIAN_CJK_NGRAM environment variable. There are now flags which can be used instead in all cases, and there's sadly no portable thread-safe way to read an environment variable so checking environment variables is problematic in library code that may be used in multithreaded programs. * Query::OP_ELITE_SET currently incorrectly recursively flattens any OP_OR (or OP_OR-like) subqueries into the list of subqueries it selects from - until that's fixed, we now select from the full exploded list rather than the last n (where n is the number of direct subqueries of the OP_ELITE_SET). + testsuite: * Testcases which need a generated database now get run with a sharded database. * Avoid using strerror() in the testsuite which removes an obstacle to running tests in parallel in separate threads. + matcher: * Extend detection of cases of OP_SYNONYM with disjoint subqueries (which means we don't need document length) which was added in 1.4.8 - we now detect when all subqueries are different terms, or when all subqueries are non-overlapping wildcards. The second case is what QueryParser produces for a wildcard or partial query with a query prefix which maps to more than one term prefix. + glass backend: * Handle an empty value slot lower bound gracefully. This shouldn't happen for a non-empty slot, but has been reported by a notmuch user so it seems there is (or perhaps was as the database was several years old) a way it can come about. We now check for this situation and set the smallest possible valid lower bound instead, so other code assuming a valid lower bound will work correctly. + chert backend: * Handle an empty value slot lower bound gracefully, equivalent to the change made for glass. + documentation: * HACKING: We no longer use auto_ptr<>. * NEWS: Correct factual error in old entry - the 0.4.1 release was Open Muscat not OmSee (the OmSee name was only applied after that final release was made, and only used internally to BrightStation). + portability: * Suppress more clang -Wself-assign-overloaded warnings in testcases which are deliberately testing handling of self-assignment. * Add missing includes of . + debug code: * When configured with --enable-log, the O_SYNC flag was always specified when opening the logfile, with the intention that the most recent log entries wouldn't get lost if there was a crash, but O_SYNC can incur a significant performance overhead and most debugging is not of such crashes. So we no longer specify O_SYNC by default, but you can now request synchronous logging by including %! anywhere in the filename specified with XAPIAN_DEBUG_LOG (the %! is replaced with the empty string). We also now use O_DSYNC if available in preference to O_SYNC, since the mtime of the log file isn't important. - Update to 1.4.10: + API: * DatabaseClosedError: New exception class thrown instead of DatabaseError when an operation is attempted which can't be completed because it involves a database which close() was previously called on. DatabaseClosedError is a subclass of DatabaseError so existing code catching DatabaseError will still work as before. * DatabaseNotFoundError: New exception class thrown instead of DatabaseOpeningError when the problem is the problem is "file not found" or similar. DatabaseNotFoundError is a subclass of DatabaseOpeningError so existing code catching DatabaseOpeningError will still work as before. * Query: Make &=, |= and ^= on Query objects opportunistically append to an existing query with a matching query operator which has a reference count of 1. This provides an easy way to incrementally build flatter query trees. * Query: Support `query &= ~query2` better - this now is handled exactly equivalent to `query = query & ~query2` and gives `query AND_NOT query2` instead of `query AND ( AND_NOT query2)`. * QueryParser: Now uses &=, |= and ^= to produce flatter query trees. This fixes problems with running out of stack space when handling Query object trees built by abusing QueryParser to parse very large machine-generated queries. * Stopper: Fix incorrect accents in Hungarian stopword list. Patch from David Corbett. + testsuite: * Test MSet::snippet() with small and zero lengths. * Fix testcase stubdb4 annotations - this testcase doesn't need a backend. * Add PATH annotation for testcases needing get_database_path() to avoid having to repeatedly list the backends where this is supported in testcase annotations. * TEST_EXCEPTION helper macro now checks that the exact specified exception type is thrown. Previously it would allow a subclass of the specified exception type, but in testcases we really want to be able to test for an exact type. + matcher: * Map OP_VALUE_GE/OP_VALUE_LE on an empty slot to EmptyPostList. We already do this for OP_VALUE_RANGE, and it's a little more efficient than creating a postlist object which checks the empty value slot. + glass backend: * We no longer flush all pending positional changes when a postlist, termlist or all-terms is opened on a modified WritableDatabase. Doing so was incurring a significant performance cost, and the first of these happens internally when `replace_document(term, doc)` is used, which is the usual way to support non-numeric unique ids. We now only flush pending positional changes when committing. + remote backend: * Use poll() where available instead of select(). poll() is specified by POSIX.1-2001 so should be widely available by now, and it allows watching any fd (select() is limited to watching fds < FD_SETSIZE). For any platforms which still lack poll() we now workaround this select() limitation when a high numbered fd needs to be watched (for example, by trying a non-blocking read or write and on EAGAIN sleeping for a bit before retrying). * Stop watching fds for "exceptional conditions" - none of these are relevant to our usage. * Remove 0.1s timeout in ready_to_read(). The comment says this is to avoid a busy loop, but that's out of date - the matcher first checks which remotes are ready to read and then does a second pass to handle those which weren't with a blocking read. + build system: * Stop probing for header sys/errno.h which is no longer used - it was only needed for Compaq C++, support for which was dropped in 1.4.8. + documentation: * docs/valueranges.html: Update to document RangeProcessor instead of ValueRangeProcessor - the latter is deprecated and will be gone in the next release series. * Document RangeProcessor::operator()() returns OP_INVALID to signal it doesn't recognise a range. * Update some URLs for pages which have moved. * Use https for URLs where available. * HACKING: Update "empty()" section for changes in C++11. + portability: * Suppress clang warnings for self-assignment tests. Some testcases trigger this new-ish clang warning while testing that self-assignment works, which seems a useful thing to be testing - at least one of these is a regression test. * Add std::move to fix clang -Wreturn-std-move warning (which is enabled by - Wall). * Add casts to fix ubsan warnings. These cases aren't undefined behaviour, but are reported by ubsan extra checks implicit-integer-truncation and/or implicit-conversion which it is useful to be able to enable to catch potential bugs. * Fix check for when to use _byteswap_ulong() - in practice this would only have caused a problem if a platform provided _byteswap_ushort() but not _byteswap_ulong(), but we're not aware of any which do. * Fix return values of do_bswap() helpers to match parameter types (previously we always returned int and only supported swapping types up to 32 bits, so this probably doesn't result in any behavioural changes). * Only include if we'll use it instead of always including it when it exists. Including can result in warnings about duplicate declarations of builtin functions under mingw. * Remove call to close()/closesocket() when the argument is always -1 (since the change to use getaddrinfo() in 1.3.3).- Update to 1.4.9: * API: + Document::add_posting(): Fix bugs with the change in 1.4.8 to more efficiently handle insertion of a batch of extra positions in ascending order. These could lead to missing positions and corrupted encoded positional data. * remote backend: + Avoid hang if remote connection shutdown fails by not waiting for the connection to close in this situation. Seems to fix occasional hangs seen on macOS. Patch from Germán M. Bravo. - Update to 1.4.8: * API: + QueryParser,TermGenerator: Add new stemming mode STEM_SOME_FULL_POS. This stores positional information for both stemmed and unstemmed terms, allowing NEAR and ADJ to work with stemmed terms. The extra positional information is likely to take up a significant amount of extra disk space so the default STEM_SOME is likely to be a better choice for most users. + Database::check(): Fetch and decompress the document data to catch problems with the splitting of large data into multiple entries, corruption of the compressed data, etc. Also check that empty document data isn't explicitly stored for glass. + Fix an incorrect type being used for term positions in the TermGenerator API. These were Xapian::termcount but should be Xapian::termpos. Both are typedefs for the same 32-bit unsigned integer type by default (almost always "unsigned int") so this change is entirely compatible, except that if you were configuring 1.4.7 or earlier with --enable-64bit-termcount you need to also use the new --enable-64bit-termpos configure option with 1.4.8 and up or rebuild your applications. This change was necessary to make - -enable-64bit-termpos actually useful. + Add Document::remove_postings() method which removes all postings in a specified term position range much more efficiently than by calling remove_posting() repeatedly. It returns the number of postings removed. + Fix bugs with handling term positions >= 0x80000000. Reported by Gaurav Arora. + Document::add_posting(): More efficiently handle insertion of a batch of extra positions in ascending order. + Query: Simplify OP_SYNONYM with single OP_WILDCARD subquery by converting to OP_WILDCARD with combiner OP_SYNONYM, which means such cases can take advantage of the new matcher optimisation in this release to avoid needing document length for OP_WILDCARD with combiner OP_SYNONYM. * testsuite: + Catch and report std::exception from the test harness itself. + apitest: Drop special case for not storing doc length in testcase postlist5 - all backends have stored document lengths for a long time. + test_harness: Create directories in a race-free way. * matcher: + Avoid needing document length for an OP_WILDCARD with combiner OP_SYNONYM. We know that we can't get any duplicate terms in the expansion of a wildcard so the sum of the wdf from them can't possibly exceed the document length. + OP_SYNONYM: No longer tries to initialise weights for its subquery, which should reduce the time taken to set up a large wildcard query. + OP_SYNONYM: Fix frequency estimates when OP_SYNONYM is used with a subquery containing OP_XOR or OP_MAX - in such cases the frequency estimates for the first subquery of the OP_XOR/OP_MAX were used for all its subqueries. Also the estimated collection frequency is now rounded to the nearest integer rather than always being rounded down. * glass backend: + Revert change made in 1.4.6: Enable glass's "open_nearby_postlist" optimisation (which especially helps large wildcard queries) for writable databases without any uncommitted changes as well. The amended check isn't conservative enough as there may be postlist changes in the inverter while the table is unmodified. This breaks testcase T150-tagging.sh in notmuch's testsuite, reported by David Bremner. + When indexing a document without any terms we now avoid some unnecessary work when storing its termlist. * build system: + New --enable-64bit-termpos configure option which makes Xapian::termpos a 64-bit type and enables support for storing 64-bit termpos values in the glass backend in an upwardly compatible way. Few people will actually want to index documents more than 4 billion words long, but the extra numbering space can be helpful if you want to use term positions in "interesting" ways. + Hook up configure --disable-sse/--enable-sse=sse options for MSVC. + Fix configure probes for builtin functions for clang. We need to specify the argument types for each builtin since otherwise AC_CHECK_DECLS tries to compile code which just tries to take a pointer to the builtin function causing clang to give an error saying that's not allowed. If the argument types are specified then AC_CHECK_DECLS tries to compile a call to the builtin function instead. * documentation: + Fix documentation comment typo. * tools: + xapian-delve: Test for all docs empty using get_total_length() which is slightly simpler internally than get_avlength(), and avoids an exact floating point equality check. * examples: + quest: Support --weight=coord. + xapian-pos: New tool to show term position info to help debugging when using positional information in more complex ways. * portability: + Fix undefined behaviour from C++ ODR violation due to using the same name two different non-static inline functions. It seems that with current GCC versions the desired function always ends up being used, but with current clang the other function is sometimes used, resulting in database corruption when using value slots in docid 16384 or higher with the default glass backend. Patch from Germán M. Bravo. + Suppress alignment cast warning on sparc Linux. The pointer being cast is to a record returned by getdirentries(), so it should be suitable aligned. + Drop special handling for Compaq C++. We never actually achieved a working build using it, and I can find no evidence that this compiler still exists, let alone that it was updated for C++11 which we now require. + Create new database directories in race-free way. + Avoid throwing and handling an exception in replace_document() when adding a document with a specified docid which is <= last_docid but currently unused. + Use our portable code for handling UUIDs on all platforms, and only use platform-specific code for generating a new UUID. This fixes a bug with converting UUIDs to and from string representation on FreeBSD, NetBSD and OpenBSD on little-endian platforms which resulted in reversed byte order in the first three components, so the same database would report a different UUID on these platforms compared to other platforms. With this fix, the UUIDs of existing databases will appear to change on these platforms (except in rare "palindronic" cases). Reported by Germán M. Bravo. + Fix to build with a C++17 compiler. Previously we used a "byte" type internally which clashed with "std::byte" in source files which use "using namespace std;". Fixes #768, reported by Laurent Stacul. + Adjust apitest testcase stubdb2 to allow for NetBSD oddity: NetBSD's getaddrinfo() in IPv4 mode seems to resolve ::1 to an IPv4 address on the local network. + Avoid timer_create() on OpenBSD and NetBSD. On OpenBSD it always fails with ENOSYS (and there's no prototype in the libc headers), while on NetBSD it seems to work, but the timer never seems to fire, so it's useless to us (see [#770]). + Use SOCK_NONBLOCK if available to avoid a call to fcntl(). It's supported by at least Linux, FreeBSD, NetBSD and OpenBSD. + Use O_NOINHERIT for O_CLOEXEC on Windows. This flag has essentially the same effect, and it's common in other codebases to do this. + On AIX O_CLOEXEC may be a 64-bit constant which won't fit in an int. To workaround this stupidity we now call the non-standard open64x() instead of open() when the flags don't fit in an int. + Add functions to add/multiply with overflow check. These are implemented with compiler builtins or equivalent where possible, so the overflow check will typically just require a check of the processor's overflow or carry flag.- Update to 1.4.7: * API: + Database::check(): Fix bogus error reports for documents with length zero due to a new check added in 1.4.6 that the doclength was between the stored upper and lower bounds, which failed to allow for the lower bound ignoring documents with length zero (since documents indexed only by boolean terms aren't involved in weighted searches). + Query: Use of Query::MatchAll in multithreaded code causes problems because the reference counting gets messed up by concurrent updates. Document that Query(string()) should be used instead of MatchAll in multithreaded code, and avoid using it in library code. * Stem: + Stemming algorithms added for Irish, Lithuanian, Nepali and Tamil. + Merge Snowball compiler changes which improve code generation. + Merge optimisations to the Arabic and Turkish stemmers. * testsuite: + Fix duplicate test in apitest closedb10 testcase. * See also https://xapian.org/docs/xapian-core-1.4.7/NEWS- Fix RPM groups. - Trim bias and redundancies from description.- Update to 1.4.6: * API classes now support C++11 move semantics when using a compiler which we are confident supports them (currently compilers which define __cplusplus >= 201103 plus a special check for MSVC 2015 or later). C++11 move semantics provide a clean and efficient way for threaded code to hand-off Xapian objects to worker threads, but in this case it's very unhelpful for availability of these semantics to vary by compiler as it quietly leads to a build with non-threadsafe behaviour. To address this, user code can #define XAPIAN_MOVE_SEMANTICS before #include to force this on, and will then get a compilation failure if the compiler lacks suitable support. * MSet::snippet(): + We were only escaping output for HTML/XML in some cases, which would potentially allow HTML to be injected into output (this fixes bnc#1099925, CVE-2018-0499). + Include certain leading non-word characters in snippets. Previously we started the snippet at the start of the first actual word, but there are various cases where including non-word characters in front of the actual word adds useful context or otherwise aids comprehension. * Add MSetIterator::get_sort_key() method. The sort key has always been available internally, but wasn't exposed via the public API before, which seems like an oversight as the collapse key has long been available. * Database::compact(): + Allow Compactor::resolve_duplicate_metadata() implementations to delete entries. Previously if an implementation returned an empty string this would result in a user meta-data entry with an empty value, which isn't normally achievable (empty meta-data values aren't stored), and so will cause odd behaviour. We now handle an empty returned value by interpreting it in the natural way - it means that the merged result is to not set a value for that key in the output database. + Since 1.3.5 compacting a WritableDatabase with uncommitted changes throws Xapian::InvalidOperationError when compacting to a single-file glass database. This release adds similar checks for chert and when compacting to a multiple-file glass database. + In the unlikely event that the total number of documents or the total length of all documents overflow when trying to compact a multi-database, we throw an exception. This is now a DatabaseError exception instead of a const char* exception (a hang-over from before this code was turned into a public API in the library). * See also https://xapian.org/docs/xapian-core-1.4.6/NEWS- Update to 1.4.5: * Add Database::get_total_length() method. Previously you had to calculate this from get_avlength() and get_doccount(), taking into account rounding issues. But even then you couldn't reliably get the exact value when total length is large since a double's mantissa has more limited precision than an unsigned long long. * Add Xapian::iterator_rewound() for bidirectional iterators, to test if the iterator is at the start (useful for testing whether we're done when iterating backwards). * DatabaseOpeningError exceptions now provide errno via get_error_string() rather than turning it into a string and including it in the exception message. * WritableDatabase::replace_document(): when passed a Document object which came from a database and has unmodified values, we used to always read those values into a memory structure. Now we only do this if the document is being replaced to the same document ID which it came from, which should make other cases a bit more efficient. * Enquire::get_eset(): When approximating term frequencies we now round to the nearest integer - previously we always rounded down. * See also https://xapian.org/docs/xapian-core-1.4.5/NEWS- Update to 1.4.4: * Database::check(): + Fix checking a single table - changes in 1.4.2 broke such checks unless you specified the table without any extension. + Errors from failing to find the file specified are now thrown as DatabaseOpeningError (was DatabaseError, of which DatabaseOpeningError is a subclass so existing code should continue to work). Also improved the error message when the file doesn't exist is better. * Drop OP_SCALE_WEIGHT over OP_VALUE_RANGE, OP_VALUE_GE and OP_VALUE_LE in the Query constructor. These operators always return weight 0 so OP_SCALE_WEIGHT over them has no effect. Eliminating it at query construction time is cheap (we only need to check the type of the subquery), eliminates the confusing "0 * " from the query description, and means the OP_SCALE_WEIGHT Query object can be released sooner. Inspired by Shivanshu Chauhan asking about the query description on IRC. * Drop OP_SCALE_WEIGHT on the right side of OP_AND_NOT in the Query constructor. OP_AND_NOT takes no weight from the right so OP_SCALE_WEIGHT has no effect there. Eliminating it at query construction time is cheap (just need to check the subquery's type), eliminates the confusing "0 * " from the query description, and means the OP_SCALE_WEIGHT object can be released sooner. * See also https://xapian.org/docs/xapian-core-1.4.4/NEWS- Update to 1.4.3: * MSet::snippet(): Favour candidate snippets which contain more of a diversity of matching terms by discounting the relevance of repeated terms using an exponential decay. A snippet which contains more terms from the query is likely to be better than one which contains the same term or terms multiple times, but a repeated term is still interesting, just less with each additional appearance. Diversity issue highlighted by Robert Stepanek's patch in https://github.com/xapian/xapian/pull/117 - testcases taken from his patch. * MSet::snippet(): New flag SNIPPET_EMPTY_WITHOUT_MATCH to get an empty snippet if there are no matches in the text passed in. Implemented by Robert Stepanek. * Round MSet::get_matches_estimated() to an appropriate number of significant figures. The algorithm used looks at the lower and upper bound and where the estimate sits between them, and then picks an appropriate number of significant figures. Thanks to Sébastien Le Callonnec for help sorting out a portability issue on OS X. * Add Database::locked() method - where possible this non-invasively checks if the database is currently open for writing, which can be useful for dashboards and other status reporting tools. * See also https://xapian.org/docs/xapian-core-1.4.3/NEWS - Update to 1.4.2: * Add XAPIAN_AT_LEAST(A,B,C) macro. * MSet::snippet(): Optimise snippet generation - it's now ~46% faster in a simple test. * Add Xapian::DOC_ASSUME_VALID flag which tells Database::get_document() that it doesn't need to check that the passed docid is valid. Fixes #739, reported by Germán M. Bravo. * TfIdfWeight: Add support for the L wdf normalisation. Patch from Vivek Pal. * BB2Weight: Fix weights when database has just one document. Our existing attempt to clamp N to be at least 2 was ineffective due to computing N - 2 < 0 in an unsigned type. * DPHWeight: Fix reversed sign in quadratic formula, making the upper bound a tiny amount higher. * DLHWeight: Correct upper bound which was a bit too low, due to flawed logic in its derivation. The new bound is slightly less tight (by a few percent). * DLHWeight,DPHWeight: Avoid calculating log(0) when wdf is equal to the document length. * TermGenerator: Handle stemmer returning empty string - the Arabic stemmer can currently do this (e.g. for a single tatweel) and user stemmers can too. Fixes #741, reported by Emmanuel Engelhart. * Database::check(): Fix check that the first docid in each doclength chunk is more than the last docid in the previous chunk - this code was in the wrong place so didn't actually work. * Database::get_unique_terms(): Clamp returned value to be <= document length. Ideally get_unique_terms() ought to only count terms with wdf > 0, but that's expensive to calculate on demand. * See also https://xapian.org/docs/xapian-core-1.4.2/NEWS- Update to 1.4.1 * Constructing a Query for a non-reference counted PostingSource object will now try to clone the PostingSource object (as happened in 1.3.4 and earlier). This clone code was removed as part of the changes in 1.3.5 to support optional reference counting of PostingSource objects, but that breaks the case when the PostingSource object is on the stack and goes out of scope before the Query object is used. Issue reported by Till Schäfer and analysed by Daniel Vrátil in a bug report against Akonadi: https://bugs.kde.org/show_bug.cgi?id=363741 * Add BM25PlusWeight class implementing the BM25+ weighting scheme, implemented by Vivek Pal (https://github.com/xapian/xapian/pull/104). * Add PL2PlusWeight class implementing the PL2+ weighting scheme, implemented by Vivek Pal (https://github.com/xapian/xapian/pull/108). * LMWeight: Implement Dir+ weighting scheme as DIRICHLET_PLUS_SMOOTHING. Patch from Vivek Pal. * Add CoordWeight class implementing coordinate matching. This can be useful for specialised uses - e.g. to implement sorting by the number of matching filters. * DLHWeight,DPHWeight,PL2Weight: With these weighting schemes, the formulae can give a negative weight contribution for a term in extreme cases. We used to try to handle this by calculating a per-term lower bound on the contribution and subtracting this from the contribution, but this idea is fundamentally flawed as the total offset it adds to a document depends on what combination of terms that document matches, meaning in general the offset isn't the same for every matching document. So instead we now clamp each term's weight contribution to be >= 0. * TfIdfWeight: Always scale term weight by wqf - this seems the logical approach as it matches the weighting we'd get if we weighted every non-unique term in the query, as well as being explicit in the Piv+ formula. * Fix OP_SCALE_WEIGHT to work with all weighting schemes - previously it was ignored when using PL2Weight and LMWeight. * PL2Weight: Greatly improve upper bound on weight: + Split the weight equation into two parts and maximise each separately as that gives an easily solvable problem, and in common cases the maximum is at the same value of wdfn for both parts. In a simple test, the upper bounds are now just over double the highest weight actually achieved - previously they were several hundred times. This approach was suggested by Aarsh Shah in: https://github.com/xapian/xapian/pull/48 + Improve upper bound on normalised wdf (wdfn) - when wdf_upper_bound > doclength_lower_bound, we get a tighter bound by evaluating at wdf=wdf_upper_bound. In a simple test, this reduces the upper bound on wdfn by 36-64%, and the upper bound on the weight by 9-33%. * PL2Weight: Fix calculation of upper_bound when P2>0. P2 is typically negative, but for a very common term it can be positive and then we should use wdfn_lower not wdfn_upper to adjust P_max. * Weight::unserialise(): Check serialised form is empty when unserialising parameter-free schemes BoolWeight, DLHWeight and DPHWeight. * TermGenerator::set_stopper_strategy(): New method to control how the Stopper object is used. Patch from Arnav Jain. * QueryParser: Fix handling of CJK query over multiple prefixes. Previously all the n-gram terms were AND-ed together - now we AND together for each prefix, then OR the results. Fixes #719, reported by Aaron Li. * Add Database::get_revision() method which provides access to the database revision number for chert and glass, intended for use by xapiand. Marked as experimental, so we don't have to go through the usual deprecation cycle if this proves not to be the approach we want to take. Fixes #709, reported by German M. Bravo. * Mark RangeProcessor constructor as `explicit`. * See also https://xapian.org/docs/xapian-core-1.4.1/NEWS - A compiler with support for C++11 is required, so specify BuildRequires gcc-c++ >= 4.6- Update to 1.4.0 * API + Update to Unicode 9.0.0 + Reimplement ESet and ESetIterator + MSetIterator and ESetIterator are now STL-compatible random_access_iterators * See also http://xapian.org/docs/xapian-core-1.4.0/NEWS- Update to 1.2.23 * API + PostingSource: Public member variables are now wrapped by methods * chert backend + xapian-check now performs additional consistency checks for chert. * omega + Fix HTML/XML entity decoding to be O(n) not O(n²) - indexing HTML/XML with a lot of entities is now much faster.- Update to 1.2.21 * API: + QueryParser: Extend the set of characters allowed in the start of a range to be anything except for '(' and characters <= ' '. * matcher: + Reimplement OP_PHRASE for non-exact phrases. + Reimplement OP_NEAR - the new implementation consistently requires the terms to occur at different positions, and fixes some previously missed matches. + Fix a reversed check for picking the shorter position list for an exact phrase of two terms. + When matching an exact phrase, if a term doesn't occur where we want, use its actual position to advance the anchor term, rather than just checking the next position of the anchor term. * brass backend: + Fix cursor versioning to consider cancel() and reopen() as events where the cursor version may need incrementing, and flag the current cursor version as used when a cursor is rebuilt. + Avoid using file descriptions < 3 for writable database tables, as it risks corruption if some code in the same process tries to write to stdout or stderr without realising it is closed. * chert backend: + Fix cursor versioning to consider cancel() and reopen() as events where the cursor version may need incrementing, and flag the current cursor version as used when a cursor is rebuilt. + Avoid using file descriptions < 3 for writable database tables, as it risks corruption if some code in the same process tries to write to stdout or stderr without realising it is closed. * flint backend: + Fix cursor versioning to consider cancel() and reopen() as events where the cursor version may need incrementing, and flag the current cursor version as used when a cursor is rebuilt. * remote backend: + Fix sort by value when multiple databases are in use and one or more are remote. * build system: + The compiler ABI check in the public API headers now issues a warning (instead of an error) for an ABI mismatch for ABI versions 2 and later (which means GCC >= 3.4). + xapian-config,xapian-core.pc: When compiling with xlC on AIX, the reported --cxxflags/--cflags now include -D_LARGE_FILES=1 as this is defined for the library, and defining it changes the ABI of std::string with this compiler, so it must also be defined when building code using the Xapian API. + xapian-core.pc: Include --enable-runtime-pseudo-reloc in --libs output for mingw and cygwin, like xapian-config does. + xapian-core.pc: Fix include directory reported by `pkg-config --cflags`. + xapian-config: Fix typo so cached result of test in is_uninstalled() is actually used on subsequent calls. + configure: Changes in 1.2.19 broke the custom macro we use to probe for supported compiler flags such that the flags never got used. + configure: Set default value for AUTOM4TE before AC_OUTPUT so the default will actually get used. + soaktest: Link with libtool's '-no-install' or '-no-fast-install', like we already do for other test programs, which means that libtool doesn't need to generate shell script wrappers for them on most platforms. * documentation: + API documentation: Minor wording tweaks and formatting improvements. + docs/deprecation.rst: Add deprecation of omindex --preserve-nonduplicates which happened in 1.2.4. + HACKING: libtool 2.4.6 is now used for bootstrapping snapshots and releases. * tools: + xapian-compact: Make sure we open all the tables of input databases at the same revision. + xapian-metadata: Add 'list' subcommand to list all the metadata keys. + xapian-replicate: Fix connection timeout to be 10 seconds rather than 10000 seconds (the incorrect timeout has been the case since 1.2.3). + xapian-replicate: Set SO_KEEPALIVE for xapian-replicate's connection to the master, and add command line option to allow setting socket-level timeouts (SO_RCVTIMEO and SO_SNDTIMEO) on platforms that support them. + xapian-replicate-server: Avoid potentially reading uninitialised data if a changeset file is truncated. * portability: + Add spaces between literal strings and macros which expand to literal strings for C++11 compatibility. + ValueCountMatchSpy::top_values_begin(): Fix the comparison function not to return true for two equal elements, which manifests as incorrect sorting in some cases when using clang's libc++ (which recent OS X versions do). + apitest: The adddoc5 testcase fails under clang due to an exception handling bug, so just #ifdef out the problematic part of the testcase when building with clang for now. + configure: Improve the probe for whether the test harness can use RTTI to work for IBM's xlC compiler (which defaults to not generating RTTI). + Use F_DUPFD where available to dup to a file descriptor which is >= 2, rather than calling dup() until we get one. + When unserialising a double, avoid reading one byte past the end of the serialised value. + When unserialising a double, add missing cast to unsigned char when we check if the value will fit in the double type. + Fix incorrect use of "delete" which should be "delete []". This is undefined behaviour in C++, though the type is POD, so in practice this probably worked OK on many platforms. - Drop patch 0001-backends-chert-chert_cursor.cc-backends-chert-chert_.patch due to upstream inclusion- Add 0001-backends-chert-chert_cursor.cc-backends-chert-chert_.patch from upstream (kde#341990, http://trac.xapian.org/ticket/675)- Update to 1.2.20 * chert backend + After splitting a block, we always insert the new block in the parent right after the block it was split from - there's no need to binary chop. * build system + Generate and install a file for pkg-config. + configure: Update link to cygwin FAQ in error message. * tools + xapian-check: For chert and brass, cross-check the position and postlist tables to detect positional data for non-existent documents. * portability + When locking a database for writing, use F_OFD_SETLK where available, which avoids having to fork() a child process to hold the lock. This currently requires Linux kernel >= 3.15, but it has been submitted to POSIX so hopefully will be widely supported eventually. Thanks to Austin Clements for pointing out this now exists. + Fix detection of fdatasync(), which appears to have been broken practically forever - this means we've probably been using fsync() instead, which probably isn't a big additional overhead. Thanks to Vlad Shablinsky for helping with Mac OS X portability of this fix. + configure: Define MINGW_HAS_SECURE_API under mingw to get _putenv_s() declared in stdlib.h. + Use POSIX O_NONBLOCK in preference to O_NDELAY - the semantics of the latter differ between BSD and System V. + According to POSIX, strerror() may not be thread safe, so use alternative thread-safe ways to translate errno values where possible. + On Microsoft Windows, avoid defining EADDRINUSE, etc if they're already defined, and use WSAE* constants un-negated - they start from a high value so won't collide with E* constants.- Tiny spec file cleanups - Add gpg signature- Update to 1.2.19 - API: * Xapian::BM5Weight: + Improve BM25 upper bound in the case when our wdf upper bound > our document length lower bound. + Pre-multiply termweight by (param_k1 + 1) rather than doing it for every weighted term in every document considered. - testsuite: * Don't report apparent leaks of fds opened on /dev/urandom - matcher: * Fix false matches reported for non-exact phrases in some cases. - build system: * For Sun's C++ compiler, pass -library=Crun separately since libtool looks for " -library=stlport4 " (with the spaces). * Remove .replicatmp (created by the test suite) upon "make clean". - documentation: * include/xapian/compactor.h: Fix formatting of doxygen comment. * HACKING: freecode no longer accepts updates, so drop that item from the release checklist. * docs/overview.rst: Add missing database path to example of using xapian-progsrv in a stub database file. - portability: * Suppress unused typedef warnings from debugging logging macros, which occur in functions which always exit via throwing an exception when compiling with recent versions of GCC or clang. * Fix debug logging code to compile with clang.ibs-power9-13 1659417462  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~1.4.17-150300.3.2.11.4.17-150300.3.2.1admin_notes.htmlapidochtmlannotated.htmlbc_s.pngbdwn.pngclassXapian_1_1AssertionError-members.htmlclassXapian_1_1AssertionError.htmlclassXapian_1_1AssertionError__inherit__graph.pngclassXapian_1_1BB2Weight-members.htmlclassXapian_1_1BB2Weight.htmlclassXapian_1_1BB2Weight__inherit__graph.pngclassXapian_1_1BM25PlusWeight-members.htmlclassXapian_1_1BM25PlusWeight.htmlclassXapian_1_1BM25PlusWeight__inherit__graph.pngclassXapian_1_1BM25Weight-members.htmlclassXapian_1_1BM25Weight.htmlclassXapian_1_1BM25Weight__inherit__graph.pngclassXapian_1_1BoolWeight-members.htmlclassXapian_1_1BoolWeight.htmlclassXapian_1_1BoolWeight__inherit__graph.pngclassXapian_1_1Compactor-members.htmlclassXapian_1_1Compactor.htmlclassXapian_1_1CoordWeight-members.htmlclassXapian_1_1CoordWeight.htmlclassXapian_1_1CoordWeight__inherit__graph.pngclassXapian_1_1DLHWeight-members.htmlclassXapian_1_1DLHWeight.htmlclassXapian_1_1DLHWeight__inherit__graph.pngclassXapian_1_1DPHWeight-members.htmlclassXapian_1_1DPHWeight.htmlclassXapian_1_1DPHWeight__inherit__graph.pngclassXapian_1_1Database-members.htmlclassXapian_1_1Database.htmlclassXapian_1_1DatabaseClosedError-members.htmlclassXapian_1_1DatabaseClosedError.htmlclassXapian_1_1DatabaseClosedError__inherit__graph.pngclassXapian_1_1DatabaseCorruptError-members.htmlclassXapian_1_1DatabaseCorruptError.htmlclassXapian_1_1DatabaseCorruptError__inherit__graph.pngclassXapian_1_1DatabaseCreateError-members.htmlclassXapian_1_1DatabaseCreateError.htmlclassXapian_1_1DatabaseCreateError__inherit__graph.pngclassXapian_1_1DatabaseError-members.htmlclassXapian_1_1DatabaseError.htmlclassXapian_1_1DatabaseError__inherit__graph.pngclassXapian_1_1DatabaseLockError-members.htmlclassXapian_1_1DatabaseLockError.htmlclassXapian_1_1DatabaseLockError__inherit__graph.pngclassXapian_1_1DatabaseModifiedError-members.htmlclassXapian_1_1DatabaseModifiedError.htmlclassXapian_1_1DatabaseModifiedError__inherit__graph.pngclassXapian_1_1DatabaseNotFoundError-members.htmlclassXapian_1_1DatabaseNotFoundError.htmlclassXapian_1_1DatabaseNotFoundError__inherit__graph.pngclassXapian_1_1DatabaseOpeningError-members.htmlclassXapian_1_1DatabaseOpeningError.htmlclassXapian_1_1DatabaseOpeningError__inherit__graph.pngclassXapian_1_1DatabaseVersionError-members.htmlclassXapian_1_1DatabaseVersionError.htmlclassXapian_1_1DatabaseVersionError__inherit__graph.pngclassXapian_1_1Database__inherit__graph.pngclassXapian_1_1DateRangeProcessor-members.htmlclassXapian_1_1DateRangeProcessor.htmlclassXapian_1_1DateRangeProcessor__inherit__graph.pngclassXapian_1_1DateValueRangeProcessor-members.htmlclassXapian_1_1DateValueRangeProcessor.htmlclassXapian_1_1DateValueRangeProcessor__inherit__graph.pngclassXapian_1_1DecreasingValueWeightPostingSource-members.htmlclassXapian_1_1DecreasingValueWeightPostingSource.htmlclassXapian_1_1DecreasingValueWeightPostingSource__inherit__graph.pngclassXapian_1_1DocNotFoundError-members.htmlclassXapian_1_1DocNotFoundError.htmlclassXapian_1_1DocNotFoundError__inherit__graph.pngclassXapian_1_1Document-members.htmlclassXapian_1_1Document.htmlclassXapian_1_1ESet-members.htmlclassXapian_1_1ESet.htmlclassXapian_1_1ESetIterator-members.htmlclassXapian_1_1ESetIterator.htmlclassXapian_1_1Enquire-members.htmlclassXapian_1_1Enquire.htmlclassXapian_1_1Error-members.htmlclassXapian_1_1Error.htmlclassXapian_1_1ErrorHandler-members.htmlclassXapian_1_1ErrorHandler.htmlclassXapian_1_1ErrorHandler__inherit__graph.pngclassXapian_1_1Error__inherit__graph.pngclassXapian_1_1ExpandDecider-members.htmlclassXapian_1_1ExpandDecider.htmlclassXapian_1_1ExpandDeciderAnd-members.htmlclassXapian_1_1ExpandDeciderAnd.htmlclassXapian_1_1ExpandDeciderAnd__inherit__graph.pngclassXapian_1_1ExpandDeciderFilterPrefix-members.htmlclassXapian_1_1ExpandDeciderFilterPrefix.htmlclassXapian_1_1ExpandDeciderFilterPrefix__inherit__graph.pngclassXapian_1_1ExpandDeciderFilterTerms-members.htmlclassXapian_1_1ExpandDeciderFilterTerms.htmlclassXapian_1_1ExpandDeciderFilterTerms__inherit__graph.pngclassXapian_1_1ExpandDecider__inherit__graph.pngclassXapian_1_1FeatureUnavailableError-members.htmlclassXapian_1_1FeatureUnavailableError.htmlclassXapian_1_1FeatureUnavailableError__inherit__graph.pngclassXapian_1_1FieldProcessor-members.htmlclassXapian_1_1FieldProcessor.htmlclassXapian_1_1FieldProcessor__inherit__graph.pngclassXapian_1_1FixedWeightPostingSource-members.htmlclassXapian_1_1FixedWeightPostingSource.htmlclassXapian_1_1FixedWeightPostingSource__inherit__graph.pngclassXapian_1_1GreatCircleMetric-members.htmlclassXapian_1_1GreatCircleMetric.htmlclassXapian_1_1GreatCircleMetric__inherit__graph.pngclassXapian_1_1IfB2Weight-members.htmlclassXapian_1_1IfB2Weight.htmlclassXapian_1_1IfB2Weight__inherit__graph.pngclassXapian_1_1InL2Weight-members.htmlclassXapian_1_1InL2Weight.htmlclassXapian_1_1InL2Weight__inherit__graph.pngclassXapian_1_1IneB2Weight-members.htmlclassXapian_1_1IneB2Weight.htmlclassXapian_1_1IneB2Weight__inherit__graph.pngclassXapian_1_1InternalError-members.htmlclassXapian_1_1InternalError.htmlclassXapian_1_1InternalError__inherit__graph.pngclassXapian_1_1InvalidArgumentError-members.htmlclassXapian_1_1InvalidArgumentError.htmlclassXapian_1_1InvalidArgumentError__inherit__graph.pngclassXapian_1_1InvalidOperationError-members.htmlclassXapian_1_1InvalidOperationError.htmlclassXapian_1_1InvalidOperationError__inherit__graph.pngclassXapian_1_1KeyMaker-members.htmlclassXapian_1_1KeyMaker.htmlclassXapian_1_1KeyMaker__inherit__graph.pngclassXapian_1_1LMWeight-members.htmlclassXapian_1_1LMWeight.htmlclassXapian_1_1LMWeight__inherit__graph.pngclassXapian_1_1LatLongCoords-members.htmlclassXapian_1_1LatLongCoords.htmlclassXapian_1_1LatLongCoordsIterator-members.htmlclassXapian_1_1LatLongCoordsIterator.htmlclassXapian_1_1LatLongDistanceKeyMaker-members.htmlclassXapian_1_1LatLongDistanceKeyMaker.htmlclassXapian_1_1LatLongDistanceKeyMaker__inherit__graph.pngclassXapian_1_1LatLongDistancePostingSource-members.htmlclassXapian_1_1LatLongDistancePostingSource.htmlclassXapian_1_1LatLongDistancePostingSource__inherit__graph.pngclassXapian_1_1LatLongMetric-members.htmlclassXapian_1_1LatLongMetric.htmlclassXapian_1_1LatLongMetric__inherit__graph.pngclassXapian_1_1LogicError-members.htmlclassXapian_1_1LogicError.htmlclassXapian_1_1LogicError__inherit__graph.pngclassXapian_1_1MSet-members.htmlclassXapian_1_1MSet.htmlclassXapian_1_1MSetIterator-members.htmlclassXapian_1_1MSetIterator.htmlclassXapian_1_1MatchDecider-members.htmlclassXapian_1_1MatchDecider.htmlclassXapian_1_1MatchDecider__inherit__graph.pngclassXapian_1_1MatchSpy-members.htmlclassXapian_1_1MatchSpy.htmlclassXapian_1_1MatchSpy__inherit__graph.pngclassXapian_1_1MultiValueKeyMaker-members.htmlclassXapian_1_1MultiValueKeyMaker.htmlclassXapian_1_1MultiValueKeyMaker__inherit__graph.pngclassXapian_1_1NetworkError-members.htmlclassXapian_1_1NetworkError.htmlclassXapian_1_1NetworkError__inherit__graph.pngclassXapian_1_1NetworkTimeoutError-members.htmlclassXapian_1_1NetworkTimeoutError.htmlclassXapian_1_1NetworkTimeoutError__inherit__graph.pngclassXapian_1_1NumberRangeProcessor-members.htmlclassXapian_1_1NumberRangeProcessor.htmlclassXapian_1_1NumberRangeProcessor__inherit__graph.pngclassXapian_1_1NumberValueRangeProcessor-members.htmlclassXapian_1_1NumberValueRangeProcessor.htmlclassXapian_1_1NumberValueRangeProcessor__inherit__graph.pngclassXapian_1_1PL2PlusWeight-members.htmlclassXapian_1_1PL2PlusWeight.htmlclassXapian_1_1PL2PlusWeight__inherit__graph.pngclassXapian_1_1PL2Weight-members.htmlclassXapian_1_1PL2Weight.htmlclassXapian_1_1PL2Weight__inherit__graph.pngclassXapian_1_1PositionIterator-members.htmlclassXapian_1_1PositionIterator.htmlclassXapian_1_1PostingIterator-members.htmlclassXapian_1_1PostingIterator.htmlclassXapian_1_1PostingSource-members.htmlclassXapian_1_1PostingSource.htmlclassXapian_1_1PostingSource__inherit__graph.pngclassXapian_1_1Query-members.htmlclassXapian_1_1Query.htmlclassXapian_1_1QueryParser-members.htmlclassXapian_1_1QueryParser.htmlclassXapian_1_1QueryParserError-members.htmlclassXapian_1_1QueryParserError.htmlclassXapian_1_1QueryParserError__inherit__graph.pngclassXapian_1_1RSet-members.htmlclassXapian_1_1RSet.htmlclassXapian_1_1RangeError-members.htmlclassXapian_1_1RangeError.htmlclassXapian_1_1RangeError__inherit__graph.pngclassXapian_1_1RangeProcessor-members.htmlclassXapian_1_1RangeProcessor.htmlclassXapian_1_1RangeProcessor__inherit__graph.pngclassXapian_1_1Registry-members.htmlclassXapian_1_1Registry.htmlclassXapian_1_1RuntimeError-members.htmlclassXapian_1_1RuntimeError.htmlclassXapian_1_1RuntimeError__inherit__graph.pngclassXapian_1_1SerialisationError-members.htmlclassXapian_1_1SerialisationError.htmlclassXapian_1_1SerialisationError__inherit__graph.pngclassXapian_1_1SimpleStopper-members.htmlclassXapian_1_1SimpleStopper.htmlclassXapian_1_1SimpleStopper__inherit__graph.pngclassXapian_1_1Stem-members.htmlclassXapian_1_1Stem.htmlclassXapian_1_1StemImplementation-members.htmlclassXapian_1_1StemImplementation.htmlclassXapian_1_1StemImplementation__inherit__graph.pngclassXapian_1_1Stopper-members.htmlclassXapian_1_1Stopper.htmlclassXapian_1_1Stopper__inherit__graph.pngclassXapian_1_1StringValueRangeProcessor-members.htmlclassXapian_1_1StringValueRangeProcessor.htmlclassXapian_1_1StringValueRangeProcessor__inherit__graph.pngclassXapian_1_1TermGenerator-members.htmlclassXapian_1_1TermGenerator.htmlclassXapian_1_1TermIterator-members.htmlclassXapian_1_1TermIterator.htmlclassXapian_1_1TfIdfWeight-members.htmlclassXapian_1_1TfIdfWeight.htmlclassXapian_1_1TfIdfWeight__inherit__graph.pngclassXapian_1_1TradWeight-members.htmlclassXapian_1_1TradWeight.htmlclassXapian_1_1TradWeight__inherit__graph.pngclassXapian_1_1UnimplementedError-members.htmlclassXapian_1_1UnimplementedError.htmlclassXapian_1_1UnimplementedError__inherit__graph.pngclassXapian_1_1Utf8Iterator-members.htmlclassXapian_1_1Utf8Iterator.htmlclassXapian_1_1ValueCountMatchSpy-members.htmlclassXapian_1_1ValueCountMatchSpy.htmlclassXapian_1_1ValueCountMatchSpy__inherit__graph.pngclassXapian_1_1ValueIterator-members.htmlclassXapian_1_1ValueIterator.htmlclassXapian_1_1ValueMapPostingSource-members.htmlclassXapian_1_1ValueMapPostingSource.htmlclassXapian_1_1ValueMapPostingSource__inherit__graph.pngclassXapian_1_1ValuePostingSource-members.htmlclassXapian_1_1ValuePostingSource.htmlclassXapian_1_1ValuePostingSource__inherit__graph.pngclassXapian_1_1ValueRangeProcessor-members.htmlclassXapian_1_1ValueRangeProcessor.htmlclassXapian_1_1ValueRangeProcessor__inherit__graph.pngclassXapian_1_1ValueSetMatchDecider-members.htmlclassXapian_1_1ValueSetMatchDecider.htmlclassXapian_1_1ValueSetMatchDecider__inherit__graph.pngclassXapian_1_1ValueWeightPostingSource-members.htmlclassXapian_1_1ValueWeightPostingSource.htmlclassXapian_1_1ValueWeightPostingSource__inherit__graph.pngclassXapian_1_1Weight-members.htmlclassXapian_1_1Weight.htmlclassXapian_1_1Weight__inherit__graph.pngclassXapian_1_1WildcardError-members.htmlclassXapian_1_1WildcardError.htmlclassXapian_1_1WildcardError__inherit__graph.pngclassXapian_1_1WritableDatabase-members.htmlclassXapian_1_1WritableDatabase.htmlclassXapian_1_1WritableDatabase__inherit__graph.pngclasses.htmlclosed.pngcompactor_8h.htmlconstants_8h.htmlconstinfo_8h.htmldatabase_8h.htmldbfactory_8h.htmldeprecated.htmldir_f63502d618711192f85ccb772536c6ae.htmldoc.pngdocument_8h.htmldoxygen.cssdoxygen.pngdynsections.jsenquire_8h.htmlerror_8h.htmlerrorhandler_8h.htmleset_8h.htmlexpanddecider_8h.htmlfiles.htmlfolderclosed.pngfolderopen.pngfunctions.htmlfunctions_b.htmlfunctions_c.htmlfunctions_d.htmlfunctions_e.htmlfunctions_enum.htmlfunctions_eval.htmlfunctions_f.htmlfunctions_func.htmlfunctions_func_b.htmlfunctions_func_c.htmlfunctions_func_d.htmlfunctions_func_e.htmlfunctions_func_f.htmlfunctions_func_g.htmlfunctions_func_h.htmlfunctions_func_i.htmlfunctions_func_k.htmlfunctions_func_l.htmlfunctions_func_m.htmlfunctions_func_n.htmlfunctions_func_o.htmlfunctions_func_p.htmlfunctions_func_q.htmlfunctions_func_r.htmlfunctions_func_s.htmlfunctions_func_t.htmlfunctions_func_u.htmlfunctions_func_v.htmlfunctions_func_w.htmlfunctions_func_~.htmlfunctions_g.htmlfunctions_h.htmlfunctions_i.htmlfunctions_k.htmlfunctions_l.htmlfunctions_m.htmlfunctions_n.htmlfunctions_o.htmlfunctions_p.htmlfunctions_q.htmlfunctions_r.htmlfunctions_s.htmlfunctions_t.htmlfunctions_type.htmlfunctions_u.htmlfunctions_v.htmlfunctions_vars.htmlfunctions_w.htmlfunctions_~.htmlgeospatial_8h.htmlglobals.htmlglobals_defs.htmlgraph_legend.htmlgraph_legend.pnghierarchy.htmlindex.htmlinherit_graph_0.pnginherit_graph_1.pnginherit_graph_10.pnginherit_graph_11.pnginherit_graph_12.pnginherit_graph_13.pnginherit_graph_14.pnginherit_graph_15.pnginherit_graph_16.pnginherit_graph_17.pnginherit_graph_18.pnginherit_graph_19.pnginherit_graph_2.pnginherit_graph_20.pnginherit_graph_21.pnginherit_graph_22.pnginherit_graph_23.pnginherit_graph_24.pnginherit_graph_25.pnginherit_graph_26.pnginherit_graph_27.pnginherit_graph_3.pnginherit_graph_4.pnginherit_graph_5.pnginherit_graph_6.pnginherit_graph_7.pnginherit_graph_8.pnginherit_graph_9.pnginherits.htmljquery.jskeymaker_8h.htmlmatchspy_8h.htmlmenu.jsmenudata.jsmset_8h.htmlnamespaceXapian.htmlnamespaceXapian_1_1Auto.htmlnamespaceXapian_1_1Chert.htmlnamespaceXapian_1_1InMemory.htmlnamespaceXapian_1_1Remote.htmlnamespaceXapian_1_1Unicode.htmlnamespacemembers.htmlnamespacemembers_enum.htmlnamespacemembers_eval.htmlnamespacemembers_func.htmlnamespacemembers_type.htmlnamespacemembers_vars.htmlnamespaces.htmlnav_f.pngnav_g.pngnav_h.pngopen.pngpages.htmlpositioniterator_8h.htmlpostingiterator_8h.htmlpostingsource_8h.htmlquery_8h.htmlqueryparser_8h.htmlregistry_8h.htmlsplitbar.pngstem_8h.htmlstructXapian_1_1LatLongCoord-members.htmlstructXapian_1_1LatLongCoord.htmlsync_off.pngsync_on.pngtab_a.pngtab_b.pngtab_h.pngtab_s.pngtabs.csstermgenerator_8h.htmltermiterator_8h.htmltypes_8h.htmlunicode_8h.htmlvalueiterator_8h.htmlvaluesetmatchdecider_8h.htmlversion_8h.htmlweight_8h.htmlxapian_8h.htmlbm25.htmlcollapsing.htmldeprecation.htmlfacets.htmlgeospatial.htmlglossary.htmlindex.htmlinstall.htmlinternals.htmlintro_ir.htmlmatcherdesign.htmloverview.htmlpostingsource.htmlqueryparser.htmlremote.htmlreplication.htmlscalability.htmlserialisation.htmlsorting.htmlspelling.htmlstemming.htmlsynonyms.htmltermgenerator.htmltests.htmlvalueranges.html/usr/share/doc/packages/xapian-core//usr/share/doc/packages/xapian-core/apidoc//usr/share/doc/packages/xapian-core/apidoc/html/-fmessage-length=0 -grecord-gcc-switches -O2 -Wall -D_FORTIFY_SOURCE=2 -fstack-protector-strong -funwind-tables -fasynchronous-unwind-tables -fstack-clash-protection -gobs://build.suse.de/SUSE:Maintenance:25213/SUSE_SLE-15-SP3_Update/99a114bc245a4670e6438eac4840f3fa-xapian-core.SUSE_SLE-15-SP3_Updatedrpmxz5ppc64le-suse-linux       !"!#  $%&'()*#+,%-../01234$5647879  %:39,;<=>?@?>>ABCDEFGHIJKLMNOPQRLST;UVWXYJZ?[\]=^__````abcbddXML 1.0 document, ASCII textdirectoryHTML document, ASCII text, with very long linesPNG image data, 8 x 30, 8-bit/color RGBA, non-interlacedPNG image data, 7 x 8, 8-bit/color RGBA, non-interlacedPNG image data, 177 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 157 x 112, 8-bit/color RGB, non-interlacedHTML document, UTF-8 Unicode text, with very long linesPNG image data, 196 x 112, 8-bit/color RGB, non-interlacedPNG image data, 169 x 112, 8-bit/color RGB, non-interlacedPNG image data, 161 x 112, 8-bit/color RGB, non-interlacedPNG image data, 159 x 112, 8-bit/color RGBA, non-interlacedPNG image data, 160 x 112, 8-bit/color RGB, non-interlacedPNG image data, 223 x 261, 8-bit/color RGBA, non-interlacedPNG image data, 227 x 261, 8-bit/color RGBA, non-interlacedPNG image data, 221 x 261, 8-bit/color RGB, non-interlacedPNG image data, 1079 x 336, 8-bit/color RGBA, non-interlacedPNG image data, 209 x 261, 8-bit/color RGB, non-interlacedPNG image data, 205 x 276, 8-bit/color RGB, non-interlacedPNG image data, 233 x 351, 8-bit/color RGBA, non-interlacedPNG image data, 451 x 351, 8-bit/color RGBA, non-interlacedPNG image data, 233 x 336, 8-bit/color RGB, non-interlacedPNG image data, 203 x 112, 8-bit/color RGBA, non-interlacedPNG image data, 221 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 257 x 276, 8-bit/color RGB, non-interlacedPNG image data, 241 x 365, 8-bit/color RGB, non-interlacedPNG image data, 204 x 187, 8-bit/color RGBA, non-interlacedHTML document, ASCII textPNG image data, 168 x 112, 8-bit/color RGB, non-interlacedPNG image data, 1125 x 677, 8-bit/color RGB, non-interlacedPNG image data, 209 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 216 x 201, 8-bit/color RGB, non-interlacedPNG image data, 631 x 169, 8-bit/color RGBA, non-interlacedPNG image data, 213 x 201, 8-bit/color RGB, non-interlacedPNG image data, 179 x 127, 8-bit/color RGBA, non-interlacedPNG image data, 200 x 112, 8-bit/color RGB, non-interlacedPNG image data, 172 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 225 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 193 x 201, 8-bit/color RGB, non-interlacedPNG image data, 451 x 201, 8-bit/color RGBA, non-interlacedPNG image data, 151 x 112, 8-bit/color RGBA, non-interlacedPNG image data, 217 x 201, 8-bit/color RGB, non-interlacedPNG image data, 241 x 276, 8-bit/color RGB, non-interlacedPNG image data, 568 x 205, 8-bit/color RGB, non-interlacedPNG image data, 233 x 112, 8-bit/color RGB, non-interlacedPNG image data, 220 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 225 x 261, 8-bit/color RGB, non-interlacedPNG image data, 241 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 227 x 291, 8-bit/color RGBA, non-interlacedPNG image data, 181 x 112, 8-bit/color RGB, non-interlacedPNG image data, 155 x 112, 8-bit/color RGBA, non-interlacedPNG image data, 1181 x 169, 8-bit/color RGB, non-interlacedPNG image data, 197 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 477 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 1113 x 585, 8-bit/color RGB, non-interlacedPNG image data, 181 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 224 x 112, 8-bit/color RGB, non-interlacedPNG image data, 487 x 291, 8-bit/color RGBA, non-interlacedPNG image data, 243 x 261, 8-bit/color RGBA, non-interlacedPNG image data, 365 x 747, 8-bit/color RGBA, non-interlacedPNG image data, 173 x 187, 8-bit/color RGBA, non-interlacedPNG image data, 9 x 9, 8-bit/color RGBA, non-interlacedPNG image data, 24 x 22, 8-bit/color RGBA, non-interlacedASCII textPNG image data, 104 x 31, 8-bit/color RGBA, non-interlacedPNG image data, 725 x 212, 8-bit/color RGBA, non-interlacedPNG image data, 157 x 37, 8-bit grayscale, non-interlacedPNG image data, 388 x 37, 8-bit/color RGB, non-interlacedPNG image data, 229 x 37, 8-bit grayscale, non-interlacedPNG image data, 415 x 37, 8-bit/color RGBA, non-interlacedPNG image data, 447 x 37, 8-bit/color RGBA, non-interlacedPNG image data, 119 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 167 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 185 x 37, 8-bit grayscale, non-interlacedPNG image data, 181 x 37, 8-bit grayscale, non-interlacedPNG image data, 125 x 37, 8-bit grayscale, non-interlacedPNG image data, 165 x 37, 8-bit grayscale, non-interlacedPNG image data, 140 x 37, 8-bit grayscale, non-interlacedPNG image data, 153 x 37, 8-bit grayscale, non-interlacedPNG image data, 116 x 37, 8-bit grayscale, non-interlacedPNG image data, 120 x 37, 8-bit grayscale, non-interlacedPNG image data, 389 x 37, 8-bit/color RGB, non-interlacedPNG image data, 183 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 161 x 37, 8-bit grayscale, non-interlacedPNG image data, 171 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 135 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 1272 x 701, 8-bit/color RGBA, non-interlacedPNG image data, 115 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 163 x 37, 8-bit gray+alpha, non-interlacedPNG image data, 175 x 37, 8-bit gray+alpha, non-interlacedUTF-8 Unicode text, with very long linesPNG image data, 1 x 56, 8-bit/color RGB, non-interlacedPNG image data, 1 x 6, 8-bit gray+alpha, non-interlacedPNG image data, 1 x 12, 8-bit/color RGB, non-interlacedPNG image data, 6 x 1024, 8-bit/color RGB, non-interlacedPNG image data, 24 x 24, 8-bit/color RGBA, non-interlacedPNG image data, 1 x 36, 8-bit/color RGB, non-interlacedASCII text, with very long linesXML 1.0 document, UTF-8 Unicode text, with very long linesXML 1.0 document, ASCII text, with very long linesXML 1.0 document, UTF-8 Unicode text0ypw2P:Lutf-82e877d675b7f24ede65812c0825b25cf2224e60da63436c71eb9425490982712?P7zXZ !t/Z W]"k%{o_.ە{[Q~L5Xo(Ԡ=H^_6i:)'‰.oh\uҨd֐.7?wNX-3nӮэ}v+`bU(N  i;vYNG+Ȅ.(<$V| RC$ ~Ï|퇃^Zfq-_H]:'Le>̅npr-o:58sWd[.MTBOR]E*NpQ3 -Jhz *q\8ڒ]߂g;;<8Ia^QӵKMIHZ*bᨪ>HkFEb莋(峮{>s46*`,&ܺx@P2 ,|D%LVP t' wMJ6 AՕV$uz@cr*2m ~]CD4a+a&mc'~^?4xfjk63ZSI " Ϛ~dzzy^5 U&FTh {#$m/{#)NzTϱqRd$jDN񊑄[ [w WtBr-/ކ j r!8ӸOrK7;U3YYeEC]Y>Z-[öuȅ rbp7l4Z+'E]4I%ysczr4L;^NTz|j r,*&,7^ ? vMFw(γzG:e *d-'q?Y( #+ _^w])\ vg!V-?>͝0]lb(鳯in}$E[]p:.Hq!U#Gûdmy1S@NB6@N T-\\T0@G6W2ė'3y27/y*ܞ#XV,0Ï3sD»y&9g¶:'[.ʎ0A3\ &!>=S1䐴FaD& [[h%Ba2byD2hz|,f3aeo)wB|˹':г>*]l%jnFvzPS>v7T l|@Spz%V'&;Ua[,S~*)lPM* W^9ئdS䟑/D_i %E88Uf<_$= 5.gʿ>EDpB g;؛I|VKYGt9%/2Wp!;&\%p>c j.8hgGaM fS4GĀn]6yH_'ҁUfv!Uv- Rx.uw_wpx%#7X[(>BV@2*EGc:ok%ga Ef?  {1m^ZM+d3P}/"]EFa.~ɬ^-p纝;d(`EX逄r4Ajkkx<&ydGG~l]c\Փ9P2h}%No:3ݩu@"Tf}G뤳LyK'hНTӽwc*5{$^9?ѿׁqN^KB"\ЬHKJvl}tF! WO~fseMlO qC:.cUq3v[ /whѺ&XLֵFGYơsv=6//I]u^)&wʯ#K) 2 US n6sK4O;hJcfdXH.Ur q'0h.ȷ!WQUމs.zD>2~4!,Pb@; ?ll?+ 6ێSڎy&A>39z J:SkYVyE]&Te^A89lR2+Hlx^"ƪX8*ѝ|xT-09{vsu!D )HPH04^߉A~ndӍFĖٽh'Fyp! 9/D.Rªr&$Ҝw evy/͚ХN˙ G {:"P;/3;sgg}:;;4䓮VK}BxYϤ٣OƷ9Sr-Ӡi/B ғB9PjYnڐb gw B`8BX/#Tb źs:k+z떵9)Y2=4~ˌWR74t RT9P `E9TjnzwdOh`jVH) O/";xTEX 0^c>SA5=.=*\[ )RfTyn8I%tI^(zr5&߸5-̳U"|j#Fk'zPjyٴOaC3^Ū+w:P)~A%Oq <9;}(PIT-~~2/P|oOQM*O,ES) L4ؗR޵zg_I/zΟ·AOFg:M̂w;夭"Q@4 =g7Q4,U^ Yve]Z7L$V+{H o,, RHum-X_mK͉H2>~4U\-z,Tul}Z GX ҺW֫?^@2 1pa\Xhh89T]7$\:Sd8,Z0zmPLI:{ YZ