Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vY5MH-00DOES-02 for pgsql-hackers@arkaria.postgresql.org; Tue, 23 Dec 2025 16:35:38 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1vY5ME-001xf3-2c for pgsql-hackers@arkaria.postgresql.org; Tue, 23 Dec 2025 16:35:35 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1vY5ME-001xeu-1O for pgsql-hackers@lists.postgresql.org; Tue, 23 Dec 2025 16:35:35 +0000 Received: from mail-ej1-x631.google.com ([2a00:1450:4864:20::631]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.96) (envelope-from ) id 1vY5MC-002MRZ-1p for pgsql-hackers@postgresql.org; Tue, 23 Dec 2025 16:35:34 +0000 Received: by mail-ej1-x631.google.com with SMTP id a640c23a62f3a-b79d6a70fc8so879893766b.0 for ; Tue, 23 Dec 2025 08:35:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1766507731; x=1767112531; darn=postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=sdap/VatKgsrBZdduF46id6UEhooR/Xi4j5EJFXkZ7M=; b=BTBzELAZtNBiCV1CbMMctgLiYziuO8Us74ixurMDMSYwvwSjegsFPaAET5XkLKxNR3 EiowwlFGP8yVObOK1V7LuzMSBInNDxbxel0OSl3yUDsJYLX5bfUyGumHV8d/Ep4AgkXu dvPtRnpcrJv3dsLrY3/DsUGr5lHenRtFeUR3RMTjHexIExMBzzHdJ4cyerZ3Fk8Cl9Gv G8/5tm4EETxdt7koux4cLWqIXGXMycrL3InCOg5EEFu6CODLBkLhTKbS1xeizXndxNw7 qAfZ5GeJZMKQCQGwuYLz6H0IuLdJqemPaKHtHVbF5IVWLWGHlFlkY05WPJ0dJO6Ids86 uDNg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1766507731; x=1767112531; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=sdap/VatKgsrBZdduF46id6UEhooR/Xi4j5EJFXkZ7M=; b=oAOGSHSfQOfCUsAeh16YFo0FKSVAhsjrhNmncLvtCPpYBqSrJNqkCZtzw2tzOpYISV ShGfWUTHB8TvyUac5nA1mHJ4N/KPzxBNa69k0TXEEabXFjIvHaF81jYqktyZBbc+EDOY E+SakcslF/Sl3m7AA0Ny3jjUqw7caOg69zaIEiytM7YNQZlB8Ok9WR11nxUIWDMAaMcL 5SG9S4fQzukb/laecK4zuhAX5X/QfEWcYAEisnAe2O/vMRBZVfbvJK9Sf9sCt5Ddb0S7 vUJfvoCCugN/XOsG5Lo/cDlu+OFaQwRz3jWihHeUxorl7IKDxAaklWNvbxIwMtDQUdbo eFYA== X-Gm-Message-State: AOJu0YxLL4Otwb13JSi5DX0T3km6cTKNTxlKjitDjZmjD4Lner70Ndt9 Ru9I63Vjt+6Ha1ltw8uYSx1czm2dm+ipvoounQ9cnZca5b3bGQfCQnfk/vRAZtcmSNYbqCrABtz iuNJAfsFU5bDBywj34iXp7OdsGmUOg+03SVqIf6k= X-Gm-Gg: AY/fxX6u/75TiFR8kq+/rJbqGq3RI00F4MDaft/iKu4QhbceQnpS8EXlaocAgHNc5XC UmCdt7JluCcTcBFt+QqnbkDbCuUjtoR9u3hQG/R2fb8JVeIudw/1PnoxDB9OHVoKBcshTYUWi8Y vSO3tzgGJ055SJgszo9agOFf1QtFKsprv7w8FtkmxMcfPgAdBqfd/cPMtovPQGm9mUZXVYseG3c 9daqoPg2xrSU5y/aanL8X/Avb8JXl306FjlWqdYs8ycWiJGfieR2TIj4/uBI2tEn0G9Bki7KRQi 6g== X-Google-Smtp-Source: AGHT+IHhCWOFn+UGqlNY+az4g1PKXVmAeWplssq5IV4fw6+j/ihh2mKRJXRwkzkNWlFOH/Nj1cL3OzagBrRr72XcdM4= X-Received: by 2002:a17:907:6e92:b0:b73:5e4d:fac4 with SMTP id a640c23a62f3a-b8036ec072cmr1526344966b.7.1766507731246; Tue, 23 Dec 2025 08:35:31 -0800 (PST) MIME-Version: 1.0 References: In-Reply-To: From: Sami Imseih Date: Tue, 23 Dec 2025 10:35:18 -0600 X-Gm-Features: AQt7F2q88diPMlwSfNZjzkMLb47h7LkXUzeQ0l4P7ut77CgZDDc2qjuyCmbes5s Message-ID: Subject: Re: Refactor query normalization into core query jumbling To: zengman Cc: pgsql-hackers Content-Type: multipart/mixed; boundary="000000000000d09ce30646a12154" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000d09ce30646a12154 Content-Type: text/plain; charset="UTF-8" > Though this may be tangential to the current topic, I have long been wanting to revise the two instances of `Assert(len_to_wrt >= 0);` > in the code to the implementation below. Would you kindly advise if this modification is worthwhile? > > ``` > if (len_to_wrt > 0) > { > memcpy(norm_query + n_quer_loc, query + quer_loc, len_to_wrt); > n_quer_loc += len_to_wrt; > } > ``` I am not sure I like this idea. The len_to_wrt being less than 0 indicates a bug which will be hidden behind such a loop. I think it's better to keep the Assert as-is. > > > This way, any extension that wishes to return a normalized string from > > > the same JumbleState can invoke this callback and get consistent results. > > > pg_stat_statements and other extensions with a need to normalize a query > > > string based on the locations of a JumbleState do not need to care about the > > > internals of normalization, they simply invoke the callback and > > > receive the final > > > string. > > > > Hmm. I did not wrap completely my head with your problem, but, > > assuming that what you are proposing goes in the right direction, > > The first goal is to move all query-normalization-related infrastructure > that pg_stat_statements (and other extensions) rely on into core, so > extensions no longer need to copy or reimplement normalization logic and > can all depend on a single, shared implementation. > > In addition, query normalization necessarily modifies JumbleState (to > record constant locations and lengths). This responsibility should not > fall to extensions and should instead be delegated to core. I will argue > that the current design, in which extensions handle this directly, is a > layering violation. > > As a first step, we can move generate_normalized_query to core as a global > function, allowing extensions to simply call it. v3 implements this approach without a callback. This establishes a clear boundary: core owns JumbleState modifications, extensions consume the results through the API. I kept the post_parse_analyze hook signature unchanged since GenerateNormalizedQuery still needs to modify JumbleState (to populate constant lengths). Making it const would be misleading. For the second part of making more jumbling utilities global, this can be taken up in another thread. I am now thinking we would be better off actually taking all the generic jumbling routines and separating them into their own C file. So we can have a new file like primjumble.c which will have all the "primitive" jumbling utilities, and queryjumblefuncs.c can worry about its core business of jumbling a Query tree. Anyhow, these are just some high level thoughts on this part for now. -- Sami Imseih Amazon Web Services (AWS) --000000000000d09ce30646a12154 Content-Type: application/octet-stream; name="v3-0001-pg_stat_statements-Move-query-normalization-to-co.patch" Content-Disposition: attachment; filename="v3-0001-pg_stat_statements-Move-query-normalization-to-co.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mjiswx8s0 RnJvbSBmZmU2OTYzZmQyMTdmNjQyMzBkNWQ2MzhhYjlhMTY1NzBhODk1MTcyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBVYnVudHUgPHVidW50dUBpcC0xNzItMzEtNDYtMjMwLmVjMi5p bnRlcm5hbD4KRGF0ZTogVGh1LCAxOCBEZWMgMjAyNSAxODo1OTozMSArMDAwMApTdWJqZWN0OiBb UEFUQ0ggdjNdIHBnX3N0YXRfc3RhdGVtZW50czogTW92ZSBxdWVyeSBub3JtYWxpemF0aW9uIHRv IGNvcmUKCnBnX3N0YXRfc3RhdGVtZW50cyB3YXMgbW9kaWZ5aW5nIGNvcmUgZ2VuZXJhdGVkIEp1 bWJsZVN0YXRlIGluc3RhbmNlcwpieSBjYWxsaW5nIGZpbGxfaW5fY29uc3RhbnRfbGVuZ3Rocygp IHZpYSBnZW5lcmF0ZV9ub3JtYWxpemVkX3F1ZXJ5KCkKdG8gcG9wdWxhdGUgY29uc3RhbnQgbGVu Z3Rocy4gVGhpcyBjcmVhdGVzIHByb2JsZW1zIHNpbmNlIGV4dGVuc2lvbnMKc2hvdWxkIG5vdCBt b2RpZnkgc2hhcmVkIGNvcmUgZGF0YSBzdHJ1Y3R1cmVzIHRoYXQgbWF5IGJlIHVzZWQgYnkKb3Ro ZXIgZXh0ZW5zaW9ucywgYW5kIHRoaXMgY291bGQgYmUgY29uc2lkZXJlZCBhIGxheWVyaW5nIHZp b2xhdGlvbi4KCk1vdmUgcXVlcnkgbm9ybWFsaXphdGlvbiBmdW5jdGlvbnMgdG8gY29yZSBhcyBh IGdsb2JhbCBmdW5jdGlvbiB0bwpmaXggdGhpcy4gRXh0ZW5zaW9ucyBub3cgY2FsbCBHZW5lcmF0 ZU5vcm1hbGl6ZWRRdWVyeSgpIGluc3RlYWQgb2YKZGlyZWN0bHkgbW9kaWZ5aW5nIEp1bWJsZVN0 YXRlLgoKVGhpcyBjaGFuZ2UgYWxzbyBhZGRyZXNzZXMgY29kZSBkdXBsaWNhdGlvbiwgYXMgc2V2 ZXJhbCBleHRlbnNpb25zCmhhdmUgYmVlbiBjb3B5aW5nIGdlbmVyYXRlX25vcm1hbGl6ZWRfcXVl cnkoKSB0byBpbXBsZW1lbnQgdGhlaXIgb3duCm5vcm1hbGl6YXRpb24uIFRoZSBuZXcgY29yZSBB UEkgcHJvdmlkZXMgYSBzaW5nbGUsIGNvbnNpc3RlbnQKaW1wbGVtZW50YXRpb24gZm9yIGFsbCBl eHRlbnNpb25zIHRvIHVzZS4KCkZ1bmN0aW9ucyBhcmUgcmVuYW1lZCB0byBtYXRjaCBjb3JlIG5h bWluZyBjb252ZW50aW9ucyBhbmQgY29tbWVudHMKYXJlIHVwZGF0ZWQgZm9yIGNsYXJpdHkuCgpE aXNjdXNzaW9uOiBodHRwczovL3Bvc3Rnci5lcy9tL0NBQTVSWjB0WnA1cVUwaWtaRUVxSm54dmRT TkdoMURXdjgwc2ItazRRQVVtaU1vT3BfUUBtYWlsLmdtYWlsLmNvbQotLS0KIC4uLi9wZ19zdGF0 X3N0YXRlbWVudHMvcGdfc3RhdF9zdGF0ZW1lbnRzLmMgICB8IDI3NiArLS0tLS0tLS0tLS0tLS0t LS0KIHNyYy9iYWNrZW5kL25vZGVzL3F1ZXJ5anVtYmxlZnVuY3MuYyAgICAgICAgICB8IDI0OCAr KysrKysrKysrKysrKysrCiBzcmMvaW5jbHVkZS9ub2Rlcy9xdWVyeWp1bWJsZS5oICAgICAgICAg ICAgICAgfCAgIDIgKwogMyBmaWxlcyBjaGFuZ2VkLCAyNjAgaW5zZXJ0aW9ucygrKSwgMjY2IGRl bGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2NvbnRyaWIvcGdfc3RhdF9zdGF0ZW1lbnRzL3BnX3N0 YXRfc3RhdGVtZW50cy5jIGIvY29udHJpYi9wZ19zdGF0X3N0YXRlbWVudHMvcGdfc3RhdF9zdGF0 ZW1lbnRzLmMKaW5kZXggMzkyMDhmODBiNWIuLmI5MDg5MTg1OWQ5IDEwMDY0NAotLS0gYS9jb250 cmliL3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYworKysgYi9jb250cmli L3BnX3N0YXRfc3RhdGVtZW50cy9wZ19zdGF0X3N0YXRlbWVudHMuYwpAQCAtNTAsNyArNTAsNiBA QAogI2luY2x1ZGUgImFjY2Vzcy9odHVwX2RldGFpbHMuaCIKICNpbmNsdWRlICJhY2Nlc3MvcGFy YWxsZWwuaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX2F1dGhpZC5oIgotI2luY2x1ZGUgImNvbW1v bi9pbnQuaCIKICNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVtZW50LmgiCiAjaW5jbHVkZSAiZnVu Y2FwaS5oIgogI2luY2x1ZGUgImppdC9qaXQuaCIKQEAgLTU5LDcgKzU4LDYgQEAKICNpbmNsdWRl ICJub2Rlcy9xdWVyeWp1bWJsZS5oIgogI2luY2x1ZGUgIm9wdGltaXplci9wbGFubmVyLmgiCiAj aW5jbHVkZSAicGFyc2VyL2FuYWx5emUuaCIKLSNpbmNsdWRlICJwYXJzZXIvc2Nhbm5lci5oIgog I2luY2x1ZGUgInBnc3RhdC5oIgogI2luY2x1ZGUgInN0b3JhZ2UvZmQuaCIKICNpbmNsdWRlICJz dG9yYWdlL2lwYy5oIgpAQCAtMzc3LDExICszNzUsNiBAQCBzdGF0aWMgY2hhciAqcXRleHRfZmV0 Y2goU2l6ZSBxdWVyeV9vZmZzZXQsIGludCBxdWVyeV9sZW4sCiBzdGF0aWMgYm9vbCBuZWVkX2dj X3F0ZXh0cyh2b2lkKTsKIHN0YXRpYyB2b2lkIGdjX3F0ZXh0cyh2b2lkKTsKIHN0YXRpYyBUaW1l c3RhbXBUeiBlbnRyeV9yZXNldChPaWQgdXNlcmlkLCBPaWQgZGJpZCwgaW50NjQgcXVlcnlpZCwg Ym9vbCBtaW5tYXhfb25seSk7Ci1zdGF0aWMgY2hhciAqZ2VuZXJhdGVfbm9ybWFsaXplZF9xdWVy eShKdW1ibGVTdGF0ZSAqanN0YXRlLCBjb25zdCBjaGFyICpxdWVyeSwKLQkJCQkJCQkJCSAgIGlu dCBxdWVyeV9sb2MsIGludCAqcXVlcnlfbGVuX3ApOwotc3RhdGljIHZvaWQgZmlsbF9pbl9jb25z dGFudF9sZW5ndGhzKEp1bWJsZVN0YXRlICpqc3RhdGUsIGNvbnN0IGNoYXIgKnF1ZXJ5LAotCQkJ CQkJCQkJIGludCBxdWVyeV9sb2MpOwotc3RhdGljIGludAljb21wX2xvY2F0aW9uKGNvbnN0IHZv aWQgKmEsIGNvbnN0IHZvaWQgKmIpOwogCiAKIC8qCkBAIC0xMzU5LDkgKzEzNTIsMTYgQEAgcGdz c19zdG9yZShjb25zdCBjaGFyICpxdWVyeSwgaW50NjQgcXVlcnlJZCwKIAkJaWYgKGpzdGF0ZSkK IAkJewogCQkJTFdMb2NrUmVsZWFzZShwZ3NzLT5sb2NrKTsKLQkJCW5vcm1fcXVlcnkgPSBnZW5l cmF0ZV9ub3JtYWxpemVkX3F1ZXJ5KGpzdGF0ZSwgcXVlcnksCi0JCQkJCQkJCQkJCQkgICBxdWVy eV9sb2NhdGlvbiwKLQkJCQkJCQkJCQkJCSAgICZxdWVyeV9sZW4pOworCisJCQkvKgorCQkJICog Z2VuZXJhdGUgdGhlIG5vcm1hbGl6ZWQgcXVlcnkuIE5vdGUgdGhhdCB0aGUgbm9ybWFsaXplZAor CQkJICogcmVwcmVzZW50YXRpb24gbWF5IHdlbGwgdmFyeSBkZXBlbmRpbmcgb24ganVzdCB3aGlj aAorCQkJICogImVxdWl2YWxlbnQiIHF1ZXJ5IGlzIHVzZWQgdG8gY3JlYXRlIHRoZSBoYXNodGFi bGUgZW50cnkuIFdlCisJCQkgKiBhc3N1bWUgdGhpcyBpcyBPSy4KKwkJCSAqLworCQkJbm9ybV9x dWVyeSA9IEdlbmVyYXRlTm9ybWFsaXplZFF1ZXJ5KGpzdGF0ZSwgcXVlcnksCisJCQkJCQkJCQkJ CQkgcXVlcnlfbG9jYXRpb24sCisJCQkJCQkJCQkJCQkgJnF1ZXJ5X2xlbik7CiAJCQlMV0xvY2tB Y3F1aXJlKHBnc3MtPmxvY2ssIExXX1NIQVJFRCk7CiAJCX0KIApAQCAtMjgyMywyNTkgKzI4MjMs MyBAQCByZWxlYXNlX2xvY2s6CiAKIAlyZXR1cm4gc3RhdHNfcmVzZXQ7CiB9Ci0KLS8qCi0gKiBH ZW5lcmF0ZSBhIG5vcm1hbGl6ZWQgdmVyc2lvbiBvZiB0aGUgcXVlcnkgc3RyaW5nIHRoYXQgd2ls bCBiZSB1c2VkIHRvCi0gKiByZXByZXNlbnQgYWxsIHNpbWlsYXIgcXVlcmllcy4KLSAqCi0gKiBO b3RlIHRoYXQgdGhlIG5vcm1hbGl6ZWQgcmVwcmVzZW50YXRpb24gbWF5IHdlbGwgdmFyeSBkZXBl bmRpbmcgb24KLSAqIGp1c3Qgd2hpY2ggImVxdWl2YWxlbnQiIHF1ZXJ5IGlzIHVzZWQgdG8gY3Jl YXRlIHRoZSBoYXNodGFibGUgZW50cnkuCi0gKiBXZSBhc3N1bWUgdGhpcyBpcyBPSy4KLSAqCi0g KiBJZiBxdWVyeV9sb2MgPiAwLCB0aGVuICJxdWVyeSIgaGFzIGJlZW4gYWR2YW5jZWQgYnkgdGhh dCBtdWNoIGNvbXBhcmVkIHRvCi0gKiB0aGUgb3JpZ2luYWwgc3RyaW5nIHN0YXJ0LCBzbyB3ZSBu ZWVkIHRvIHRyYW5zbGF0ZSB0aGUgcHJvdmlkZWQgbG9jYXRpb25zCi0gKiB0byBjb21wZW5zYXRl LiAgKFRoaXMgbGV0cyB1cyBhdm9pZCByZS1zY2FubmluZyBzdGF0ZW1lbnRzIGJlZm9yZSB0aGUg b25lCi0gKiBvZiBpbnRlcmVzdCwgc28gaXQncyB3b3J0aCBkb2luZy4pCi0gKgotICogKnF1ZXJ5 X2xlbl9wIGNvbnRhaW5zIHRoZSBpbnB1dCBzdHJpbmcgbGVuZ3RoLCBhbmQgaXMgdXBkYXRlZCB3 aXRoCi0gKiB0aGUgcmVzdWx0IHN0cmluZyBsZW5ndGggb24gZXhpdC4gIFRoZSByZXN1bHRpbmcg c3RyaW5nIG1pZ2h0IGJlIGxvbmdlcgotICogb3Igc2hvcnRlciBkZXBlbmRpbmcgb24gd2hhdCBo YXBwZW5zIHdpdGggcmVwbGFjZW1lbnQgb2YgY29uc3RhbnRzLgotICoKLSAqIFJldHVybnMgYSBw YWxsb2MnZCBzdHJpbmcuCi0gKi8KLXN0YXRpYyBjaGFyICoKLWdlbmVyYXRlX25vcm1hbGl6ZWRf cXVlcnkoSnVtYmxlU3RhdGUgKmpzdGF0ZSwgY29uc3QgY2hhciAqcXVlcnksCi0JCQkJCQkgIGlu dCBxdWVyeV9sb2MsIGludCAqcXVlcnlfbGVuX3ApCi17Ci0JY2hhcgkgICAqbm9ybV9xdWVyeTsK LQlpbnQJCQlxdWVyeV9sZW4gPSAqcXVlcnlfbGVuX3A7Ci0JaW50CQkJbm9ybV9xdWVyeV9idWZs ZW4sCS8qIFNwYWNlIGFsbG93ZWQgZm9yIG5vcm1fcXVlcnkgKi8KLQkJCQlsZW5fdG9fd3J0LAkJ LyogTGVuZ3RoIChpbiBieXRlcykgdG8gd3JpdGUgKi8KLQkJCQlxdWVyX2xvYyA9IDAsCS8qIFNv dXJjZSBxdWVyeSBieXRlIGxvY2F0aW9uICovCi0JCQkJbl9xdWVyX2xvYyA9IDAsIC8qIE5vcm1h bGl6ZWQgcXVlcnkgYnl0ZSBsb2NhdGlvbiAqLwotCQkJCWxhc3Rfb2ZmID0gMCwJLyogT2Zmc2V0 IGZyb20gc3RhcnQgZm9yIHByZXZpb3VzIHRvayAqLwotCQkJCWxhc3RfdG9rX2xlbiA9IDA7CS8q IExlbmd0aCAoaW4gYnl0ZXMpIG9mIHRoYXQgdG9rICovCi0JaW50CQkJbnVtX2NvbnN0YW50c19y ZXBsYWNlZCA9IDA7Ci0KLQkvKgotCSAqIEdldCBjb25zdGFudHMnIGxlbmd0aHMgKGNvcmUgc3lz dGVtIG9ubHkgZ2l2ZXMgdXMgbG9jYXRpb25zKS4gIE5vdGUKLQkgKiB0aGlzIGFsc28gZW5zdXJl cyB0aGUgaXRlbXMgYXJlIHNvcnRlZCBieSBsb2NhdGlvbi4KLQkgKi8KLQlmaWxsX2luX2NvbnN0 YW50X2xlbmd0aHMoanN0YXRlLCBxdWVyeSwgcXVlcnlfbG9jKTsKLQotCS8qCi0JICogQWxsb3cg Zm9yICRuIHN5bWJvbHMgdG8gYmUgbG9uZ2VyIHRoYW4gdGhlIGNvbnN0YW50cyB0aGV5IHJlcGxh Y2UuCi0JICogQ29uc3RhbnRzIG11c3QgdGFrZSBhdCBsZWFzdCBvbmUgYnl0ZSBpbiB0ZXh0IGZv cm0sIHdoaWxlIGEgJG4gc3ltYm9sCi0JICogY2VydGFpbmx5IGlzbid0IG1vcmUgdGhhbiAxMSBi eXRlcywgZXZlbiBpZiBuIHJlYWNoZXMgSU5UX01BWC4gIFdlCi0JICogY291bGQgcmVmaW5lIHRo YXQgbGltaXQgYmFzZWQgb24gdGhlIG1heCB2YWx1ZSBvZiBuIGZvciB0aGUgY3VycmVudAotCSAq IHF1ZXJ5LCBidXQgaXQgaGFyZGx5IHNlZW1zIHdvcnRoIGFueSBleHRyYSBlZmZvcnQgdG8gZG8g c28uCi0JICovCi0Jbm9ybV9xdWVyeV9idWZsZW4gPSBxdWVyeV9sZW4gKyBqc3RhdGUtPmNsb2Nh dGlvbnNfY291bnQgKiAxMDsKLQotCS8qIEFsbG9jYXRlIHJlc3VsdCBidWZmZXIgKi8KLQlub3Jt X3F1ZXJ5ID0gcGFsbG9jKG5vcm1fcXVlcnlfYnVmbGVuICsgMSk7Ci0KLQlmb3IgKGludCBpID0g MDsgaSA8IGpzdGF0ZS0+Y2xvY2F0aW9uc19jb3VudDsgaSsrKQotCXsKLQkJaW50CQkJb2ZmLAkJ LyogT2Zmc2V0IGZyb20gc3RhcnQgZm9yIGN1ciB0b2sgKi8KLQkJCQkJdG9rX2xlbjsJLyogTGVu Z3RoIChpbiBieXRlcykgb2YgdGhhdCB0b2sgKi8KLQotCQkvKgotCQkgKiBJZiB3ZSBoYXZlIGFu IGV4dGVybmFsIHBhcmFtIGF0IHRoaXMgbG9jYXRpb24sIGJ1dCBubyBsaXN0cyBhcmUKLQkJICog YmVpbmcgc3F1YXNoZWQgYWNyb3NzIHRoZSBxdWVyeSwgdGhlbiB3ZSBza2lwIGhlcmU7IHRoaXMg d2lsbCBtYWtlCi0JCSAqIHVzIHByaW50IHRoZSBjaGFyYWN0ZXJzIGZvdW5kIGluIHRoZSBvcmln aW5hbCBxdWVyeSB0aGF0IHJlcHJlc2VudAotCQkgKiB0aGUgcGFyYW1ldGVyIGluIHRoZSBuZXh0 IGl0ZXJhdGlvbiAob3IgYWZ0ZXIgdGhlIGxvb3AgaXMgZG9uZSksCi0JCSAqIHdoaWNoIGlzIGEg Yml0IG9kZCBidXQgc2VlbXMgdG8gd29yayBva2F5IGluIG1vc3QgY2FzZXMuCi0JCSAqLwotCQlp ZiAoanN0YXRlLT5jbG9jYXRpb25zW2ldLmV4dGVybl9wYXJhbSAmJiAhanN0YXRlLT5oYXNfc3F1 YXNoZWRfbGlzdHMpCi0JCQljb250aW51ZTsKLQotCQlvZmYgPSBqc3RhdGUtPmNsb2NhdGlvbnNb aV0ubG9jYXRpb247Ci0KLQkJLyogQWRqdXN0IHJlY29yZGVkIGxvY2F0aW9uIGlmIHdlJ3JlIGRl YWxpbmcgd2l0aCBwYXJ0aWFsIHN0cmluZyAqLwotCQlvZmYgLT0gcXVlcnlfbG9jOwotCi0JCXRv a19sZW4gPSBqc3RhdGUtPmNsb2NhdGlvbnNbaV0ubGVuZ3RoOwotCi0JCWlmICh0b2tfbGVuIDwg MCkKLQkJCWNvbnRpbnVlOwkJCS8qIGlnbm9yZSBhbnkgZHVwbGljYXRlcyAqLwotCi0JCS8qIENv cHkgbmV4dCBjaHVuayAod2hhdCBwcmVjZWRlcyB0aGUgbmV4dCBjb25zdGFudCkgKi8KLQkJbGVu X3RvX3dydCA9IG9mZiAtIGxhc3Rfb2ZmOwotCQlsZW5fdG9fd3J0IC09IGxhc3RfdG9rX2xlbjsK LQkJQXNzZXJ0KGxlbl90b193cnQgPj0gMCk7Ci0JCW1lbWNweShub3JtX3F1ZXJ5ICsgbl9xdWVy X2xvYywgcXVlcnkgKyBxdWVyX2xvYywgbGVuX3RvX3dydCk7Ci0JCW5fcXVlcl9sb2MgKz0gbGVu X3RvX3dydDsKLQotCQkvKgotCQkgKiBBbmQgaW5zZXJ0IGEgcGFyYW0gc3ltYm9sIGluIHBsYWNl IG9mIHRoZSBjb25zdGFudCB0b2tlbjsgYW5kLCBpZgotCQkgKiB3ZSBoYXZlIGEgc3F1YXNoYWJs ZSBsaXN0LCBpbnNlcnQgYSBwbGFjZWhvbGRlciBjb21tZW50IHN0YXJ0aW5nCi0JCSAqIGZyb20g dGhlIGxpc3QncyBzZWNvbmQgdmFsdWUuCi0JCSAqLwotCQluX3F1ZXJfbG9jICs9IHNwcmludGYo bm9ybV9xdWVyeSArIG5fcXVlcl9sb2MsICIkJWQlcyIsCi0JCQkJCQkJICBudW1fY29uc3RhbnRz X3JlcGxhY2VkICsgMSArIGpzdGF0ZS0+aGlnaGVzdF9leHRlcm5fcGFyYW1faWQsCi0JCQkJCQkJ ICBqc3RhdGUtPmNsb2NhdGlvbnNbaV0uc3F1YXNoZWQgPyAiIC8qLCAuLi4gKi8iIDogIiIpOwot CQludW1fY29uc3RhbnRzX3JlcGxhY2VkKys7Ci0KLQkJLyogbW92ZSBmb3J3YXJkICovCi0JCXF1 ZXJfbG9jID0gb2ZmICsgdG9rX2xlbjsKLQkJbGFzdF9vZmYgPSBvZmY7Ci0JCWxhc3RfdG9rX2xl biA9IHRva19sZW47Ci0JfQotCi0JLyoKLQkgKiBXZSd2ZSBjb3BpZWQgdXAgdW50aWwgdGhlIGxh c3QgaWdub3JhYmxlIGNvbnN0YW50LiAgQ29weSBvdmVyIHRoZQotCSAqIHJlbWFpbmluZyBieXRl cyBvZiB0aGUgb3JpZ2luYWwgcXVlcnkgc3RyaW5nLgotCSAqLwotCWxlbl90b193cnQgPSBxdWVy eV9sZW4gLSBxdWVyX2xvYzsKLQotCUFzc2VydChsZW5fdG9fd3J0ID49IDApOwotCW1lbWNweShu b3JtX3F1ZXJ5ICsgbl9xdWVyX2xvYywgcXVlcnkgKyBxdWVyX2xvYywgbGVuX3RvX3dydCk7Ci0J bl9xdWVyX2xvYyArPSBsZW5fdG9fd3J0OwotCi0JQXNzZXJ0KG5fcXVlcl9sb2MgPD0gbm9ybV9x dWVyeV9idWZsZW4pOwotCW5vcm1fcXVlcnlbbl9xdWVyX2xvY10gPSAnXDAnOwotCi0JKnF1ZXJ5 X2xlbl9wID0gbl9xdWVyX2xvYzsKLQlyZXR1cm4gbm9ybV9xdWVyeTsKLX0KLQotLyoKLSAqIEdp dmVuIGEgdmFsaWQgU1FMIHN0cmluZyBhbmQgYW4gYXJyYXkgb2YgY29uc3RhbnQtbG9jYXRpb24g cmVjb3JkcywKLSAqIGZpbGwgaW4gdGhlIHRleHR1YWwgbGVuZ3RocyBvZiB0aG9zZSBjb25zdGFu dHMuCi0gKgotICogVGhlIGNvbnN0YW50cyBtYXkgdXNlIGFueSBhbGxvd2VkIGNvbnN0YW50IHN5 bnRheCwgc3VjaCBhcyBmbG9hdCBsaXRlcmFscywKLSAqIGJpdC1zdHJpbmdzLCBzaW5nbGUtcXVv dGVkIHN0cmluZ3MgYW5kIGRvbGxhci1xdW90ZWQgc3RyaW5ncy4gIFRoaXMgaXMKLSAqIGFjY29t cGxpc2hlZCBieSB1c2luZyB0aGUgcHVibGljIEFQSSBmb3IgdGhlIGNvcmUgc2Nhbm5lci4KLSAq Ci0gKiBJdCBpcyB0aGUgY2FsbGVyJ3Mgam9iIHRvIGVuc3VyZSB0aGF0IHRoZSBzdHJpbmcgaXMg YSB2YWxpZCBTUUwgc3RhdGVtZW50Ci0gKiB3aXRoIGNvbnN0YW50cyBhdCB0aGUgaW5kaWNhdGVk IGxvY2F0aW9ucy4gIFNpbmNlIGluIHByYWN0aWNlIHRoZSBzdHJpbmcKLSAqIGhhcyBhbHJlYWR5 IGJlZW4gcGFyc2VkLCBhbmQgdGhlIGxvY2F0aW9ucyB0aGF0IHRoZSBjYWxsZXIgcHJvdmlkZXMg d2lsbAotICogaGF2ZSBvcmlnaW5hdGVkIGZyb20gd2l0aGluIHRoZSBhdXRob3JpdGF0aXZlIHBh cnNlciwgdGhpcyBzaG91bGQgbm90IGJlCi0gKiBhIHByb2JsZW0uCi0gKgotICogTXVsdGlwbGUg Y29uc3RhbnRzIGNhbiBoYXZlIHRoZSBzYW1lIGxvY2F0aW9uLiAgV2UgcmVzZXQgbGVuZ3RocyBv ZiB0aG9zZQotICogcGFzdCB0aGUgZmlyc3QgdG8gLTEgc28gdGhhdCB0aGV5IGNhbiBsYXRlciBi ZSBpZ25vcmVkLgotICoKLSAqIElmIHF1ZXJ5X2xvYyA+IDAsIHRoZW4gInF1ZXJ5IiBoYXMgYmVl biBhZHZhbmNlZCBieSB0aGF0IG11Y2ggY29tcGFyZWQgdG8KLSAqIHRoZSBvcmlnaW5hbCBzdHJp bmcgc3RhcnQsIHNvIHdlIG5lZWQgdG8gdHJhbnNsYXRlIHRoZSBwcm92aWRlZCBsb2NhdGlvbnMK LSAqIHRvIGNvbXBlbnNhdGUuICAoVGhpcyBsZXRzIHVzIGF2b2lkIHJlLXNjYW5uaW5nIHN0YXRl bWVudHMgYmVmb3JlIHRoZSBvbmUKLSAqIG9mIGludGVyZXN0LCBzbyBpdCdzIHdvcnRoIGRvaW5n LikKLSAqCi0gKiBOLkIuIFRoZXJlIGlzIGFuIGFzc3VtcHRpb24gdGhhdCBhICctJyBjaGFyYWN0 ZXIgYXQgYSBDb25zdCBsb2NhdGlvbiBiZWdpbnMKLSAqIGEgbmVnYXRpdmUgbnVtZXJpYyBjb25z dGFudC4gIFRoaXMgcHJlY2x1ZGVzIHRoZXJlIGV2ZXIgYmVpbmcgYW5vdGhlcgotICogcmVhc29u IGZvciBhIGNvbnN0YW50IHRvIHN0YXJ0IHdpdGggYSAnLScuCi0gKi8KLXN0YXRpYyB2b2lkCi1m aWxsX2luX2NvbnN0YW50X2xlbmd0aHMoSnVtYmxlU3RhdGUgKmpzdGF0ZSwgY29uc3QgY2hhciAq cXVlcnksCi0JCQkJCQkgaW50IHF1ZXJ5X2xvYykKLXsKLQlMb2NhdGlvbkxlbiAqbG9jczsKLQlj b3JlX3l5c2Nhbl90IHl5c2Nhbm5lcjsKLQljb3JlX3l5X2V4dHJhX3R5cGUgeXlleHRyYTsKLQlj b3JlX1lZU1RZUEUgeXlsdmFsOwotCVlZTFRZUEUJCXl5bGxvYzsKLQotCS8qCi0JICogU29ydCB0 aGUgcmVjb3JkcyBieSBsb2NhdGlvbiBzbyB0aGF0IHdlIGNhbiBwcm9jZXNzIHRoZW0gaW4gb3Jk ZXIgd2hpbGUKLQkgKiBzY2FubmluZyB0aGUgcXVlcnkgdGV4dC4KLQkgKi8KLQlpZiAoanN0YXRl LT5jbG9jYXRpb25zX2NvdW50ID4gMSkKLQkJcXNvcnQoanN0YXRlLT5jbG9jYXRpb25zLCBqc3Rh dGUtPmNsb2NhdGlvbnNfY291bnQsCi0JCQkgIHNpemVvZihMb2NhdGlvbkxlbiksIGNvbXBfbG9j YXRpb24pOwotCWxvY3MgPSBqc3RhdGUtPmNsb2NhdGlvbnM7Ci0KLQkvKiBpbml0aWFsaXplIHRo ZSBmbGV4IHNjYW5uZXIgLS0tIHNob3VsZCBtYXRjaCByYXdfcGFyc2VyKCkgKi8KLQl5eXNjYW5u ZXIgPSBzY2FubmVyX2luaXQocXVlcnksCi0JCQkJCQkJICZ5eWV4dHJhLAotCQkJCQkJCSAmU2Nh bktleXdvcmRzLAotCQkJCQkJCSBTY2FuS2V5d29yZFRva2Vucyk7Ci0KLQkvKiB3ZSBkb24ndCB3 YW50IHRvIHJlLWVtaXQgYW55IGVzY2FwZSBzdHJpbmcgd2FybmluZ3MgKi8KLQl5eWV4dHJhLmVz Y2FwZV9zdHJpbmdfd2FybmluZyA9IGZhbHNlOwotCi0JLyogU2VhcmNoIGZvciBlYWNoIGNvbnN0 YW50LCBpbiBzZXF1ZW5jZSAqLwotCWZvciAoaW50IGkgPSAwOyBpIDwganN0YXRlLT5jbG9jYXRp b25zX2NvdW50OyBpKyspCi0JewotCQlpbnQJCQlsb2M7Ci0JCWludAkJCXRvazsKLQotCQkvKiBJ Z25vcmUgY29uc3RhbnRzIGFmdGVyIHRoZSBmaXJzdCBvbmUgaW4gdGhlIHNhbWUgbG9jYXRpb24g Ki8KLQkJaWYgKGkgPiAwICYmIGxvY3NbaV0ubG9jYXRpb24gPT0gbG9jc1tpIC0gMV0ubG9jYXRp b24pCi0JCXsKLQkJCWxvY3NbaV0ubGVuZ3RoID0gLTE7Ci0JCQljb250aW51ZTsKLQkJfQotCi0J CWlmIChsb2NzW2ldLnNxdWFzaGVkKQotCQkJY29udGludWU7CQkJLyogc3F1YXNoYWJsZSBsaXN0 LCBpZ25vcmUgKi8KLQotCQkvKiBBZGp1c3QgcmVjb3JkZWQgbG9jYXRpb24gaWYgd2UncmUgZGVh bGluZyB3aXRoIHBhcnRpYWwgc3RyaW5nICovCi0JCWxvYyA9IGxvY3NbaV0ubG9jYXRpb24gLSBx dWVyeV9sb2M7Ci0JCUFzc2VydChsb2MgPj0gMCk7Ci0KLQkJLyoKLQkJICogV2UgaGF2ZSBhIHZh bGlkIGxvY2F0aW9uIGZvciBhIGNvbnN0YW50IHRoYXQncyBub3QgYSBkdXBlLiBMZXgKLQkJICog dG9rZW5zIHVudGlsIHdlIGZpbmQgdGhlIGRlc2lyZWQgY29uc3RhbnQuCi0JCSAqLwotCQlmb3Ig KDs7KQotCQl7Ci0JCQl0b2sgPSBjb3JlX3l5bGV4KCZ5eWx2YWwsICZ5eWxsb2MsIHl5c2Nhbm5l cik7Ci0KLQkJCS8qIFdlIHNob3VsZCBub3QgaGl0IGVuZC1vZi1zdHJpbmcsIGJ1dCBpZiB3ZSBk bywgYmVoYXZlIHNhbmVseSAqLwotCQkJaWYgKHRvayA9PSAwKQotCQkJCWJyZWFrOwkJCS8qIG91 dCBvZiBpbm5lciBmb3ItbG9vcCAqLwotCi0JCQkvKgotCQkJICogV2Ugc2hvdWxkIGZpbmQgdGhl IHRva2VuIHBvc2l0aW9uIGV4YWN0bHksIGJ1dCBpZiB3ZSBzb21laG93Ci0JCQkgKiBydW4gcGFz dCBpdCwgd29yayB3aXRoIHRoYXQuCi0JCQkgKi8KLQkJCWlmICh5eWxsb2MgPj0gbG9jKQotCQkJ ewotCQkJCWlmIChxdWVyeVtsb2NdID09ICctJykKLQkJCQl7Ci0JCQkJCS8qCi0JCQkJCSAqIEl0 J3MgYSBuZWdhdGl2ZSB2YWx1ZSAtIHRoaXMgaXMgdGhlIG9uZSBhbmQgb25seSBjYXNlCi0JCQkJ CSAqIHdoZXJlIHdlIHJlcGxhY2UgbW9yZSB0aGFuIGEgc2luZ2xlIHRva2VuLgotCQkJCQkgKgot CQkJCQkgKiBEbyBub3QgY29tcGVuc2F0ZSBmb3IgdGhlIGNvcmUgc3lzdGVtJ3Mgc3BlY2lhbC1j YXNlCi0JCQkJCSAqIGFkanVzdG1lbnQgb2YgbG9jYXRpb24gdG8gdGhhdCBvZiB0aGUgbGVhZGlu ZyAnLScKLQkJCQkJICogb3BlcmF0b3IgaW4gdGhlIGV2ZW50IG9mIGEgbmVnYXRpdmUgY29uc3Rh bnQuICBJdCBpcwotCQkJCQkgKiBhbHNvIHVzZWZ1bCBmb3Igb3VyIHB1cnBvc2VzIHRvIHN0YXJ0 IGZyb20gdGhlIG1pbnVzCi0JCQkJCSAqIHN5bWJvbC4gIEluIHRoaXMgd2F5LCBxdWVyaWVzIGxp a2UgInNlbGVjdCAqIGZyb20gZm9vCi0JCQkJCSAqIHdoZXJlIGJhciA9IDEiIGFuZCAic2VsZWN0 ICogZnJvbSBmb28gd2hlcmUgYmFyID0gLTIiCi0JCQkJCSAqIHdpbGwgaGF2ZSBpZGVudGljYWwg bm9ybWFsaXplZCBxdWVyeSBzdHJpbmdzLgotCQkJCQkgKi8KLQkJCQkJdG9rID0gY29yZV95eWxl eCgmeXlsdmFsLCAmeXlsbG9jLCB5eXNjYW5uZXIpOwotCQkJCQlpZiAodG9rID09IDApCi0JCQkJ CQlicmVhazsJLyogb3V0IG9mIGlubmVyIGZvci1sb29wICovCi0JCQkJfQotCi0JCQkJLyoKLQkJ CQkgKiBXZSBub3cgcmVseSBvbiB0aGUgYXNzdW1wdGlvbiB0aGF0IGZsZXggaGFzIHBsYWNlZCBh IHplcm8KLQkJCQkgKiBieXRlIGFmdGVyIHRoZSB0ZXh0IG9mIHRoZSBjdXJyZW50IHRva2VuIGlu IHNjYW5idWYuCi0JCQkJICovCi0JCQkJbG9jc1tpXS5sZW5ndGggPSBzdHJsZW4oeXlleHRyYS5z Y2FuYnVmICsgbG9jKTsKLQkJCQlicmVhazsJCQkvKiBvdXQgb2YgaW5uZXIgZm9yLWxvb3AgKi8K LQkJCX0KLQkJfQotCi0JCS8qIElmIHdlIGhpdCBlbmQtb2Ytc3RyaW5nLCBnaXZlIHVwLCBsZWF2 aW5nIHJlbWFpbmluZyBsZW5ndGhzIC0xICovCi0JCWlmICh0b2sgPT0gMCkKLQkJCWJyZWFrOwot CX0KLQotCXNjYW5uZXJfZmluaXNoKHl5c2Nhbm5lcik7Ci19Ci0KLS8qCi0gKiBjb21wX2xvY2F0 aW9uOiBjb21wYXJhdG9yIGZvciBxc29ydGluZyBMb2NhdGlvbkxlbiBzdHJ1Y3RzIGJ5IGxvY2F0 aW9uCi0gKi8KLXN0YXRpYyBpbnQKLWNvbXBfbG9jYXRpb24oY29uc3Qgdm9pZCAqYSwgY29uc3Qg dm9pZCAqYikKLXsKLQlpbnQJCQlsID0gKChjb25zdCBMb2NhdGlvbkxlbiAqKSBhKS0+bG9jYXRp b247Ci0JaW50CQkJciA9ICgoY29uc3QgTG9jYXRpb25MZW4gKikgYiktPmxvY2F0aW9uOwotCi0J cmV0dXJuIHBnX2NtcF9zMzIobCwgcik7Ci19CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9ub2Rl cy9xdWVyeWp1bWJsZWZ1bmNzLmMgYi9zcmMvYmFja2VuZC9ub2Rlcy9xdWVyeWp1bWJsZWZ1bmNz LmMKaW5kZXggZmZjMjMwYWY0MjcuLjllMDRkZDZmYmM2IDEwMDY0NAotLS0gYS9zcmMvYmFja2Vu ZC9ub2Rlcy9xdWVyeWp1bWJsZWZ1bmNzLmMKKysrIGIvc3JjL2JhY2tlbmQvbm9kZXMvcXVlcnlq dW1ibGVmdW5jcy5jCkBAIC00MCwxMCArNDAsMTIgQEAKICNpbmNsdWRlICJhY2Nlc3MvdHJhbnNh bS5oIgogI2luY2x1ZGUgImNhdGFsb2cvcGdfcHJvYy5oIgogI2luY2x1ZGUgImNvbW1vbi9oYXNo Zm4uaCIKKyNpbmNsdWRlICJjb21tb24vaW50LmgiCiAjaW5jbHVkZSAibWlzY2FkbWluLmgiCiAj aW5jbHVkZSAibm9kZXMvbm9kZUZ1bmNzLmgiCiAjaW5jbHVkZSAibm9kZXMvcXVlcnlqdW1ibGUu aCIKICNpbmNsdWRlICJ1dGlscy9sc3lzY2FjaGUuaCIKKyNpbmNsdWRlICJwYXJzZXIvc2Nhbm5l ci5oIgogI2luY2x1ZGUgInBhcnNlci9zY2Fuc3VwLmgiCiAKICNkZWZpbmUgSlVNQkxFX1NJWkUJ CQkJMTAyNAkvKiBxdWVyeSBzZXJpYWxpemF0aW9uIGJ1ZmZlciBzaXplICovCkBAIC03NzMsMyAr Nzc1LDI0OSBAQCBfanVtYmxlUmFuZ2VUYmxFbnRyeV9lcmVmKEp1bWJsZVN0YXRlICpqc3RhdGUs CiAJICovCiAJSlVNQkxFX1NUUklORyhhbGlhc25hbWUpOwogfQorCisvKgorICogQ29tcExvY2F0 aW9uOiBjb21wYXJhdG9yIGZvciBxc29ydGluZyBMb2NhdGlvbkxlbiBzdHJ1Y3RzIGJ5IGxvY2F0 aW9uCisgKi8KK3N0YXRpYyBpbnQKK0NvbXBMb2NhdGlvbihjb25zdCB2b2lkICphLCBjb25zdCB2 b2lkICpiKQoreworCWludAkJCWwgPSAoKGNvbnN0IExvY2F0aW9uTGVuICopIGEpLT5sb2NhdGlv bjsKKwlpbnQJCQlyID0gKChjb25zdCBMb2NhdGlvbkxlbiAqKSBiKS0+bG9jYXRpb247CisKKwly ZXR1cm4gcGdfY21wX3MzMihsLCByKTsKK30KKworLyoKKyAqIEdpdmVuIGEgdmFsaWQgU1FMIHN0 cmluZyBhbmQgYW4gYXJyYXkgb2YgY29uc3RhbnQtbG9jYXRpb24gcmVjb3JkcywKKyAqIGZpbGwg aW4gdGhlIHRleHR1YWwgbGVuZ3RocyBvZiB0aG9zZSBjb25zdGFudHMgaW4gSnVtYmxlU3RhdGUu CisgKgorICogVGhlIGNvbnN0YW50cyBtYXkgdXNlIGFueSBhbGxvd2VkIGNvbnN0YW50IHN5bnRh eCwgc3VjaCBhcyBmbG9hdCBsaXRlcmFscywKKyAqIGJpdC1zdHJpbmdzLCBzaW5nbGUtcXVvdGVk IHN0cmluZ3MgYW5kIGRvbGxhci1xdW90ZWQgc3RyaW5ncy4gIFRoaXMgaXMKKyAqIGFjY29tcGxp c2hlZCBieSB1c2luZyB0aGUgcHVibGljIEFQSSBmb3IgdGhlIGNvcmUgc2Nhbm5lci4KKyAqCisg KiBNdWx0aXBsZSBjb25zdGFudHMgY2FuIGhhdmUgdGhlIHNhbWUgbG9jYXRpb24uICBXZSByZXNl dCBsZW5ndGhzIG9mIHRob3NlCisgKiBwYXN0IHRoZSBmaXJzdCB0byAtMSBzbyB0aGF0IHRoZXkg Y2FuIGxhdGVyIGJlIGlnbm9yZWQuCisgKgorICogTi5CLiBUaGVyZSBpcyBhbiBhc3N1bXB0aW9u IHRoYXQgYSAnLScgY2hhcmFjdGVyIGF0IGEgQ29uc3QgbG9jYXRpb24gYmVnaW5zCisgKiBhIG5l Z2F0aXZlIG51bWVyaWMgY29uc3RhbnQuICBUaGlzIHByZWNsdWRlcyB0aGVyZSBldmVyIGJlaW5n IGFub3RoZXIKKyAqIHJlYXNvbiBmb3IgYSBjb25zdGFudCB0byBzdGFydCB3aXRoIGEgJy0nLgor ICovCitzdGF0aWMgdm9pZAorU2V0Q29uc3RhbnRMZW5ndGhzKEp1bWJsZVN0YXRlICpqc3RhdGUs IGNvbnN0IGNoYXIgKnF1ZXJ5LAorCQkJCSAgIGludCBxdWVyeV9sb2MpCit7CisJTG9jYXRpb25M ZW4gKmxvY3M7CisJY29yZV95eXNjYW5fdCB5eXNjYW5uZXI7CisJY29yZV95eV9leHRyYV90eXBl IHl5ZXh0cmE7CisJY29yZV9ZWVNUWVBFIHl5bHZhbDsKKwlZWUxUWVBFCQl5eWxsb2M7CisKKwkv KgorCSAqIFNvcnQgdGhlIHJlY29yZHMgYnkgbG9jYXRpb24gc28gdGhhdCB3ZSBjYW4gcHJvY2Vz cyB0aGVtIGluIG9yZGVyIHdoaWxlCisJICogc2Nhbm5pbmcgdGhlIHF1ZXJ5IHRleHQuCisJICov CisJaWYgKGpzdGF0ZS0+Y2xvY2F0aW9uc19jb3VudCA+IDEpCisJCXFzb3J0KGpzdGF0ZS0+Y2xv Y2F0aW9ucywganN0YXRlLT5jbG9jYXRpb25zX2NvdW50LAorCQkJICBzaXplb2YoTG9jYXRpb25M ZW4pLCBDb21wTG9jYXRpb24pOworCWxvY3MgPSBqc3RhdGUtPmNsb2NhdGlvbnM7CisKKwkvKiBp bml0aWFsaXplIHRoZSBmbGV4IHNjYW5uZXIgLS0tIHNob3VsZCBtYXRjaCByYXdfcGFyc2VyKCkg Ki8KKwl5eXNjYW5uZXIgPSBzY2FubmVyX2luaXQocXVlcnksCisJCQkJCQkJICZ5eWV4dHJhLAor CQkJCQkJCSAmU2NhbktleXdvcmRzLAorCQkJCQkJCSBTY2FuS2V5d29yZFRva2Vucyk7CisKKwkv KiB3ZSBkb24ndCB3YW50IHRvIHJlLWVtaXQgYW55IGVzY2FwZSBzdHJpbmcgd2FybmluZ3MgKi8K Kwl5eWV4dHJhLmVzY2FwZV9zdHJpbmdfd2FybmluZyA9IGZhbHNlOworCisJLyogU2VhcmNoIGZv ciBlYWNoIGNvbnN0YW50LCBpbiBzZXF1ZW5jZSAqLworCWZvciAoaW50IGkgPSAwOyBpIDwganN0 YXRlLT5jbG9jYXRpb25zX2NvdW50OyBpKyspCisJeworCQlpbnQJCQlsb2M7CisJCWludAkJCXRv azsKKworCQkvKiBJZ25vcmUgY29uc3RhbnRzIGFmdGVyIHRoZSBmaXJzdCBvbmUgaW4gdGhlIHNh bWUgbG9jYXRpb24gKi8KKwkJaWYgKGkgPiAwICYmIGxvY3NbaV0ubG9jYXRpb24gPT0gbG9jc1tp IC0gMV0ubG9jYXRpb24pCisJCXsKKwkJCWxvY3NbaV0ubGVuZ3RoID0gLTE7CisJCQljb250aW51 ZTsKKwkJfQorCisJCWlmIChsb2NzW2ldLnNxdWFzaGVkKQorCQkJY29udGludWU7CQkJLyogc3F1 YXNoYWJsZSBsaXN0LCBpZ25vcmUgKi8KKworCQkvKgorCQkgKiBBZGp1c3QgdGhlIGNvbnN0YW50 J3MgbG9jYXRpb24gdXNpbmcgdGhlIHByb3ZpZGVkIHN0YXJ0aW5nIGxvY2F0aW9uCisJCSAqIG9m IHRoZSBjdXJyZW50IHN0YXRlbWVudC4gVGhpcyBhbGxvd3MgdXMgdG8gYXZvaWQgc2Nhbm5pbmcg YQorCQkgKiBtdWx0aS1zdGF0ZW1lbnQgc3RyaW5nIGZyb20gdGhlIGJlZ2lubmluZy4KKwkJICov CisJCWxvYyA9IGxvY3NbaV0ubG9jYXRpb24gLSBxdWVyeV9sb2M7CisJCUFzc2VydChsb2MgPj0g MCk7CisKKwkJLyoKKwkJICogV2UgaGF2ZSBhIHZhbGlkIGxvY2F0aW9uIGZvciBhIGNvbnN0YW50 IHRoYXQncyBub3QgYSBkdXBlLiBMZXgKKwkJICogdG9rZW5zIHVudGlsIHdlIGZpbmQgdGhlIGRl c2lyZWQgY29uc3RhbnQuCisJCSAqLworCQlmb3IgKDs7KQorCQl7CisJCQl0b2sgPSBjb3JlX3l5 bGV4KCZ5eWx2YWwsICZ5eWxsb2MsIHl5c2Nhbm5lcik7CisKKwkJCS8qIFdlIHNob3VsZCBub3Qg aGl0IGVuZC1vZi1zdHJpbmcsIGJ1dCBpZiB3ZSBkbywgYmVoYXZlIHNhbmVseSAqLworCQkJaWYg KHRvayA9PSAwKQorCQkJCWJyZWFrOwkJCS8qIG91dCBvZiBpbm5lciBmb3ItbG9vcCAqLworCisJ CQkvKgorCQkJICogV2Ugc2hvdWxkIGZpbmQgdGhlIHRva2VuIHBvc2l0aW9uIGV4YWN0bHksIGJ1 dCBpZiB3ZSBzb21laG93CisJCQkgKiBydW4gcGFzdCBpdCwgd29yayB3aXRoIHRoYXQuCisJCQkg Ki8KKwkJCWlmICh5eWxsb2MgPj0gbG9jKQorCQkJeworCQkJCWlmIChxdWVyeVtsb2NdID09ICct JykKKwkJCQl7CisJCQkJCS8qCisJCQkJCSAqIEl0J3MgYSBuZWdhdGl2ZSB2YWx1ZSAtIHRoaXMg aXMgdGhlIG9uZSBhbmQgb25seSBjYXNlCisJCQkJCSAqIHdoZXJlIHdlIHJlcGxhY2UgbW9yZSB0 aGFuIGEgc2luZ2xlIHRva2VuLgorCQkJCQkgKgorCQkJCQkgKiBEbyBub3QgY29tcGVuc2F0ZSBm b3IgdGhlIHNwZWNpYWwtY2FzZSBhZGp1c3RtZW50IG9mCisJCQkJCSAqIGxvY2F0aW9uIHRvIHRo YXQgb2YgdGhlIGxlYWRpbmcgJy0nIG9wZXJhdG9yIGluIHRoZQorCQkJCQkgKiBldmVudCBvZiBh IG5lZ2F0aXZlIGNvbnN0YW50IChzZWUgZG9OZWdhdGUoKSBpbgorCQkJCQkgKiBncmFtLnkpLiAg SXQgaXMgYWxzbyB1c2VmdWwgZm9yIG91ciBwdXJwb3NlcyB0byBzdGFydAorCQkJCQkgKiBmcm9t IHRoZSBtaW51cyBzeW1ib2wuICBJbiB0aGlzIHdheSwgcXVlcmllcyBsaWtlCisJCQkJCSAqICJz ZWxlY3QgKiBmcm9tIGZvbyB3aGVyZSBiYXIgPSAxIiBhbmQgInNlbGVjdCAqIGZyb20KKwkJCQkJ ICogZm9vIHdoZXJlIGJhciA9IC0yIiB3aWxsIGhhdmUgaWRlbnRpY2FsIG5vcm1hbGl6ZWQKKwkJ CQkJICogcXVlcnkgc3RyaW5ncy4KKwkJCQkJICovCisJCQkJCXRvayA9IGNvcmVfeXlsZXgoJnl5 bHZhbCwgJnl5bGxvYywgeXlzY2FubmVyKTsKKwkJCQkJaWYgKHRvayA9PSAwKQorCQkJCQkJYnJl YWs7CS8qIG91dCBvZiBpbm5lciBmb3ItbG9vcCAqLworCQkJCX0KKworCQkJCS8qCisJCQkJICog V2Ugbm93IHJlbHkgb24gdGhlIGFzc3VtcHRpb24gdGhhdCBmbGV4IGhhcyBwbGFjZWQgYSB6ZXJv CisJCQkJICogYnl0ZSBhZnRlciB0aGUgdGV4dCBvZiB0aGUgY3VycmVudCB0b2tlbiBpbiBzY2Fu YnVmLgorCQkJCSAqLworCQkJCWxvY3NbaV0ubGVuZ3RoID0gc3RybGVuKHl5ZXh0cmEuc2NhbmJ1 ZiArIGxvYyk7CisJCQkJYnJlYWs7CQkJLyogb3V0IG9mIGlubmVyIGZvci1sb29wICovCisJCQl9 CisJCX0KKworCQkvKiBJZiB3ZSBoaXQgZW5kLW9mLXN0cmluZywgZ2l2ZSB1cCwgbGVhdmluZyBy ZW1haW5pbmcgbGVuZ3RocyAtMSAqLworCQlpZiAodG9rID09IDApCisJCQlicmVhazsKKwl9CisK KwlzY2FubmVyX2ZpbmlzaCh5eXNjYW5uZXIpOworfQorCisvKgorICogQ2FsbGJhY2sgdG8gZ2Vu ZXJhdGUgYSBub3JtYWxpemVkIHZlcnNpb24gb2YgdGhlIHF1ZXJ5IHN0cmluZyB0aGF0IHdpbGwg YmUgdXNlZCB0bworICogcmVwcmVzZW50IGFsbCBzaW1pbGFyIHF1ZXJpZXMuCisgKgorICogSXQg aXMgdGhlIGNhbGxlcidzIGpvYiB0byBlbnN1cmUgdGhhdCB0aGUgc3RyaW5nIGlzIGEgdmFsaWQg U1FMIHN0YXRlbWVudAorICogd2l0aCB0aGUgY29ycmVjdCBjb25zdGFudCBsb2NhdGlvbnMgaW4g anN0YXRlLT5jbG9jYXRpb25zLiBTaW5jZSBpbgorICogcHJhY3RpY2UgdGhlIHN0cmluZyBoYXMg YWxyZWFkeSBiZWVuIHBhcnNlZCB1c2luZyB0aGUgYXV0aG9yaXRhdGl2ZSBwYXJzZXIKKyAqIGFu ZCB0aGUgbG9jYXRpb25zIGFyZSBzZXQgYnkgY29yZSBxdWVyeSBqdW1ibGluZywgdGhpcyBzaG91 bGQgbm90IGJlIGEgcHJvYmxlbS4KKyAqCisgKiAqcXVlcnlfbGVuX3AgY29udGFpbnMgdGhlIGlu cHV0IHN0cmluZyBsZW5ndGgsIGFuZCBpcyB1cGRhdGVkIHdpdGgKKyAqIHRoZSByZXN1bHQgc3Ry aW5nIGxlbmd0aCBvbiBleGl0LiAgVGhlIHJlc3VsdGluZyBzdHJpbmcgbWlnaHQgYmUgbG9uZ2Vy CisgKiBvciBzaG9ydGVyIGRlcGVuZGluZyBvbiB3aGF0IGhhcHBlbnMgd2l0aCByZXBsYWNlbWVu dCBvZiBjb25zdGFudHMuCisgKgorICogUmV0dXJucyBhIHBhbGxvYydkIHN0cmluZy4KKyAqLwor Y2hhciAqCitHZW5lcmF0ZU5vcm1hbGl6ZWRRdWVyeShKdW1ibGVTdGF0ZSAqanN0YXRlLCBjb25z dCBjaGFyICpxdWVyeSwKKwkJCQkJCWludCBxdWVyeV9sb2MsIGludCAqcXVlcnlfbGVuX3ApCit7 CisJY2hhcgkgICAqbm9ybV9xdWVyeTsKKwlpbnQJCQlxdWVyeV9sZW4gPSAqcXVlcnlfbGVuX3A7 CisJaW50CQkJbm9ybV9xdWVyeV9idWZsZW4sCS8qIFNwYWNlIGFsbG93ZWQgZm9yIG5vcm1fcXVl cnkgKi8KKwkJCQlsZW5fdG9fd3J0LAkJLyogTGVuZ3RoIChpbiBieXRlcykgdG8gd3JpdGUgKi8K KwkJCQlxdWVyX2xvYyA9IDAsCS8qIFNvdXJjZSBxdWVyeSBieXRlIGxvY2F0aW9uICovCisJCQkJ bl9xdWVyX2xvYyA9IDAsIC8qIE5vcm1hbGl6ZWQgcXVlcnkgYnl0ZSBsb2NhdGlvbiAqLworCQkJ CWxhc3Rfb2ZmID0gMCwJLyogT2Zmc2V0IGZyb20gc3RhcnQgZm9yIHByZXZpb3VzIHRvayAqLwor CQkJCWxhc3RfdG9rX2xlbiA9IDA7CS8qIExlbmd0aCAoaW4gYnl0ZXMpIG9mIHRoYXQgdG9rICov CisJaW50CQkJbnVtX2NvbnN0YW50c19yZXBsYWNlZCA9IDA7CisKKwkvKgorCSAqIFNldCBjb25z dGFudHMnIGxlbmd0aHMgaW4gSnVtYmxlU3RhdGUsIGFzIG9ubHkgbG9jYXRpb25zIGFyZSBzZXQg ZHVyaW5nCisJICogRG9KdW1ibGUoKS4gTm90ZSB0aGlzIGFsc28gZW5zdXJlcyB0aGUgaXRlbXMg YXJlIHNvcnRlZCBieSBsb2NhdGlvbi4KKwkgKi8KKwlTZXRDb25zdGFudExlbmd0aHMoKEp1bWJs ZVN0YXRlICopIGpzdGF0ZSwgcXVlcnksIHF1ZXJ5X2xvYyk7CisKKwkvKgorCSAqIEFsbG93IGZv ciAkbiBzeW1ib2xzIHRvIGJlIGxvbmdlciB0aGFuIHRoZSBjb25zdGFudHMgdGhleSByZXBsYWNl LgorCSAqIENvbnN0YW50cyBtdXN0IHRha2UgYXQgbGVhc3Qgb25lIGJ5dGUgaW4gdGV4dCBmb3Jt LCB3aGlsZSBhICRuIHN5bWJvbAorCSAqIGNlcnRhaW5seSBpc24ndCBtb3JlIHRoYW4gMTEgYnl0 ZXMsIGV2ZW4gaWYgbiByZWFjaGVzIElOVF9NQVguICBXZQorCSAqIGNvdWxkIHJlZmluZSB0aGF0 IGxpbWl0IGJhc2VkIG9uIHRoZSBtYXggdmFsdWUgb2YgbiBmb3IgdGhlIGN1cnJlbnQKKwkgKiBx dWVyeSwgYnV0IGl0IGhhcmRseSBzZWVtcyB3b3J0aCBhbnkgZXh0cmEgZWZmb3J0IHRvIGRvIHNv LgorCSAqLworCW5vcm1fcXVlcnlfYnVmbGVuID0gcXVlcnlfbGVuICsganN0YXRlLT5jbG9jYXRp b25zX2NvdW50ICogMTA7CisKKwkvKiBBbGxvY2F0ZSByZXN1bHQgYnVmZmVyICovCisJbm9ybV9x dWVyeSA9IHBhbGxvYyhub3JtX3F1ZXJ5X2J1ZmxlbiArIDEpOworCisJZm9yIChpbnQgaSA9IDA7 IGkgPCBqc3RhdGUtPmNsb2NhdGlvbnNfY291bnQ7IGkrKykKKwl7CisJCWludAkJCW9mZiwJCS8q IE9mZnNldCBmcm9tIHN0YXJ0IGZvciBjdXIgdG9rICovCisJCQkJCXRva19sZW47CS8qIExlbmd0 aCAoaW4gYnl0ZXMpIG9mIHRoYXQgdG9rICovCisKKwkJLyoKKwkJICogSWYgd2UgaGF2ZSBhbiBl eHRlcm5hbCBwYXJhbSBhdCB0aGlzIGxvY2F0aW9uLCBidXQgbm8gbGlzdHMgYXJlCisJCSAqIGJl aW5nIHNxdWFzaGVkIGFjcm9zcyB0aGUgcXVlcnksIHRoZW4gd2Ugc2tpcCBoZXJlOyB0aGlzIHdp bGwgbWFrZQorCQkgKiB1cyBwcmludCB0aGUgY2hhcmFjdGVycyBmb3VuZCBpbiB0aGUgb3JpZ2lu YWwgcXVlcnkgdGhhdCByZXByZXNlbnQKKwkJICogdGhlIHBhcmFtZXRlciBpbiB0aGUgbmV4dCBp dGVyYXRpb24gKG9yIGFmdGVyIHRoZSBsb29wIGlzIGRvbmUpLAorCQkgKiB3aGljaCBpcyBhIGJp dCBvZGQgYnV0IHNlZW1zIHRvIHdvcmsgb2theSBpbiBtb3N0IGNhc2VzLgorCQkgKi8KKwkJaWYg KGpzdGF0ZS0+Y2xvY2F0aW9uc1tpXS5leHRlcm5fcGFyYW0gJiYgIWpzdGF0ZS0+aGFzX3NxdWFz aGVkX2xpc3RzKQorCQkJY29udGludWU7CisKKwkJb2ZmID0ganN0YXRlLT5jbG9jYXRpb25zW2ld LmxvY2F0aW9uOworCisJCS8qIEFkanVzdCB0aGUgY29uc3RhbnQncyBsb2NhdGlvbiAoc2VlIFNl dENvbnN0YW50TGVuZ3RocykgKi8KKwkJb2ZmIC09IHF1ZXJ5X2xvYzsKKworCQl0b2tfbGVuID0g anN0YXRlLT5jbG9jYXRpb25zW2ldLmxlbmd0aDsKKworCQlpZiAodG9rX2xlbiA8IDApCisJCQlj b250aW51ZTsJCQkvKiBpZ25vcmUgYW55IGR1cGxpY2F0ZXMgKi8KKworCQkvKiBDb3B5IG5leHQg Y2h1bmsgKHdoYXQgcHJlY2VkZXMgdGhlIG5leHQgY29uc3RhbnQpICovCisJCWxlbl90b193cnQg PSBvZmYgLSBsYXN0X29mZjsKKwkJbGVuX3RvX3dydCAtPSBsYXN0X3Rva19sZW47CisJCUFzc2Vy dChsZW5fdG9fd3J0ID49IDApOworCQltZW1jcHkobm9ybV9xdWVyeSArIG5fcXVlcl9sb2MsIHF1 ZXJ5ICsgcXVlcl9sb2MsIGxlbl90b193cnQpOworCQluX3F1ZXJfbG9jICs9IGxlbl90b193cnQ7 CisKKwkJLyoKKwkJICogQW5kIGluc2VydCBhIHBhcmFtIHN5bWJvbCBpbiBwbGFjZSBvZiB0aGUg Y29uc3RhbnQgdG9rZW47IGFuZCwgaWYKKwkJICogd2UgaGF2ZSBhIHNxdWFzaGFibGUgbGlzdCwg aW5zZXJ0IGEgcGxhY2Vob2xkZXIgY29tbWVudCBzdGFydGluZworCQkgKiBmcm9tIHRoZSBsaXN0 J3Mgc2Vjb25kIHZhbHVlLgorCQkgKi8KKwkJbl9xdWVyX2xvYyArPSBzcHJpbnRmKG5vcm1fcXVl cnkgKyBuX3F1ZXJfbG9jLCAiJCVkJXMiLAorCQkJCQkJCSAgbnVtX2NvbnN0YW50c19yZXBsYWNl ZCArIDEgKyBqc3RhdGUtPmhpZ2hlc3RfZXh0ZXJuX3BhcmFtX2lkLAorCQkJCQkJCSAganN0YXRl LT5jbG9jYXRpb25zW2ldLnNxdWFzaGVkID8gIiAvKiwgLi4uICovIiA6ICIiKTsKKwkJbnVtX2Nv bnN0YW50c19yZXBsYWNlZCsrOworCisJCS8qIG1vdmUgZm9yd2FyZCAqLworCQlxdWVyX2xvYyA9 IG9mZiArIHRva19sZW47CisJCWxhc3Rfb2ZmID0gb2ZmOworCQlsYXN0X3Rva19sZW4gPSB0b2tf bGVuOworCX0KKworCS8qCisJICogV2UndmUgY29waWVkIHVwIHVudGlsIHRoZSBsYXN0IGlnbm9y YWJsZSBjb25zdGFudC4gIENvcHkgb3ZlciB0aGUKKwkgKiByZW1haW5pbmcgYnl0ZXMgb2YgdGhl IG9yaWdpbmFsIHF1ZXJ5IHN0cmluZy4KKwkgKi8KKwlsZW5fdG9fd3J0ID0gcXVlcnlfbGVuIC0g cXVlcl9sb2M7CisKKwlBc3NlcnQobGVuX3RvX3dydCA+PSAwKTsKKwltZW1jcHkobm9ybV9xdWVy eSArIG5fcXVlcl9sb2MsIHF1ZXJ5ICsgcXVlcl9sb2MsIGxlbl90b193cnQpOworCW5fcXVlcl9s b2MgKz0gbGVuX3RvX3dydDsKKworCUFzc2VydChuX3F1ZXJfbG9jIDw9IG5vcm1fcXVlcnlfYnVm bGVuKTsKKwlub3JtX3F1ZXJ5W25fcXVlcl9sb2NdID0gJ1wwJzsKKworCSpxdWVyeV9sZW5fcCA9 IG5fcXVlcl9sb2M7CisJcmV0dXJuIG5vcm1fcXVlcnk7Cit9CmRpZmYgLS1naXQgYS9zcmMvaW5j bHVkZS9ub2Rlcy9xdWVyeWp1bWJsZS5oIGIvc3JjL2luY2x1ZGUvbm9kZXMvcXVlcnlqdW1ibGUu aAppbmRleCBkY2IzNmRjYjQ0Zi4uY2I4NzQxYjFkMDUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNsdWRl L25vZGVzL3F1ZXJ5anVtYmxlLmgKKysrIGIvc3JjL2luY2x1ZGUvbm9kZXMvcXVlcnlqdW1ibGUu aApAQCAtOTEsNiArOTEsOCBAQCBleHRlcm4gUEdETExJTVBPUlQgaW50IGNvbXB1dGVfcXVlcnlf aWQ7CiAKIAogZXh0ZXJuIGNvbnN0IGNoYXIgKkNsZWFuUXVlcnl0ZXh0KGNvbnN0IGNoYXIgKnF1 ZXJ5LCBpbnQgKmxvY2F0aW9uLCBpbnQgKmxlbik7CitleHRlcm4gY2hhciAqR2VuZXJhdGVOb3Jt YWxpemVkUXVlcnkoSnVtYmxlU3RhdGUgKmpzdGF0ZSwgY29uc3QgY2hhciAqcXVlcnksCisJCQkJ CQkJCQkgaW50IHF1ZXJ5X2xvYywgaW50ICpxdWVyeV9sZW5fcCk7CiBleHRlcm4gSnVtYmxlU3Rh dGUgKkp1bWJsZVF1ZXJ5KFF1ZXJ5ICpxdWVyeSk7CiBleHRlcm4gdm9pZCBFbmFibGVRdWVyeUlk KHZvaWQpOwogCi0tIAoyLjQzLjAKCg== --000000000000d09ce30646a12154--