From debbugs-submit-bounces@debbugs.gnu.org Tue Jun 25 01:36:59 2019 Received: (at submit) by debbugs.gnu.org; 25 Jun 2019 05:36:59 +0000 Received: from localhost ([127.0.0.1]:58524 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hfe8Z-0003CQ-3f for submit@debbugs.gnu.org; Tue, 25 Jun 2019 01:36:59 -0400 Received: from lists.gnu.org ([209.51.188.17]:48214) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hfe8W-0003CH-Lh for submit@debbugs.gnu.org; Tue, 25 Jun 2019 01:36:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:40224) by lists.gnu.org with esmtp (Exim 4.86_2) (envelope-from ) id 1hfe8U-0002yo-Li for bug-gnu-emacs@gnu.org; Tue, 25 Jun 2019 01:36:56 -0400 X-Spam-Checker-Version: SpamAssassin 3.3.2 (2011-06-06) on eggs.gnu.org X-Spam-Level: X-Spam-Status: No, score=0.8 required=5.0 tests=BAYES_50,FREEMAIL_FROM, URIBL_BLOCKED autolearn=disabled version=3.3.2 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1hfe8S-0005ps-Rb for bug-gnu-emacs@gnu.org; Tue, 25 Jun 2019 01:36:54 -0400 Received: from mail-ot1-x329.google.com ([2607:f8b0:4864:20::329]:39851) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1hfe8S-0005ne-D2 for bug-gnu-emacs@gnu.org; Tue, 25 Jun 2019 01:36:52 -0400 Received: by mail-ot1-x329.google.com with SMTP id r21so16021780otq.6 for ; Mon, 24 Jun 2019 22:36:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:date:message-id:subject:to; bh=MlQpWSXzwIWZFeCflyF926jlJvPnwKt3XnvnMIIq6PI=; b=l9vV5Nx7aaVZw7WTyCvLYT2UFS9w/AfjZsnNQ3XV81g6JhSk60fMDyvQVkBVrGQ4If Mwa7SQzvbLy9z80wwVnsaVVikwuDINI1huUJUfsB/dONyTnVarq3T4dlfNUan/rgKNgR g4iYxUis7Wu6KVuCRSJiEg6URiYEt8NU5SEvMfkUhU4lFc92AmvPCPW1o1ABZNpMoEGe T28RUo0bphf7lNk97H2z3mcZW50qCVE6+cM8nBomYma4ko0OEIRAhglHOmC2jZ4OrTox eX2g9k9J4N5gKpTL6oRjdo3b5/ZHmPLnPW61rJCnaDKywhBP1JyLRNZrGp2K1KWj2/Qz W6yw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=MlQpWSXzwIWZFeCflyF926jlJvPnwKt3XnvnMIIq6PI=; b=o89/GHJ3TbpPJznOD5cSPRo4a8ueg55UbLp7QULxGmwSwTTK8O60zw56sUTOTPEV+l pyZR8mGWXLYuZ5FHo9GDYoBjNpeAVHY4jX0QxW821Irtswk9miEIb1coTQHPTi9egdWs HfMkqNZQmyYUwVplxr3ZKjr2K/ry7KaHZE40mZdPH9MCyRKjCcd0w4QWlEcxPdjwmgXP kHedYeTYXu+7bJpb5wvY0tAMeI2FnPhN+T87xTlDUDR/+IWKze9o3fqJoK/3xwDIHmss pZl8zwIqg+stNM+ZgOKdqty2QpDdxyqgBV0Udi+ZlPFIhlCJawUxfjvQlZvsyxSdom/I Nvlw== X-Gm-Message-State: APjAAAX3PW6EPpTnx42tT9nBV5KKBGx5YmW0pwrWvTxtLhX6NbZIdRf+ DLzg0m2f12Ao0xSR6NOSoRQ+oSgvEBVzQFYvEaqPYpFv4Bw= X-Google-Smtp-Source: APXvYqy4g3qizFeI8jRsrTzvBAVmU9xmU7LYImnmF1J4fVExzff63i8MGOGD+BkxcxRmm8kwKHAFsqPit0BwSVSXkRQ= X-Received: by 2002:a9d:7352:: with SMTP id l18mr20350882otk.292.1561441010643; Mon, 24 Jun 2019 22:36:50 -0700 (PDT) MIME-Version: 1.0 From: Pip Cet Date: Tue, 25 Jun 2019 05:36:15 +0000 Message-ID: Subject: 27.0.50; XFIXNAT called on negative numbers To: bug-gnu-emacs@gnu.org Content-Type: multipart/mixed; boundary="000000000000c7322b058c1f502e" X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::329 X-Spam-Score: -1.3 (-) X-Debbugs-Envelope-To: submit X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -2.3 (--) --000000000000c7322b058c1f502e Content-Type: text/plain; charset="UTF-8" I just spent some time reviewing the use of XFIXNAT, after being bitten by this code in fileio.c: if (FIXNUMP (tem)) nextpos = XFIXNAT (tem); In the following cases, negative numbers passed to APIs which aren't strictly internal or low-level cause us to call XFIXNAT on a negative number: (indent-to -100 -100) (set-text-properties -1 -1 nil "") (make-network-process :name "name" :family 'ipv6 :remote [-1 0 0 0 0 0 0 0 0]) (end-kbd-macro -1 nil) (previous-single-property-change (point) 'dummy nil -1) I think those six cases are worth fixing, but more generally, I think it would help avoid such errors if XFIXNAT were "always" paired with FIXNATP, XFIXNUM with FIXNUMP, and XCHARACTER (which would be new) with CHARACTERP. So I'm going to be brave here and admit that in many cases, while XFIXNUM was correct, it took me a long time to see that because the check was performed somewhere else. I understand there is a very slight performance hit on some platforms, but is that really still an issue? Also, consistent pairing would catch a few cases in which we call XFIXNUM but could get away with an XFIXNAT, such as this code in self-insert-command: if (!CHARACTERP (c)) bitch_at_user (); else { int character = translate_char (Vtranslation_table_for_input, XFIXNUM (c)); I also think it would make sense to eassume (FIXNUMP (a)) in both XFIXNAT and XFIXNUM (but not XHASH, or XUFIXNUM if that's what XHASH uses). It might catch bugs like (set-text-properties nil nil nil "") currently not throwing an error. The patch I'm attaching fixes only things I'm reasonably sure are bugs. --000000000000c7322b058c1f502e Content-Type: text/x-patch; charset="US-ASCII"; name="xfixnat.diff" Content-Disposition: attachment; filename="xfixnat.diff" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_jxbdl7wb0 ZGlmZiAtLWdpdCBhL3NyYy9jY2wuYyBiL3NyYy9jY2wuYwppbmRleCBlYzEwOGUzMGQ4Li5jODUz ZTYxOTgyIDEwMDY0NAotLS0gYS9zcmMvY2NsLmMKKysrIGIvc3JjL2NjbC5jCkBAIC0yMDYyLDcg KzIwNjIsNyBAQCAjZGVmaW5lIENDTF9FWEVDVVRFX0JVRl9TSVpFIDEwMjQKICAgICAgIGlmIChU WVBFX1JBTkdFRF9GSVhOVU1QIChpbnQsIEFSRUYgKHN0YXR1cywgaSkpKQogCWNjbC5yZWdbaV0g PSBYRklYTlVNIChBUkVGIChzdGF0dXMsIGkpKTsKICAgICB9Ci0gIGlmIChGSVhOVU1QIChBUkVG IChzdGF0dXMsIGkpKSkKKyAgaWYgKEZJWE5BVFAgKEFSRUYgKHN0YXR1cywgaSkpKQogICAgIHsK ICAgICAgIGkgPSBYRklYTkFUIChBUkVGIChzdGF0dXMsIDgpKTsKICAgICAgIGlmIChjY2wuaWMg PCBpICYmIGkgPCBjY2wuc2l6ZSkKZGlmZiAtLWdpdCBhL3NyYy9kb3NmbnMuYyBiL3NyYy9kb3Nm bnMuYwppbmRleCA0N2M1NDUwMDdhLi5mYjViY2M5YWQzIDEwMDY0NAotLS0gYS9zcmMvZG9zZm5z LmMKKysrIGIvc3JjL2Rvc2Zucy5jCkBAIC03Miw3ICs3Miw3IEBAIERFRlVOICgiaW50ODYiLCBG aW50ODYsIFNpbnQ4NiwgMiwgMiwgMCwKICAgaWYgKG5vIDwgMCB8fCBubyA+IDB4ZmYgfHwgQVNJ WkUgKHJlZ2lzdGVycykgIT0gOCkKICAgICByZXR1cm4gUW5pbDsKICAgZm9yIChpID0gMDsgaSA8 IDg7IGkrKykKLSAgICBDSEVDS19GSVhOVU0gKEFSRUYgKHJlZ2lzdGVycywgaSkpOworICAgIENI RUNLX0ZJWE5BVCAoQVJFRiAocmVnaXN0ZXJzLCBpKSk7CiAKICAgaW5yZWdzLnguYXggICAgPSAo dW5zaWduZWQgbG9uZykgWEZJWE5BVCAoQVJFRiAocmVnaXN0ZXJzLCAwKSk7CiAgIGlucmVncy54 LmJ4ICAgID0gKHVuc2lnbmVkIGxvbmcpIFhGSVhOQVQgKEFSRUYgKHJlZ2lzdGVycywgMSkpOwpA QCAtMTM5LDcgKzEzOSw3IEBAIERFRlVOICgibXNkb3MtbWVtcHV0IiwgRmRvc19tZW1wdXQsIFNk b3NfbWVtcHV0LCAyLCAyLCAwLAogCiAgIGZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKICAgICB7 Ci0gICAgICBDSEVDS19GSVhOVU0gKEFSRUYgKHZlY3RvciwgaSkpOworICAgICAgQ0hFQ0tfRklY TkFUIChBUkVGICh2ZWN0b3IsIGkpKTsKICAgICAgIGJ1ZltpXSA9ICh1bnNpZ25lZCBjaGFyKSBY RklYTkFUIChBUkVGICh2ZWN0b3IsIGkpKSAmIDB4RkY7CiAgICAgfQogCmRpZmYgLS1naXQgYS9z cmMvZmlsZWlvLmMgYi9zcmMvZmlsZWlvLmMKaW5kZXggNWRkMTRkYWFjYi4uYjJkYjZlZmQ1NCAx MDA2NDQKLS0tIGEvc3JjL2ZpbGVpby5jCisrKyBiL3NyYy9maWxlaW8uYwpAQCAtNDcxOSw3ICs0 NzE5LDcgQEAgYmVjYXVzZSAoMSkgaXQgcHJlc2VydmVzIHNvbWUgbWFya2VyIHBvc2l0aW9ucyBh bmQgKDIpIGl0IHB1dHMgbGVzcyBkYXRhCiAJCSB0aGUgZm9ybWF0IGNvbnZlcnNpb24uICAqLwog CSAgICAgIExpc3BfT2JqZWN0IHRlbSA9IFhDQVIgKG9sZF91bmRvKTsKIAkgICAgICBpZiAoQ09O U1AgKHRlbSkgJiYgRklYTlVNUCAoWENBUiAodGVtKSkKLQkJICAmJiBGSVhOVU1QIChYQ0RSICh0 ZW0pKQorCQkgICYmIEZJWE5BVFAgKFhDRFIgKHRlbSkpCiAJCSAgJiYgWEZJWE5BVCAoWENEUiAo dGVtKSkgPT0gUFQgKyBvbGRfaW5zZXJ0ZWQpCiAJCVhTRVRDRFIgKHRlbSwgbWFrZV9maXhudW0g KFBUICsgaW5zZXJ0ZWQpKTsKIAkgICAgfQpAQCAtNTM5MSw3ICs1MzkxLDcgQEAgYV93cml0ZSAo aW50IGRlc2MsIExpc3BfT2JqZWN0IHN0cmluZywgcHRyZGlmZl90IHBvcywKICAgICB7CiAgICAg ICB0ZW0gPSBGY2FyX3NhZmUgKEZjYXIgKCphbm5vdCkpOwogICAgICAgbmV4dHBvcyA9IHBvcyAt IDE7Ci0gICAgICBpZiAoRklYTlVNUCAodGVtKSkKKyAgICAgIGlmIChGSVhOQVRQICh0ZW0pKQog CW5leHRwb3MgPSBYRklYTkFUICh0ZW0pOwogCiAgICAgICAvKiBJZiB0aGVyZSBhcmUgbm8gbW9y ZSBhbm5vdGF0aW9ucyBpbiB0aGlzIHJhbmdlLApAQCAtNTg0Nyw3ICs1ODQ3LDcgQEAgREVGVU4g KCJkby1hdXRvLXNhdmUiLCBGZG9fYXV0b19zYXZlLCBTZG9fYXV0b19zYXZlLCAwLCAyLCAiIiwK IAogCSAgICBzZXRfYnVmZmVyX2ludGVybmFsIChiKTsKIAkgICAgaWYgKE5JTFAgKFZhdXRvX3Nh dmVfaW5jbHVkZV9iaWdfZGVsZXRpb25zKQotCQkmJiBGSVhOVU1QIChCVkFSIChiLCBzYXZlX2xl bmd0aCkpCisJCSYmIEZJWE5BVFAgKEJWQVIgKGIsIHNhdmVfbGVuZ3RoKSkKIAkJLyogQSBzaG9y dCBmaWxlIGlzIGxpa2VseSB0byBjaGFuZ2UgYSBsYXJnZSBmcmFjdGlvbjsKIAkJICAgc3BhcmUg dGhlIHVzZXIgYW5ub3lpbmcgbWVzc2FnZXMuICAqLwogCQkmJiBYRklYTkFUIChCVkFSIChiLCBz YXZlX2xlbmd0aCkpID4gNTAwMApkaWZmIC0tZ2l0IGEvc3JjL2ltYWdlLmMgYi9zcmMvaW1hZ2Uu YwppbmRleCA3YjY0OGM0NmFlLi4yZWNlYTA4OTNmIDEwMDY0NAotLS0gYS9zcmMvaW1hZ2UuYwor KysgYi9zcmMvaW1hZ2UuYwpAQCAtMjM4NSw3ICsyMzg1LDcgQEAgbG9va3VwX2ltYWdlIChzdHJ1 Y3QgZnJhbWUgKmYsIExpc3BfT2JqZWN0IHNwZWMpCiAjZW5kaWYKIAogCSAgYXNjZW50ID0gaW1h Z2Vfc3BlY192YWx1ZSAoc3BlYywgUUNhc2NlbnQsIE5VTEwpOwotCSAgaWYgKEZJWE5VTVAgKGFz Y2VudCkpCisJICBpZiAoRklYTkFUUCAoYXNjZW50KSkKIAkgICAgaW1nLT5hc2NlbnQgPSBYRklY TkFUIChhc2NlbnQpOwogCSAgZWxzZSBpZiAoRVEgKGFzY2VudCwgUWNlbnRlcikpCiAJICAgIGlt Zy0+YXNjZW50ID0gQ0VOVEVSRURfSU1BR0VfQVNDRU5UOwpkaWZmIC0tZ2l0IGEvc3JjL2xpc3Au aCBiL3NyYy9saXNwLmgKaW5kZXggNzdmYzIyZDExOC4uYTFiZDZkOGY2YiAxMDA2NDQKLS0tIGEv c3JjL2xpc3AuaAorKysgYi9zcmMvbGlzcC5oCkBAIC0yOTY4LDYgKzI5NjgsMTQgQEAgI2RlZmlu ZSBDSEVDS19GSVhOVU1fQ09FUkNFX01BUktFUih4KQkJCQkJXAogICAgICAgQ0hFQ0tfVFlQRSAo RklYTlVNUCAoeCksIFFpbnRlZ2VyX29yX21hcmtlcl9wLCB4KTsJCVwKICAgfSB3aGlsZSAoZmFs c2UpCiAKKyNkZWZpbmUgQ0hFQ0tfRklYTkFUX0NPRVJDRV9NQVJLRVIoeCkJCQkJCVwKKyAgZG8g ewkJCQkJCQkJCVwKKyAgICBpZiAoTUFSS0VSUCAoKHgpKSkJCQkJCQkJXAorICAgICAgWFNFVEZB U1RJTlQgKHgsIG1hcmtlcl9wb3NpdGlvbiAoeCkpOwkJCQlcCisgICAgZWxzZQkJCQkJCQkJXAor ICAgICAgQ0hFQ0tfVFlQRSAoRklYTkFUUCAoeCksIFFpbnRlZ2VyX29yX21hcmtlcl9wLCB4KTsJ CVwKKyAgfSB3aGlsZSAoZmFsc2UpCisKIElOTElORSBkb3VibGUKIFhGTE9BVElOVCAoTGlzcF9P YmplY3QgbikKIHsKZGlmZiAtLWdpdCBhL3NyYy9wcm9jZXNzLmMgYi9zcmMvcHJvY2Vzcy5jCmlu ZGV4IDY3MTdjY2I0MTguLjZiYzNjNzUxOTAgMTAwNjQ0Ci0tLSBhL3NyYy9wcm9jZXNzLmMKKysr IGIvc3JjL3Byb2Nlc3MuYwpAQCAtMjY3Myw3ICsyNjczLDcgQEAgY29udl9saXNwX3RvX3NvY2th ZGRyIChpbnQgZmFtaWx5LCBMaXNwX09iamVjdCBhZGRyZXNzLCBzdHJ1Y3Qgc29ja2FkZHIgKnNh LCBpbnQKIAkgIGhvc3Rwb3J0ID0gWEZJWE5VTSAocC0+Y29udGVudHNbLS1sZW5dKTsKIAkgIHNp bjYtPnNpbjZfcG9ydCA9IGh0b25zIChob3N0cG9ydCk7CiAJICBmb3IgKGkgPSAwOyBpIDwgbGVu OyBpKyspCi0JICAgIGlmIChGSVhOVU1QIChwLT5jb250ZW50c1tpXSkpCisJICAgIGlmIChGSVhO QVRQIChwLT5jb250ZW50c1tpXSkpCiAJICAgICAgewogCQlpbnQgaiA9IFhGSVhOQVQgKHAtPmNv bnRlbnRzW2ldKSAmIDB4ZmZmZjsKIAkJaXA2W2ldID0gbnRvaHMgKGopOwpkaWZmIC0tZ2l0IGEv c3JjL3RleHRwcm9wLmMgYi9zcmMvdGV4dHByb3AuYwppbmRleCBhZTQyYzQ0MTg1Li42YjIwYTM0 ODIwIDEwMDY0NAotLS0gYS9zcmMvdGV4dHByb3AuYworKysgYi9zcmMvdGV4dHByb3AuYwpAQCAt MTM0LDggKzEzNCw4IEBAIHZhbGlkYXRlX2ludGVydmFsX3JhbmdlIChMaXNwX09iamVjdCBvYmpl Y3QsIExpc3BfT2JqZWN0ICpiZWdpbiwKICAgcHRyZGlmZl90IHNlYXJjaHBvczsKIAogICBDSEVD S19TVFJJTkdfT1JfQlVGRkVSIChvYmplY3QpOwotICBDSEVDS19GSVhOVU1fQ09FUkNFX01BUktF UiAoKmJlZ2luKTsKLSAgQ0hFQ0tfRklYTlVNX0NPRVJDRV9NQVJLRVIgKCplbmQpOworICBDSEVD S19GSVhOQVRfQ09FUkNFX01BUktFUiAoKmJlZ2luKTsKKyAgQ0hFQ0tfRklYTkFUX0NPRVJDRV9N QVJLRVIgKCplbmQpOwogCiAgIC8qIElmIHdlIGFyZSBhc2tlZCBmb3IgYSBwb2ludCwgYnV0IGZy b20gYSBzdWJyIHdoaWNoIG9wZXJhdGVzCiAgICAgIG9uIGEgcmFuZ2UsIHRoZW4gcmV0dXJuIG5v dGhpbmcuICAqLwpAQCAtNzkwLDE0ICs3OTAsMTQgQEAgREVGVU4gKCJuZXh0LXNpbmdsZS1jaGFy LXByb3BlcnR5LWNoYW5nZSIsIEZuZXh0X3NpbmdsZV9jaGFyX3Byb3BlcnR5X2NoYW5nZSwKIAkg IEZzZXRfYnVmZmVyIChvYmplY3QpOwogCX0KIAotICAgICAgQ0hFQ0tfRklYTlVNX0NPRVJDRV9N QVJLRVIgKHBvc2l0aW9uKTsKKyAgICAgIENIRUNLX0ZJWE5BVF9DT0VSQ0VfTUFSS0VSIChwb3Np dGlvbik7CiAKICAgICAgIGluaXRpYWxfdmFsdWUgPSBGZ2V0X2NoYXJfcHJvcGVydHkgKHBvc2l0 aW9uLCBwcm9wLCBvYmplY3QpOwogCiAgICAgICBpZiAoTklMUCAobGltaXQpKQogCVhTRVRGQVNU SU5UIChsaW1pdCwgWlYpOwogICAgICAgZWxzZQotCUNIRUNLX0ZJWE5VTV9DT0VSQ0VfTUFSS0VS IChsaW1pdCk7CisJQ0hFQ0tfRklYTkFUX0NPRVJDRV9NQVJLRVIgKGxpbWl0KTsKIAogICAgICAg aWYgKFhGSVhOQVQgKHBvc2l0aW9uKSA+PSBYRklYTkFUIChsaW1pdCkpCiAJewpAQCAtODc0LDEy ICs4NzQsMTIgQEAgREVGVU4gKCJwcmV2aW91cy1zaW5nbGUtY2hhci1wcm9wZXJ0eS1jaGFuZ2Ui LAogCSAgRnNldF9idWZmZXIgKG9iamVjdCk7CiAJfQogCi0gICAgICBDSEVDS19GSVhOVU1fQ09F UkNFX01BUktFUiAocG9zaXRpb24pOworICAgICAgQ0hFQ0tfRklYTkFUX0NPRVJDRV9NQVJLRVIg KHBvc2l0aW9uKTsKIAogICAgICAgaWYgKE5JTFAgKGxpbWl0KSkKIAlYU0VURkFTVElOVCAobGlt aXQsIEJFR1YpOwogICAgICAgZWxzZQotCUNIRUNLX0ZJWE5VTV9DT0VSQ0VfTUFSS0VSIChsaW1p dCk7CisJQ0hFQ0tfRklYTkFUX0NPRVJDRV9NQVJLRVIgKGxpbWl0KTsKIAogICAgICAgaWYgKFhG SVhOQVQgKHBvc2l0aW9uKSA8PSBYRklYTkFUIChsaW1pdCkpCiAJewpAQCAtOTQyLDcgKzk0Miw3 IEBAIERFRlVOICgibmV4dC1wcm9wZXJ0eS1jaGFuZ2UiLCBGbmV4dF9wcm9wZXJ0eV9jaGFuZ2Us CiAgICAgWFNFVEJVRkZFUiAob2JqZWN0LCBjdXJyZW50X2J1ZmZlcik7CiAKICAgaWYgKCFOSUxQ IChsaW1pdCkgJiYgIUVRIChsaW1pdCwgUXQpKQotICAgIENIRUNLX0ZJWE5VTV9DT0VSQ0VfTUFS S0VSIChsaW1pdCk7CisgICAgQ0hFQ0tfRklYTkFUX0NPRVJDRV9NQVJLRVIgKGxpbWl0KTsKIAog ICBpID0gdmFsaWRhdGVfaW50ZXJ2YWxfcmFuZ2UgKG9iamVjdCwgJnBvc2l0aW9uLCAmcG9zaXRp b24sIHNvZnQpOwogCkBAIC05NzUsNyArOTc1LDcgQEAgREVGVU4gKCJuZXh0LXByb3BlcnR5LWNo YW5nZSIsIEZuZXh0X3Byb3BlcnR5X2NoYW5nZSwKIAogICBpZiAoIW5leHQKICAgICAgIHx8IChu ZXh0LT5wb3NpdGlvbgotCSAgPj0gKEZJWE5VTVAgKGxpbWl0KQorCSAgPj0gKEZJWE5BVFAgKGxp bWl0KQogCSAgICAgID8gWEZJWE5BVCAobGltaXQpCiAJICAgICAgOiAoU1RSSU5HUCAob2JqZWN0 KQogCQkgPyBTQ0hBUlMgKG9iamVjdCkKQEAgLTEwMDksNyArMTAwOSw3IEBAIERFRlVOICgibmV4 dC1zaW5nbGUtcHJvcGVydHktY2hhbmdlIiwgRm5leHRfc2luZ2xlX3Byb3BlcnR5X2NoYW5nZSwK ICAgICBYU0VUQlVGRkVSIChvYmplY3QsIGN1cnJlbnRfYnVmZmVyKTsKIAogICBpZiAoIU5JTFAg KGxpbWl0KSkKLSAgICBDSEVDS19GSVhOVU1fQ09FUkNFX01BUktFUiAobGltaXQpOworICAgIENI RUNLX0ZJWE5BVF9DT0VSQ0VfTUFSS0VSIChsaW1pdCk7CiAKICAgaSA9IHZhbGlkYXRlX2ludGVy dmFsX3JhbmdlIChvYmplY3QsICZwb3NpdGlvbiwgJnBvc2l0aW9uLCBzb2Z0KTsKICAgaWYgKCFp KQpAQCAtMTAyNCw3ICsxMDI0LDcgQEAgREVGVU4gKCJuZXh0LXNpbmdsZS1wcm9wZXJ0eS1jaGFu Z2UiLCBGbmV4dF9zaW5nbGVfcHJvcGVydHlfY2hhbmdlLAogCiAgIGlmICghbmV4dAogICAgICAg fHwgKG5leHQtPnBvc2l0aW9uCi0JICA+PSAoRklYTlVNUCAobGltaXQpCisJICA+PSAoRklYTkFU UCAobGltaXQpCiAJICAgICAgPyBYRklYTkFUIChsaW1pdCkKIAkgICAgICA6IChTVFJJTkdQIChv YmplY3QpCiAJCSA/IFNDSEFSUyAob2JqZWN0KQpAQCAtMTA1Niw3ICsxMDU2LDcgQEAgREVGVU4g KCJwcmV2aW91cy1wcm9wZXJ0eS1jaGFuZ2UiLCBGcHJldmlvdXNfcHJvcGVydHlfY2hhbmdlLAog ICAgIFhTRVRCVUZGRVIgKG9iamVjdCwgY3VycmVudF9idWZmZXIpOwogCiAgIGlmICghTklMUCAo bGltaXQpKQotICAgIENIRUNLX0ZJWE5VTV9DT0VSQ0VfTUFSS0VSIChsaW1pdCk7CisgICAgQ0hF Q0tfRklYTkFUX0NPRVJDRV9NQVJLRVIgKGxpbWl0KTsKIAogICBpID0gdmFsaWRhdGVfaW50ZXJ2 YWxfcmFuZ2UgKG9iamVjdCwgJnBvc2l0aW9uLCAmcG9zaXRpb24sIHNvZnQpOwogICBpZiAoIWkp CkBAIC0xMDc0LDcgKzEwNzQsNyBAQCBERUZVTiAoInByZXZpb3VzLXByb3BlcnR5LWNoYW5nZSIs IEZwcmV2aW91c19wcm9wZXJ0eV9jaGFuZ2UsCiAKICAgaWYgKCFwcmV2aW91cwogICAgICAgfHwg KHByZXZpb3VzLT5wb3NpdGlvbiArIExFTkdUSCAocHJldmlvdXMpCi0JICA8PSAoRklYTlVNUCAo bGltaXQpCisJICA8PSAoRklYTkFUUCAobGltaXQpCiAJICAgICAgPyBYRklYTkFUIChsaW1pdCkK IAkgICAgICA6IChTVFJJTkdQIChvYmplY3QpID8gMCA6IEJVRl9CRUdWIChYQlVGRkVSIChvYmpl Y3QpKSkpKSkKICAgICByZXR1cm4gbGltaXQ7CkBAIC0xMTA2LDcgKzExMDYsNyBAQCBERUZVTiAo InByZXZpb3VzLXNpbmdsZS1wcm9wZXJ0eS1jaGFuZ2UiLCBGcHJldmlvdXNfc2luZ2xlX3Byb3Bl cnR5X2NoYW5nZSwKICAgICBYU0VUQlVGRkVSIChvYmplY3QsIGN1cnJlbnRfYnVmZmVyKTsKIAog ICBpZiAoIU5JTFAgKGxpbWl0KSkKLSAgICBDSEVDS19GSVhOVU1fQ09FUkNFX01BUktFUiAobGlt aXQpOworICAgIENIRUNLX0ZJWE5BVF9DT0VSQ0VfTUFSS0VSIChsaW1pdCk7CiAKICAgaSA9IHZh bGlkYXRlX2ludGVydmFsX3JhbmdlIChvYmplY3QsICZwb3NpdGlvbiwgJnBvc2l0aW9uLCBzb2Z0 KTsKIApAQCAtMTEyNyw3ICsxMTI3LDcgQEAgREVGVU4gKCJwcmV2aW91cy1zaW5nbGUtcHJvcGVy dHktY2hhbmdlIiwgRnByZXZpb3VzX3NpbmdsZV9wcm9wZXJ0eV9jaGFuZ2UsCiAKICAgaWYgKCFw cmV2aW91cwogICAgICAgfHwgKHByZXZpb3VzLT5wb3NpdGlvbiArIExFTkdUSCAocHJldmlvdXMp Ci0JICA8PSAoRklYTlVNUCAobGltaXQpCisJICA8PSAoRklYTkFUUCAobGltaXQpCiAJICAgICAg PyBYRklYTkFUIChsaW1pdCkKIAkgICAgICA6IChTVFJJTkdQIChvYmplY3QpID8gMCA6IEJVRl9C RUdWIChYQlVGRkVSIChvYmplY3QpKSkpKSkKICAgICByZXR1cm4gbGltaXQ7CkBAIC0xMzUzLDgg KzEzNTMsOCBAQCBzZXRfdGV4dF9wcm9wZXJ0aWVzIChMaXNwX09iamVjdCBzdGFydCwgTGlzcF9P YmplY3QgZW5kLCBMaXNwX09iamVjdCBwcm9wZXJ0aWVzLAogICAvKiBJZiB3ZSB3YW50IG5vIHBy b3BlcnRpZXMgZm9yIGEgd2hvbGUgc3RyaW5nLAogICAgICBnZXQgcmlkIG9mIGl0cyBpbnRlcnZh bHMuICAqLwogICBpZiAoTklMUCAocHJvcGVydGllcykgJiYgU1RSSU5HUCAob2JqZWN0KQotICAg ICAgJiYgWEZJWE5BVCAoc3RhcnQpID09IDAKLSAgICAgICYmIFhGSVhOQVQgKGVuZCkgPT0gU0NI QVJTIChvYmplY3QpKQorICAgICAgJiYgRklYTkFUUCAoc3RhcnQpICYmIFhGSVhOQVQgKHN0YXJ0 KSA9PSAwCisgICAgICAmJiBGSVhOQVRQIChlbmQpICYmIFhGSVhOQVQgKGVuZCkgPT0gU0NIQVJT IChvYmplY3QpKQogICAgIHsKICAgICAgIGlmICghc3RyaW5nX2ludGVydmFscyAob2JqZWN0KSkK IAlyZXR1cm4gUW5pbDsKZGlmZiAtLWdpdCBhL3NyYy93MzJ0ZXJtLmMgYi9zcmMvdzMydGVybS5j CmluZGV4IDU3MjYxMjRiMGUuLjg4NmZjNmM3NTEgMTAwNjQ0Ci0tLSBhL3NyYy93MzJ0ZXJtLmMK KysrIGIvc3JjL3czMnRlcm0uYwpAQCAtMjQ2Myw3ICsyNDYzLDcgQEAgdzMyX2RyYXdfZ2x5cGhf c3RyaW5nIChzdHJ1Y3QgZ2x5cGhfc3RyaW5nICpzKQogCQkgIExpc3BfT2JqZWN0IHZhbAogCQkg ICAgPSBidWZmZXJfbG9jYWxfdmFsdWUgKFF1bmRlcmxpbmVfbWluaW11bV9vZmZzZXQsCiAJCQkJ CXMtPnctPmNvbnRlbnRzKTsKLQkJICBpZiAoRklYTlVNUCAodmFsKSkKKwkJICBpZiAoRklYTkFU UCAodmFsKSkKIAkJICAgIG1pbmltdW1fb2Zmc2V0ID0gWEZJWE5BVCAodmFsKTsKIAkJICBlbHNl CiAJCSAgICBtaW5pbXVtX29mZnNldCA9IDE7CmRpZmYgLS1naXQgYS9zcmMveHRlcm0uYyBiL3Ny Yy94dGVybS5jCmluZGV4IDFhY2ZmMmFmMGQuLjY0NDY3ZTBkOTIgMTAwNjQ0Ci0tLSBhL3NyYy94 dGVybS5jCisrKyBiL3NyYy94dGVybS5jCkBAIC0zODA2LDcgKzM4MDYsNyBAQCB4X2RyYXdfZ2x5 cGhfc3RyaW5nIChzdHJ1Y3QgZ2x5cGhfc3RyaW5nICpzKQogCQkgIExpc3BfT2JqZWN0IHZhbAog CQkgICAgPSBidWZmZXJfbG9jYWxfdmFsdWUgKFF1bmRlcmxpbmVfbWluaW11bV9vZmZzZXQsCiAJ CQkJCSAgcy0+dy0+Y29udGVudHMpOwotCQkgIGlmIChGSVhOVU1QICh2YWwpKQorCQkgIGlmIChG SVhOQVRQICh2YWwpKQogCQkgICAgbWluaW11bV9vZmZzZXQgPSBYRklYTkFUICh2YWwpOwogCQkg IGVsc2UKIAkJICAgIG1pbmltdW1fb2Zmc2V0ID0gMTsK --000000000000c7322b058c1f502e-- From debbugs-submit-bounces@debbugs.gnu.org Wed Jun 26 21:10:45 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 01:10:45 +0000 Received: from localhost ([127.0.0.1]:37216 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgIvz-00055G-W8 for submit@debbugs.gnu.org; Wed, 26 Jun 2019 21:10:44 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:52878) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgIvw-00054o-Ef for 36370@debbugs.gnu.org; Wed, 26 Jun 2019 21:10:42 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 21179162615; Wed, 26 Jun 2019 18:10:33 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id C42QFKOO3GBD; Wed, 26 Jun 2019 18:10:31 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 4FF3F162617; Wed, 26 Jun 2019 18:10:31 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id stluvm8FEKuo; Wed, 26 Jun 2019 18:10:31 -0700 (PDT) Received: from Penguin.CS.UCLA.EDU (Penguin.CS.UCLA.EDU [131.179.64.200]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 2ED68162615; Wed, 26 Jun 2019 18:10:31 -0700 (PDT) To: Pip Cet From: Paul Eggert Subject: Re: 27.0.50; XFIXNAT called on negative numbers Openpgp: preference=signencrypt Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= xsFNBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqfhpxxdGA9 Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9XmAAtmXqeZVIYX/UFS 96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Ygd7gx07Auwp7iw7eNvnoDTAl KAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kghy+P6au6PrIIhYraeua7XDdb2LS1en3Ss mE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZK QMr9amVPknjfPmJISqdhgB1DlEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2 Sf1tk5eU8MBiyN/bZ03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujC OJVxq2kljBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6CnrQzvJbB n6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQABzSBQYXVsIEVnZ2Vy dCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PsLBfgQTAQIAKAUCTIByZAIbAwUJEswDAAYLCQgHAwIG FQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRRGw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+t nfrI/C7fAeoFzQ5tVgVinShaPkZo0HTPf18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr 6g/+vtEOKbhleszN2XpJvpwM2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD 0dDiyhlDAq4lOV2mdBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFH s9tuJQvXk9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY 0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8YAZgKJfu oWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHUh6/BmgvdjWPZYFTt N+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1gpzTvPc4qVQinCmIkEFp83zl +G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZzEW4cLSWO387MTK3CzDOx5qe6s4a91Zu ZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh+Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc 1xdhAFHOwU0ETIByZAEQAKaF678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x6 70HRVahAmk0sZpYc25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/ IMnlZRaVlm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46mOhRDC2r FV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x1icmn6xGI45EugJO gec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9DX8njona0gf0s03tocK8kBN6 6UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZazWA5VslvTxpm76hbg5oiAEH/Vg/8MxHyA nPhfrgwyPrmJEcVBafdspJnYQxBYNco2LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA 77BMRnF0FQyE+7AzV79MBN4ykiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0G IPplLz6YhjrbHrPRF1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAHCwWUEGAEC AA8FAkyAcmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UGbPEd7HGF /VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD0Dw+0LYPnUOsQ0KO FxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h8z5ccpG0Qs4bFhdFYnFrEieD LoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZOIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFx c4W1URpAkBCOYJoXvQfD5L3lqAl8TCqDUzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwc XNOdiklGxbmHVG6YGl6g8Lrbsu9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu 5cEq4RDHM44QqPk6l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB 1thMYqlmgdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cXWtkGoi8b uNcby4U= Organization: UCLA Computer Science Department Message-ID: Date: Wed, 26 Jun 2019 18:10:30 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------4AE65539A8385E3DDA48708E" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------4AE65539A8385E3DDA48708E Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Thanks for looking into this. Cleaning this up has been on my to-do list for a while, and something along these lines has been discussed on the mailing list. Some comments on your fixes: * The ccl.c, fileio.c, image.c, and process.c fixes should use XFIXNUM, not XFIXNAT, since the code is range-checking after extraction anyway and the latter range-checking should do the right thing. Come to think of it, the ccl.c and image.c code is buggy regardless of the XFIXNUM/XFIXNAT business since the Emacs integer might not fit into int range, and that should be fixed too. * Instead of adding a new macro CHECK_FIXNAT_COERCE_MARKER, the code should stick with CHECK_FIXNUM_COERCE_MARKER and do the usual range-checking on the results. This should yield more-precise diagnostics. Most of the range-checking is there already. * The set_text_properties fix can be done more efficiently via EQ. * I'm mildly inclined to think that w32term.c and xterm.c should treate negative minimum values as 0 when the actual value must be nonnegative. That is, a negative minimum should act like a minimum of 0, not as a minimum of 1 as in your proposed patch. To help prevent similar problems in the future, XFIXNUM, XFIXNAT etc. should check that their arguments are of the proper type when ENABLE_CHECKING is nonzero. A proposed patch is attached; it should do all the above. PS. At some point we should also check that make_fixnum is invoked only on values in fixnum range, but that's a matter for a later patch. --------------4AE65539A8385E3DDA48708E Content-Type: text/x-patch; name="0001-Clean-up-use-of-XFIXNUM-etc.patch" Content-Disposition: attachment; filename="0001-Clean-up-use-of-XFIXNUM-etc.patch" Content-Transfer-Encoding: quoted-printable >From bdec4f8e8d7278d68d3534b87c29362ffcbe23d2 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 26 Jun 2019 17:52:06 -0700 Subject: [PATCH] Clean up use of XFIXNUM etc. MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit A few bits of the code were relying on the fact that XFIXNUM, XFIXNAT, and XUFIXNUM do something even with arguments that are not fixnums/fixnats. Separate these rare uses out into XFIXNUM_RAW and XUFIXNUM_RAW. Problem and original patch reported by Pip Cet (Bug#36370). * src/ccl.c (Fccl_execute_on_string): * src/fileio.c (Finsert_file_contents, a_write) (Fdo_auto_save): * src/process.c (conv_lisp_to_sockaddr): * src/textprop.c (Fnext_single_char_property_change) (Fprevious_single_char_property_change) (Fnext_property_change, Fnext_single_property_change) (Fprevious_property_change) (Fprevious_single_property_change): Don=E2=80=99t assume fixnums are nonnegative. * src/ccl.c (Fccl_execute_on_string): Fix range-checking bug if AREF (status, i) is out of int range. * src/data.c (arith_driver): Use XFIXNUM_RAW as we want efficient garbage if the value is not a fixnum. * src/dosfns.c (Fint86, Fdos_memput): Check that args are nonnegative. * src/image.c (lookup_image): Check that args are in range. * src/lisp.h (lisp_h_XHASH): Use XUFIXNUM_RAW, since this is for hashing. (lisp_h_XFIXNAT, XFIXNAT) [USE_LSB_TAG]: Remove macros. (lisp_h_XFIXNUM_RAW, XFIXNUM_RAW) [USE_LSB_TAG]: New macros, with the semantics of the old macros without _RAW. (XFIXNUM_RAW, XUFIXNUM_RAW): New inline functions, with the semantics of the old functions without _RAW. (FIXNUMP): Move definition up to avoid forward use. (XFIXNUM, XFIXNAT, XUFIXNUM): Use eassume to add a runtime check (when debugging) that the argument has the proper form. (XFIXNUM, XFIXNAT): Now inline functions only, since they refer to their arguments more than once now that they use eassume. * src/textprop.c (Fprevious_single_char_property_change): Avoid fixnum overflow with invalid input. (set_text_properties): Fix unlikely failure to validate arguments, by using EQ instead of XFIXNAT. * src/w32term.c (w32_draw_glyph_string): * src/xterm.c (x_draw_glyph_string): Treat negative minimums as 0 rather than as garbage patterns. --- src/ccl.c | 6 ++-- src/data.c | 2 +- src/dosfns.c | 4 +-- src/fileio.c | 6 ++-- src/image.c | 4 +-- src/lisp.h | 75 +++++++++++++++++++++++++------------------------- src/process.c | 2 +- src/textprop.c | 29 +++++++++---------- src/w32term.c | 2 +- src/xterm.c | 2 +- 10 files changed, 67 insertions(+), 65 deletions(-) diff --git a/src/ccl.c b/src/ccl.c index ec108e30d8..f1d4c28df1 100644 --- a/src/ccl.c +++ b/src/ccl.c @@ -2064,9 +2064,9 @@ #define CCL_EXECUTE_BUF_SIZE 1024 } if (FIXNUMP (AREF (status, i))) { - i =3D XFIXNAT (AREF (status, 8)); - if (ccl.ic < i && i < ccl.size) - ccl.ic =3D i; + EMACS_INT ic =3D XFIXNUM (AREF (status, i)); + if (ccl.ic < ic && ic < ccl.size) + ccl.ic =3D ic; } =20 buf_magnification =3D ccl.buf_magnification ? ccl.buf_magnification : = 1; diff --git a/src/data.c b/src/data.c index c1699aeae7..46bd7e0e25 100644 --- a/src/data.c +++ b/src/data.c @@ -2928,7 +2928,7 @@ arith_driver (enum arithop code, ptrdiff_t nargs, L= isp_Object *args, ptrdiff_t argnum =3D 0; /* Set ACCUM to VAL's value if it is a fixnum, otherwise to some ignored value to avoid using an uninitialized variable later. */ - intmax_t accum =3D XFIXNUM (val); + intmax_t accum =3D XFIXNUM_RAW (val); =20 if (FIXNUMP (val)) while (true) diff --git a/src/dosfns.c b/src/dosfns.c index 47c545007a..fb5bcc9ad3 100644 --- a/src/dosfns.c +++ b/src/dosfns.c @@ -72,7 +72,7 @@ DEFUN ("int86", Fint86, Sint86, 2, 2, 0, if (no < 0 || no > 0xff || ASIZE (registers) !=3D 8) return Qnil; for (i =3D 0; i < 8; i++) - CHECK_FIXNUM (AREF (registers, i)); + CHECK_FIXNAT (AREF (registers, i)); =20 inregs.x.ax =3D (unsigned long) XFIXNAT (AREF (registers, 0)); inregs.x.bx =3D (unsigned long) XFIXNAT (AREF (registers, 1)); @@ -139,7 +139,7 @@ DEFUN ("msdos-memput", Fdos_memput, Sdos_memput, 2, 2= , 0, =20 for (i =3D 0; i < len; i++) { - CHECK_FIXNUM (AREF (vector, i)); + CHECK_FIXNAT (AREF (vector, i)); buf[i] =3D (unsigned char) XFIXNAT (AREF (vector, i)) & 0xFF; } =20 diff --git a/src/fileio.c b/src/fileio.c index 0da9894a73..61e10dac47 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -4720,7 +4720,7 @@ because (1) it preserves some marker positions and = (2) it puts less data Lisp_Object tem =3D XCAR (old_undo); if (CONSP (tem) && FIXNUMP (XCAR (tem)) && FIXNUMP (XCDR (tem)) - && XFIXNAT (XCDR (tem)) =3D=3D PT + old_inserted) + && XFIXNUM (XCDR (tem)) =3D=3D PT + old_inserted) XSETCDR (tem, make_fixnum (PT + inserted)); } } @@ -5392,7 +5392,7 @@ a_write (int desc, Lisp_Object string, ptrdiff_t po= s, tem =3D Fcar_safe (Fcar (*annot)); nextpos =3D pos - 1; if (FIXNUMP (tem)) - nextpos =3D XFIXNAT (tem); + nextpos =3D XFIXNUM (tem); =20 /* If there are no more annotations in this range, output the rest of the range all at once. */ @@ -5850,7 +5850,7 @@ DEFUN ("do-auto-save", Fdo_auto_save, Sdo_auto_save= , 0, 2, "", && FIXNUMP (BVAR (b, save_length)) /* A short file is likely to change a large fraction; spare the user annoying messages. */ - && XFIXNAT (BVAR (b, save_length)) > 5000 + && XFIXNUM (BVAR (b, save_length)) > 5000 && (growth_factor * (BUF_Z (b) - BUF_BEG (b)) < (growth_factor - 1) * XFIXNAT (BVAR (b, save_length))) /* These messages are frequent and annoying for `*mail*'. */ diff --git a/src/image.c b/src/image.c index 7b648c46ae..d204749631 100644 --- a/src/image.c +++ b/src/image.c @@ -2385,13 +2385,13 @@ lookup_image (struct frame *f, Lisp_Object spec) #endif =20 ascent =3D image_spec_value (spec, QCascent, NULL); - if (FIXNUMP (ascent)) + if (RANGED_FIXNUMP (0, ascent, INT_MAX)) img->ascent =3D XFIXNAT (ascent); else if (EQ (ascent, Qcenter)) img->ascent =3D CENTERED_IMAGE_ASCENT; =20 margin =3D image_spec_value (spec, QCmargin, NULL); - if (FIXNUMP (margin)) + if (RANGED_FIXNUMP (0, margin, INT_MAX)) img->vmargin =3D img->hmargin =3D XFIXNAT (margin); else if (CONSP (margin)) { diff --git a/src/lisp.h b/src/lisp.h index 77fc22d118..077d236065 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -414,12 +414,11 @@ #define lisp_h_XCAR(c) XCONS (c)->u.s.car #define lisp_h_XCDR(c) XCONS (c)->u.s.u.cdr #define lisp_h_XCONS(a) \ (eassert (CONSP (a)), XUNTAG (a, Lisp_Cons, struct Lisp_Cons)) -#define lisp_h_XHASH(a) XUFIXNUM (a) +#define lisp_h_XHASH(a) XUFIXNUM_RAW (a) #if USE_LSB_TAG # define lisp_h_make_fixnum(n) \ XIL ((EMACS_INT) (((EMACS_UINT) (n) << INTTYPEBITS) + Lisp_Int0)) -# define lisp_h_XFIXNAT(a) XFIXNUM (a) -# define lisp_h_XFIXNUM(a) (XLI (a) >> INTTYPEBITS) +# define lisp_h_XFIXNUM_RAW(a) (XLI (a) >> INTTYPEBITS) # define lisp_h_XTYPE(a) ((enum Lisp_Type) (XLI (a) & ~VALMASK)) #endif =20 @@ -460,8 +459,7 @@ #define lisp_h_XHASH(a) XUFIXNUM (a) # define XHASH(a) lisp_h_XHASH (a) # if USE_LSB_TAG # define make_fixnum(n) lisp_h_make_fixnum (n) -# define XFIXNAT(a) lisp_h_XFIXNAT (a) -# define XFIXNUM(a) lisp_h_XFIXNUM (a) +# define XFIXNUM_RAW(a) lisp_h_XFIXNUM_RAW (a) # define XTYPE(a) lisp_h_XTYPE (a) # endif #endif @@ -1141,17 +1139,9 @@ #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_F= IXNUM) } =20 INLINE EMACS_INT -(XFIXNUM) (Lisp_Object a) +(XFIXNUM_RAW) (Lisp_Object a) { - return lisp_h_XFIXNUM (a); -} - -INLINE EMACS_INT -(XFIXNAT) (Lisp_Object a) -{ - EMACS_INT n =3D lisp_h_XFIXNAT (a); - eassume (0 <=3D n); - return n; + return lisp_h_XFIXNUM_RAW (a); } =20 #else /* ! USE_LSB_TAG */ @@ -1179,9 +1169,11 @@ make_fixnum (EMACS_INT n) return XIL (n); } =20 -/* Extract A's value as a signed integer. */ +/* Extract A's value as a signed integer. Unlike XFIXNUM, this works + on any Lisp object, although the resulting integer is useful only + for things like hashing when A is not a fixnum. */ INLINE EMACS_INT -XFIXNUM (Lisp_Object a) +XFIXNUM_RAW (Lisp_Object a) { EMACS_INT i =3D XLI (a); if (! USE_LSB_TAG) @@ -1192,31 +1184,36 @@ XFIXNUM (Lisp_Object a) return i >> INTTYPEBITS; } =20 -/* Like XFIXNUM (A), but may be faster. A must be nonnegative. - If ! USE_LSB_TAG, this takes advantage of the fact that Lisp - integers have zero-bits in their tags. */ -INLINE EMACS_INT -XFIXNAT (Lisp_Object a) +#endif /* ! USE_LSB_TAG */ + +INLINE bool +(FIXNUMP) (Lisp_Object x) { - EMACS_INT int0 =3D Lisp_Int0; - EMACS_INT n =3D USE_LSB_TAG ? XFIXNUM (a) : XLI (a) - (int0 << VALBITS= ); - eassume (0 <=3D n); - return n; + return lisp_h_FIXNUMP (x); } =20 -#endif /* ! USE_LSB_TAG */ +INLINE EMACS_INT +XFIXNUM (Lisp_Object a) +{ + eassume (FIXNUMP (a)); + return XFIXNUM_RAW (a); +} =20 /* Extract A's value as an unsigned integer in the range 0..INTMASK. */ INLINE EMACS_UINT -XUFIXNUM (Lisp_Object a) +XUFIXNUM_RAW (Lisp_Object a) { EMACS_UINT i =3D XLI (a); return USE_LSB_TAG ? i >> INTTYPEBITS : i & INTMASK; } +INLINE EMACS_UINT +XUFIXNUM (Lisp_Object a) +{ + eassume (FIXNUMP (a)); + return XUFIXNUM_RAW (a); +} =20 -/* Return A's hash, which is in the range 0..INTMASK. Although XHASH (A= ) =3D=3D - XUFIXNUM (A) currently, XUFIXNUM should be applied only to fixnums. = */ - +/* Return A's hash, which is in the range 0..INTMASK. */ INLINE EMACS_INT (XHASH) (Lisp_Object a) { @@ -1261,12 +1258,6 @@ make_lisp_ptr (void *ptr, enum Lisp_Type type) return a; } =20 -INLINE bool -(FIXNUMP) (Lisp_Object x) -{ - return lisp_h_FIXNUMP (x); -} - #define XSETINT(a, b) ((a) =3D make_fixnum (b)) #define XSETFASTINT(a, b) ((a) =3D make_fixed_natnum (b)) #define XSETCONS(a, b) ((a) =3D make_lisp_ptr (b, Lisp_Cons)) @@ -2832,6 +2823,16 @@ FIXNATP (Lisp_Object x) { return FIXNUMP (x) && 0 <=3D XFIXNUM (x); } + +/* Like XFIXNUM (A), but may be faster. A must be nonnegative. */ +INLINE EMACS_INT +XFIXNAT (Lisp_Object a) +{ + eassume (FIXNATP (a)); + EMACS_INT int0 =3D Lisp_Int0; + return USE_LSB_TAG ? XFIXNUM (a) : XLI (a) - (int0 << VALBITS); +} + INLINE bool NUMBERP (Lisp_Object x) { diff --git a/src/process.c b/src/process.c index 15d87cf601..cab390c10c 100644 --- a/src/process.c +++ b/src/process.c @@ -2675,7 +2675,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object addr= ess, struct sockaddr *sa, int for (i =3D 0; i < len; i++) if (FIXNUMP (p->contents[i])) { - int j =3D XFIXNAT (p->contents[i]) & 0xffff; + int j =3D XFIXNUM (p->contents[i]) & 0xffff; ip6[i] =3D ntohs (j); } sa->sa_family =3D family; diff --git a/src/textprop.c b/src/textprop.c index ae42c44185..3026ec7e99 100644 --- a/src/textprop.c +++ b/src/textprop.c @@ -799,7 +799,7 @@ DEFUN ("next-single-char-property-change", Fnext_sing= le_char_property_change, else CHECK_FIXNUM_COERCE_MARKER (limit); =20 - if (XFIXNAT (position) >=3D XFIXNAT (limit)) + if (XFIXNAT (position) >=3D XFIXNUM (limit)) { position =3D limit; if (XFIXNAT (position) > ZV) @@ -881,16 +881,17 @@ DEFUN ("previous-single-char-property-change", else CHECK_FIXNUM_COERCE_MARKER (limit); =20 - if (XFIXNAT (position) <=3D XFIXNAT (limit)) + if (XFIXNUM (position) <=3D XFIXNUM (limit)) { position =3D limit; - if (XFIXNAT (position) < BEGV) + if (XFIXNUM (position) < BEGV) XSETFASTINT (position, BEGV); } else { Lisp_Object initial_value - =3D Fget_char_property (make_fixnum (XFIXNAT (position) - 1), + =3D Fget_char_property (make_fixnum (XFIXNUM (position) + - (0 <=3D XFIXNUM (position))), prop, object); =20 while (true) @@ -970,13 +971,13 @@ DEFUN ("next-property-change", Fnext_property_chang= e, next =3D next_interval (i); =20 while (next && intervals_equal (i, next) - && (NILP (limit) || next->position < XFIXNAT (limit))) + && (NILP (limit) || next->position < XFIXNUM (limit))) next =3D next_interval (next); =20 if (!next || (next->position >=3D (FIXNUMP (limit) - ? XFIXNAT (limit) + ? XFIXNUM (limit) : (STRINGP (object) ? SCHARS (object) : BUF_ZV (XBUFFER (object)))))) @@ -1019,13 +1020,13 @@ DEFUN ("next-single-property-change", Fnext_singl= e_property_change, next =3D next_interval (i); while (next && EQ (here_val, textget (next->plist, prop)) - && (NILP (limit) || next->position < XFIXNAT (limit))) + && (NILP (limit) || next->position < XFIXNUM (limit))) next =3D next_interval (next); =20 if (!next || (next->position >=3D (FIXNUMP (limit) - ? XFIXNAT (limit) + ? XFIXNUM (limit) : (STRINGP (object) ? SCHARS (object) : BUF_ZV (XBUFFER (object)))))) @@ -1069,13 +1070,13 @@ DEFUN ("previous-property-change", Fprevious_prop= erty_change, previous =3D previous_interval (i); while (previous && intervals_equal (previous, i) && (NILP (limit) - || (previous->position + LENGTH (previous) > XFIXNAT (limit)))) + || (previous->position + LENGTH (previous) > XFIXNUM (limit)))) previous =3D previous_interval (previous); =20 if (!previous || (previous->position + LENGTH (previous) <=3D (FIXNUMP (limit) - ? XFIXNAT (limit) + ? XFIXNUM (limit) : (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object)))))) return limit; else @@ -1122,13 +1123,13 @@ DEFUN ("previous-single-property-change", Fprevio= us_single_property_change, while (previous && EQ (here_val, textget (previous->plist, prop)) && (NILP (limit) - || (previous->position + LENGTH (previous) > XFIXNAT (limit)))) + || (previous->position + LENGTH (previous) > XFIXNUM (limit)))) previous =3D previous_interval (previous); =20 if (!previous || (previous->position + LENGTH (previous) <=3D (FIXNUMP (limit) - ? XFIXNAT (limit) + ? XFIXNUM (limit) : (STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object)))))) return limit; else @@ -1353,8 +1354,8 @@ set_text_properties (Lisp_Object start, Lisp_Object= end, Lisp_Object properties, /* If we want no properties for a whole string, get rid of its intervals. */ if (NILP (properties) && STRINGP (object) - && XFIXNAT (start) =3D=3D 0 - && XFIXNAT (end) =3D=3D SCHARS (object)) + && EQ (start, make_fixnum (0)) + && EQ (end, make_fixnum (SCHARS (object)))) { if (!string_intervals (object)) return Qnil; diff --git a/src/w32term.c b/src/w32term.c index 5726124b0e..97a5fc6389 100644 --- a/src/w32term.c +++ b/src/w32term.c @@ -2464,7 +2464,7 @@ w32_draw_glyph_string (struct glyph_string *s) =3D buffer_local_value (Qunderline_minimum_offset, s->w->contents); if (FIXNUMP (val)) - minimum_offset =3D XFIXNAT (val); + minimum_offset =3D max (0, XFIXNUM (val)); else minimum_offset =3D 1; val =3D buffer_local_value (Qx_underline_at_descent_line, diff --git a/src/xterm.c b/src/xterm.c index 1acff2af0d..38bc17de97 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -3807,7 +3807,7 @@ x_draw_glyph_string (struct glyph_string *s) =3D buffer_local_value (Qunderline_minimum_offset, s->w->contents); if (FIXNUMP (val)) - minimum_offset =3D XFIXNAT (val); + minimum_offset =3D max (0, XFIXNUM (val)); else minimum_offset =3D 1; val =3D buffer_local_value (Qx_underline_at_descent_line, --=20 2.21.0 --------------4AE65539A8385E3DDA48708E-- From debbugs-submit-bounces@debbugs.gnu.org Wed Jun 26 21:12:41 2019 Received: (at control) by debbugs.gnu.org; 27 Jun 2019 01:12:41 +0000 Received: from localhost ([127.0.0.1]:37221 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgIxt-00058i-4S for submit@debbugs.gnu.org; Wed, 26 Jun 2019 21:12:41 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:53114) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgIxo-00058P-R0 for control@debbugs.gnu.org; Wed, 26 Jun 2019 21:12:37 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 92D8C162615 for ; Wed, 26 Jun 2019 18:12:31 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id LSYwNFHHWKXh for ; Wed, 26 Jun 2019 18:12:31 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id EA96B162617 for ; Wed, 26 Jun 2019 18:12:30 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id FDphLzfqmd1N for ; Wed, 26 Jun 2019 18:12:30 -0700 (PDT) Received: from Penguin.CS.UCLA.EDU (Penguin.CS.UCLA.EDU [131.179.64.200]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id D31C0162615 for ; Wed, 26 Jun 2019 18:12:30 -0700 (PDT) To: GNU bug control From: Paul Eggert Subject: 36370 has a patch Openpgp: preference=signencrypt Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= xsFNBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqfhpxxdGA9 Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9XmAAtmXqeZVIYX/UFS 96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Ygd7gx07Auwp7iw7eNvnoDTAl KAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kghy+P6au6PrIIhYraeua7XDdb2LS1en3Ss mE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZK QMr9amVPknjfPmJISqdhgB1DlEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2 Sf1tk5eU8MBiyN/bZ03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujC OJVxq2kljBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6CnrQzvJbB n6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQABzSBQYXVsIEVnZ2Vy dCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PsLBfgQTAQIAKAUCTIByZAIbAwUJEswDAAYLCQgHAwIG FQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRRGw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+t nfrI/C7fAeoFzQ5tVgVinShaPkZo0HTPf18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr 6g/+vtEOKbhleszN2XpJvpwM2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD 0dDiyhlDAq4lOV2mdBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFH s9tuJQvXk9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY 0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8YAZgKJfu oWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHUh6/BmgvdjWPZYFTt N+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1gpzTvPc4qVQinCmIkEFp83zl +G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZzEW4cLSWO387MTK3CzDOx5qe6s4a91Zu ZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh+Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc 1xdhAFHOwU0ETIByZAEQAKaF678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x6 70HRVahAmk0sZpYc25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/ IMnlZRaVlm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46mOhRDC2r FV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x1icmn6xGI45EugJO gec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9DX8njona0gf0s03tocK8kBN6 6UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZazWA5VslvTxpm76hbg5oiAEH/Vg/8MxHyA nPhfrgwyPrmJEcVBafdspJnYQxBYNco2LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA 77BMRnF0FQyE+7AzV79MBN4ykiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0G IPplLz6YhjrbHrPRF1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAHCwWUEGAEC AA8FAkyAcmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UGbPEd7HGF /VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD0Dw+0LYPnUOsQ0KO FxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h8z5ccpG0Qs4bFhdFYnFrEieD LoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZOIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFx c4W1URpAkBCOYJoXvQfD5L3lqAl8TCqDUzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwc XNOdiklGxbmHVG6YGl6g8Lrbsu9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu 5cEq4RDHM44QqPk6l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB 1thMYqlmgdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cXWtkGoi8b uNcby4U= Organization: UCLA Computer Science Department Message-ID: Date: Wed, 26 Jun 2019 18:12:30 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: control X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) tags 36370 patch From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 02:17:12 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 06:17:12 +0000 Received: from localhost ([127.0.0.1]:37309 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgNiZ-00006D-OO for submit@debbugs.gnu.org; Thu, 27 Jun 2019 02:17:12 -0400 Received: from mail-ot1-f45.google.com ([209.85.210.45]:46475) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgNiW-00005n-5K for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 02:17:08 -0400 Received: by mail-ot1-f45.google.com with SMTP id z23so1066087ote.13 for <36370@debbugs.gnu.org>; Wed, 26 Jun 2019 23:17:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=4b8IY4y2RuYfORbRCXkWUJJExOrxIXV+Px+OouuCh88=; b=lGf9mMS8Q5MR+0fseDC/PmvD7fQTxnOadxTO8bntodZP3lNYW5NwsrMswW1DS9l61m uzde4IVGbe/ZOOe0zhTWp+N6faIN2oNaJJTNK7YG9VPfGfMjSpzu21/eYCv2OOs8vaqw frGdPCnMV9wUSPAJoa1GYOy0zoPUVq7Rd0lDkZ7fzPGrGBFtKj/pJOM4Yxo/zTvWAv2w 7AfWLfw8XOTuZFFPsEYxKbregp7Q18irsfYjeXEOKwQvYXdU+I3wz34CnayBWVM85jrj yjvvfDtE95s7BBAEyTfC2ehWKbkv8gfpddDOw1+5uZxxxibiu80LNihkR4jJUT4Q443X pG3w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=4b8IY4y2RuYfORbRCXkWUJJExOrxIXV+Px+OouuCh88=; b=PIb6T5IVGesVrhPo1uCQltmieMMnAKh6lu76VRKQhO6LKa29yAM4MxbXDLM0GpP4Ww VtKZxcdEgZRc26hyagGDuisdn4KM+CsYqkCj0F7aN4iKrQIC/NakkZXlYdG5tfvxJCTK jbHSOiPVn8XC17wnrzmT3rMSZOKIjZGkrfNuLMftOvFRMpd211P0D9WEQLztJLwgEDSd liti6iHMlOQOhPRzBXyVFdsGRgEAXfSxoGTHPQ0MSqd3mYGX70mpAGWEfAIbHhR+8us0 poWJbeDYHm8+SanBLbLP4mnK0rzL0b5+D/5aUhayEkuhysZpiyPuR+hPKOf57RCW+PIS l1IA== X-Gm-Message-State: APjAAAU2lqPakSFt490NczAq/juDdp4Q7H8s7yNnjNFi2DLaNK1o3IRB /MEcq7KSZ+1NxhVRXAvXmbdIYLh8EshXTH7rwo4= X-Google-Smtp-Source: APXvYqwWgZF6MPutwjVcC70wSYytVYSZX5Sa2QfGtNaM3joJUkTS4aaZWU3582oHxwHknB9W6ZE+iM92nHB83UgaKWY= X-Received: by 2002:a9d:664c:: with SMTP id q12mr1802698otm.175.1561616222402; Wed, 26 Jun 2019 23:17:02 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Pip Cet Date: Thu, 27 Jun 2019 06:16:25 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Thu, Jun 27, 2019 at 1:11 AM Paul Eggert wrote: > Thanks for looking into this. Cleaning this up has been on my to-do list > for a while, and something along these lines has been discussed on the > mailing list. Some comments on your fixes: I really think I should reiterate that readability is much much more important than whatever performance tweaks XFIXNAT might allow. I'd prefer if the code were written as though FIXNATs weren't FIXNUMs at all: pair FIXNATP with XFIXNAT, and provide FIXNAT versions of CHECK_RANGED_FIXNUM and CHECK_FIXNUM_COERCE_MARKER. Hmm. I'm not sure it's a problem for you, but I'm finding it rather hard to check in all cases whether XFIXNAT is safe. For example, ascent = image_spec_value (spec, QCascent, NULL); if (FIXNUMP (ascent)) img->ascent = XFIXNAT (ascent); in image.c is safe, because lookup_image is called only after valid_image_p. if (FIXNUMP (AREF (status, i))) { - i = XFIXNAT (AREF (status, 8)); - if (ccl.ic < i && i < ccl.size) - ccl.ic = i; + EMACS_INT ic = XFIXNUM (AREF (status, i)); + if (ccl.ic < ic && ic < ccl.size) + ccl.ic = ic; } I'd prefer AREF (status, 8) here, for what readability the code gives us. # define XHASH(a) lisp_h_XHASH (a) # if USE_LSB_TAG # define make_fixnum(n) lisp_h_make_fixnum (n) -# define XFIXNAT(a) lisp_h_XFIXNAT (a) -# define XFIXNUM(a) lisp_h_XFIXNUM (a) +# define XFIXNUM_RAW(a) lisp_h_XFIXNUM_RAW (a) # define XTYPE(a) lisp_h_XTYPE (a) # endif #endif I'd prefer leaving the macros for now; eassume (inline_function (x)) doesn't work very well on current GCC, while eassume (MACRO (x)) is fine, so I'm sometimes building with DEFINE_KEY_OPS_AS_MACROS. (The eassume/eassert situation is something else I've been planning to look at in more detail, though debugging it will be easier when https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91005 is fixed). > * The ccl.c, fileio.c, image.c, and process.c fixes should use XFIXNUM, > not XFIXNAT, since the code is range-checking after extraction anyway > and the latter range-checking should do the right thing. Come to think That's an argument that either XFIXNUM or XFIXNAT are fine, and in this case XFIXNAT seems, to me, much more readable. > of it, the ccl.c and image.c code is buggy regardless of the > XFIXNUM/XFIXNAT business since the Emacs integer might not fit into int > range, and that should be fixed too. I don't see how either ccl.c or image.c are buggy for out-of-range integer arguments. > * Instead of adding a new macro CHECK_FIXNAT_COERCE_MARKER, the code > should stick with CHECK_FIXNUM_COERCE_MARKER and do the usual > range-checking on the results. This should yield more-precise > diagnostics. Most of the range-checking is there already. I disagree, obviously. When you want a position, you want a FIXNAT, not a negative number, so CHECK_FIXNAT_COERCE_MARKER everywhere would catch those cases where someone passes an obviously invalid argument. > * The set_text_properties fix can be done more efficiently via EQ. I suspect your change results in a few more insns being emitted, but I'll have to check. > * I'm mildly inclined to think that w32term.c and xterm.c should treate > negative minimum values as 0 when the actual value must be nonnegative. > That is, a negative minimum should act like a minimum of 0, not as a > minimum of 1 as in your proposed patch. Doesn't matter, so I decided not to fiddle with this code. > To help prevent similar problems in the future, XFIXNUM, XFIXNAT etc. > should check that their arguments are of the proper type when > ENABLE_CHECKING is nonzero. > > A proposed patch is attached; it should do all the above. I'd prefer not touching the dosfns.c code, for the simple reason that if anyone still uses it, they might rely on the broken behavior. > PS. At some point we should also check that make_fixnum is invoked only > on values in fixnum range, but that's a matter for a later patch. Definitely. From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 04:28:43 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 08:28:43 +0000 Received: from localhost ([127.0.0.1]:37376 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgPlq-0003MK-Dw for submit@debbugs.gnu.org; Thu, 27 Jun 2019 04:28:42 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:59232) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgPlm-0003M4-QG for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 04:28:40 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id C31EA161A49; Thu, 27 Jun 2019 01:28:32 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id PdmYkMFWsicR; Thu, 27 Jun 2019 01:28:31 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 33DDF161C38; Thu, 27 Jun 2019 01:28:31 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id sqrgOfTtkGaA; Thu, 27 Jun 2019 01:28:31 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 0A0F1161A49; Thu, 27 Jun 2019 01:28:31 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet References: From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: Date: Thu, 27 Jun 2019 01:28:30 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------3410BBC0447F81BE707959FE" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------3410BBC0447F81BE707959FE Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Pip Cet wrote: > I'd prefer if the code were written as though FIXNATs weren't FIXNUMs at all. I'm more of the opposite opinion. The original reason for XFIXNAT (under its old name) was performance, because long ago Emacs put the type tag in the most significant bits, and it was faster to mask it out than to smear the sign bit when you knew the fixnum was nonnegative. Nowadays that original reason is obsolete because the tags are in the least significant bits and XFIXNAT is just an alias for XFIXNUM, and if it were up to me we'd get rid of XFIXNAT entirely, and just use XFIXNUM. But old habits die hard.... > ascent = image_spec_value (spec, QCascent, NULL); > if (FIXNUMP (ascent)) > img->ascent = XFIXNAT (ascent); > > in image.c is safe, because lookup_image is called only after valid_image_p. Sorry, you've lost me. How does valid_image_p guarantee that 'ascent' (if a fixnum) is in the range 0..INT_MAX? Because if it's not in that range, the above code could trap. > I'd prefer AREF (status, 8) here, for what readability the code gives us. Sure, sounds good. See attached further patch. > I'd prefer leaving the macros for now I actually did it that way at first, but that failed miserably as the macros evaluated their arguments more than once when debugging , and lots of code expects them to behave like functions and evaluate their arguments exactly once. So functions it is. > eassume (inline_function (x)) > doesn't work very well on current GCC, while eassume (MACRO (x)) is > fine, so I'm sometimes building with DEFINE_KEY_OPS_AS_MACROS. Hmm, I see I should have helped GCC more there. First, the two new eassumes should just be easserts as the assumptions are not helpful to the compiler. Second, I should restore the eassume that tells GCC that XFIXNAT returns a nonnegative integer. > (The > eassume/eassert situation is something else I've been planning to look > at in more detail, though debugging it will be easier when > https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91005 is fixed). Sorry, I don't follow. That bug report seems to be about nested C functions; why is it relevant to Emacs, which doesn't use nested C functions? >> * The ccl.c, fileio.c, image.c, and process.c fixes should use XFIXNUM, >> not XFIXNAT, since the code is range-checking after extraction anyway >> and the latter range-checking should do the right thing. Come to think > > That's an argument that either XFIXNUM or XFIXNAT are fine, and in > this case XFIXNAT seems, to me, much more readable. No, as the range-checking is done after the XFIXNAT, which means the XFIXNAT could have an assertion failure. >> of it, the ccl.c and image.c code is buggy regardless of the >> XFIXNUM/XFIXNAT business since the Emacs integer might not fit into int >> range, and that should be fixed too. > > I don't see how either ccl.c or image.c are buggy for out-of-range > integer arguments. For example, ccl.c in master has this: if (FIXNUMP (AREF (status, i))) { i = XFIXNAT (AREF (status, 8)); if (ccl.ic < i && i < ccl.size) ccl.ic = i; } where i is a 32-bit int. If AREF (status, 8) is the 62-bit Lisp fixnum with value '2 * (EMACS_INT) INT_MAX + ccl.ic + 3', the assignment to i overflows, which can trap. Even if the assignment doesn't trap but merely wraps around, the next line won't do range checking correctly. > When you want a position, you want a FIXNAT, > not a negative number, so CHECK_FIXNAT_COERCE_MARKER everywhere would > catch those cases where someone passes an obviously invalid argument. But why stop there? 0 is an obviously invalid argument for buffers. :-) I think this is just an area where we disagree - I want a range check where you want a type check. It's safe either way and the range check is a tad faster (as the range check needs to be done anyway) and results in a crisper diagnostic when it fails. > I'd prefer not touching the dosfns.c code, for the simple reason that > if anyone still uses it, they might rely on the broken behavior. We can't leave it alone, as XFIXNAT is now checking that its result is nonnegative when debugging is enabled. However, we could instead change the XFIXNATs to XFIXNUMs: this will generate exactly the same machine code on that platform when debugging is disabled, and will not trap when debugging is enabled. See attached patch. --------------3410BBC0447F81BE707959FE Content-Type: text/plain; charset=UTF-8; name="0001-Improve-XFIXNUM-cleanup-a-bit.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="0001-Improve-XFIXNUM-cleanup-a-bit.txt" RnJvbSAzZjgwOTBlOTExMjVkZTk4Nzk4ZDRiZmI1ZjkxOTM0YmNhYzk2MjZiIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQYXVsIEVnZ2VydCA8ZWdnZXJ0QGNzLnVjbGEuZWR1 PgpEYXRlOiBUaHUsIDI3IEp1biAyMDE5IDAxOjE0OjUzIC0wNzAwClN1YmplY3Q6IFtQQVRD SF0gSW1wcm92ZSBYRklYTlVNIGNsZWFudXAgYSBiaXQKTUlNRS1WZXJzaW9uOiAxLjAKQ29u dGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CkNvbnRlbnQtVHJhbnNmZXIt RW5jb2Rpbmc6IDhiaXQKCkJhc2VkIG9uIFBpcCBDZXTigJlzIHJldmlldyAoQnVnIzM2Mzcw IzEzKS4KKiBzcmMvY2NsLmMgKEZjY2xfZXhlY3V0ZV9vbl9zdHJpbmcpOiBVc2UgY2xlYXJl ciBpbmRleGluZy4KKiBzcmMvZG9zZm5zLmMgKEZpbnQ4NiwgRmRvc19tZW1wdXQpOgpBdm9p ZCBydW50aW1lIGNoZWNrcyBmb3IgbmVnYXRpdmUgZml4bnVtcyB3aGVuIGRlYnVnZ2luZy4K VGhpcyByZXN0b3JlcyB0aGUgZWFybGllciBtYWNoaW5lIGNvZGUuCiogc3JjL2xpc3AuaCAo WEZJWE5VTSwgWFVGSVhOVU0pOiBVc2UgZWFzc2VydCwgbm90IGVhc3N1bWUuCihYRklYTkFU KTogQXQgdGhlIHN0YXJ0LCBtZXJlbHkgZWFzc2VydCBGSVhOVU1QIHJhdGhlcgp0aGFuIGVh c3N1bWluZyBGSVhOQVRQLiAgQXQgdGhlIGVuZCwgZWFzc3VtZSB0aGF0IHRoZQpyZXN1bHQg aXMgbm9ubmVnYXRpdmUuICBUaGlzIHJlc3RvcmVzIGhlbHAgdG8gdGhlIGNvbXBpbGVyCnRo YXQgdGhlIHByZXZpb3VzIHBhdGNoIG1pc3Rha2VubHkgcmVtb3ZlZC4KLS0tCiBzcmMvY2Ns LmMgICAgfCAgNCArKy0tCiBzcmMvZG9zZm5zLmMgfCAyMiArKysrKysrKysrKy0tLS0tLS0t LS0tCiBzcmMvbGlzcC5oICAgfCAxMCArKysrKystLS0tCiAzIGZpbGVzIGNoYW5nZWQsIDE5 IGluc2VydGlvbnMoKyksIDE3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9jY2wu YyBiL3NyYy9jY2wuYwppbmRleCBmMWQ0YzI4ZGYxLi5mZjQyYzZmMjVmIDEwMDY0NAotLS0g YS9zcmMvY2NsLmMKKysrIGIvc3JjL2NjbC5jCkBAIC0yMDYyLDkgKzIwNjIsOSBAQCAjZGVm aW5lIENDTF9FWEVDVVRFX0JVRl9TSVpFIDEwMjQKICAgICAgIGlmIChUWVBFX1JBTkdFRF9G SVhOVU1QIChpbnQsIEFSRUYgKHN0YXR1cywgaSkpKQogCWNjbC5yZWdbaV0gPSBYRklYTlVN IChBUkVGIChzdGF0dXMsIGkpKTsKICAgICB9Ci0gIGlmIChGSVhOVU1QIChBUkVGIChzdGF0 dXMsIGkpKSkKKyAgaWYgKEZJWE5VTVAgKEFSRUYgKHN0YXR1cywgOCkpKQogICAgIHsKLSAg ICAgIEVNQUNTX0lOVCBpYyA9IFhGSVhOVU0gKEFSRUYgKHN0YXR1cywgaSkpOworICAgICAg RU1BQ1NfSU5UIGljID0gWEZJWE5VTSAoQVJFRiAoc3RhdHVzLCA4KSk7CiAgICAgICBpZiAo Y2NsLmljIDwgaWMgJiYgaWMgPCBjY2wuc2l6ZSkKIAljY2wuaWMgPSBpYzsKICAgICB9CmRp ZmYgLS1naXQgYS9zcmMvZG9zZm5zLmMgYi9zcmMvZG9zZm5zLmMKaW5kZXggZmI1YmNjOWFk My4uNjM1ZjI5YmQ2NSAxMDA2NDQKLS0tIGEvc3JjL2Rvc2Zucy5jCisrKyBiL3NyYy9kb3Nm bnMuYwpAQCAtNzIsMTYgKzcyLDE2IEBAIERFRlVOICgiaW50ODYiLCBGaW50ODYsIFNpbnQ4 NiwgMiwgMiwgMCwKICAgaWYgKG5vIDwgMCB8fCBubyA+IDB4ZmYgfHwgQVNJWkUgKHJlZ2lz dGVycykgIT0gOCkKICAgICByZXR1cm4gUW5pbDsKICAgZm9yIChpID0gMDsgaSA8IDg7IGkr KykKLSAgICBDSEVDS19GSVhOQVQgKEFSRUYgKHJlZ2lzdGVycywgaSkpOworICAgIENIRUNL X0ZJWE5VTSAoQVJFRiAocmVnaXN0ZXJzLCBpKSk7CiAKLSAgaW5yZWdzLnguYXggICAgPSAo dW5zaWduZWQgbG9uZykgWEZJWE5BVCAoQVJFRiAocmVnaXN0ZXJzLCAwKSk7Ci0gIGlucmVn cy54LmJ4ICAgID0gKHVuc2lnbmVkIGxvbmcpIFhGSVhOQVQgKEFSRUYgKHJlZ2lzdGVycywg MSkpOwotICBpbnJlZ3MueC5jeCAgICA9ICh1bnNpZ25lZCBsb25nKSBYRklYTkFUIChBUkVG IChyZWdpc3RlcnMsIDIpKTsKLSAgaW5yZWdzLnguZHggICAgPSAodW5zaWduZWQgbG9uZykg WEZJWE5BVCAoQVJFRiAocmVnaXN0ZXJzLCAzKSk7Ci0gIGlucmVncy54LnNpICAgID0gKHVu c2lnbmVkIGxvbmcpIFhGSVhOQVQgKEFSRUYgKHJlZ2lzdGVycywgNCkpOwotICBpbnJlZ3Mu eC5kaSAgICA9ICh1bnNpZ25lZCBsb25nKSBYRklYTkFUIChBUkVGIChyZWdpc3RlcnMsIDUp KTsKLSAgaW5yZWdzLnguY2ZsYWcgPSAodW5zaWduZWQgbG9uZykgWEZJWE5BVCAoQVJFRiAo cmVnaXN0ZXJzLCA2KSk7Ci0gIGlucmVncy54LmZsYWdzID0gKHVuc2lnbmVkIGxvbmcpIFhG SVhOQVQgKEFSRUYgKHJlZ2lzdGVycywgNykpOworICBpbnJlZ3MueC5heCAgICA9ICh1bnNp Z25lZCBsb25nKSBYRklYTlVNIChBUkVGIChyZWdpc3RlcnMsIDApKTsKKyAgaW5yZWdzLngu YnggICAgPSAodW5zaWduZWQgbG9uZykgWEZJWE5VTSAoQVJFRiAocmVnaXN0ZXJzLCAxKSk7 CisgIGlucmVncy54LmN4ICAgID0gKHVuc2lnbmVkIGxvbmcpIFhGSVhOVU0gKEFSRUYgKHJl Z2lzdGVycywgMikpOworICBpbnJlZ3MueC5keCAgICA9ICh1bnNpZ25lZCBsb25nKSBYRklY TlVNIChBUkVGIChyZWdpc3RlcnMsIDMpKTsKKyAgaW5yZWdzLnguc2kgICAgPSAodW5zaWdu ZWQgbG9uZykgWEZJWE5VTSAoQVJFRiAocmVnaXN0ZXJzLCA0KSk7CisgIGlucmVncy54LmRp ICAgID0gKHVuc2lnbmVkIGxvbmcpIFhGSVhOVU0gKEFSRUYgKHJlZ2lzdGVycywgNSkpOwor ICBpbnJlZ3MueC5jZmxhZyA9ICh1bnNpZ25lZCBsb25nKSBYRklYTlVNIChBUkVGIChyZWdp c3RlcnMsIDYpKTsKKyAgaW5yZWdzLnguZmxhZ3MgPSAodW5zaWduZWQgbG9uZykgWEZJWE5V TSAoQVJFRiAocmVnaXN0ZXJzLCA3KSk7CiAKICAgaW50ODYgKG5vLCAmaW5yZWdzLCAmb3V0 cmVncyk7CiAKQEAgLTEzOSw4ICsxMzksOCBAQCBERUZVTiAoIm1zZG9zLW1lbXB1dCIsIEZk b3NfbWVtcHV0LCBTZG9zX21lbXB1dCwgMiwgMiwgMCwKIAogICBmb3IgKGkgPSAwOyBpIDwg bGVuOyBpKyspCiAgICAgewotICAgICAgQ0hFQ0tfRklYTkFUIChBUkVGICh2ZWN0b3IsIGkp KTsKLSAgICAgIGJ1ZltpXSA9ICh1bnNpZ25lZCBjaGFyKSBYRklYTkFUIChBUkVGICh2ZWN0 b3IsIGkpKSAmIDB4RkY7CisgICAgICBDSEVDS19GSVhOVU0gKEFSRUYgKHZlY3RvciwgaSkp OworICAgICAgYnVmW2ldID0gKHVuc2lnbmVkIGNoYXIpIFhGSVhOVU0gKEFSRUYgKHZlY3Rv ciwgaSkpICYgMHhGRjsKICAgICB9CiAKICAgZG9zbWVtcHV0IChidWYsIGxlbiwgb2Zmcyk7 CmRpZmYgLS1naXQgYS9zcmMvbGlzcC5oIGIvc3JjL2xpc3AuaAppbmRleCAwNzdkMjM2MDY1 Li5hMDYxOWU2NGYyIDEwMDY0NAotLS0gYS9zcmMvbGlzcC5oCisrKyBiL3NyYy9saXNwLmgK QEAgLTExOTUsNyArMTE5NSw3IEBAIFhGSVhOVU1fUkFXIChMaXNwX09iamVjdCBhKQogSU5M SU5FIEVNQUNTX0lOVAogWEZJWE5VTSAoTGlzcF9PYmplY3QgYSkKIHsKLSAgZWFzc3VtZSAo RklYTlVNUCAoYSkpOworICBlYXNzZXJ0IChGSVhOVU1QIChhKSk7CiAgIHJldHVybiBYRklY TlVNX1JBVyAoYSk7CiB9CiAKQEAgLTEyMDksNyArMTIwOSw3IEBAIFhVRklYTlVNX1JBVyAo TGlzcF9PYmplY3QgYSkKIElOTElORSBFTUFDU19VSU5UCiBYVUZJWE5VTSAoTGlzcF9PYmpl Y3QgYSkKIHsKLSAgZWFzc3VtZSAoRklYTlVNUCAoYSkpOworICBlYXNzZXJ0IChGSVhOVU1Q IChhKSk7CiAgIHJldHVybiBYVUZJWE5VTV9SQVcgKGEpOwogfQogCkBAIC0yODI4LDkgKzI4 MjgsMTEgQEAgRklYTkFUUCAoTGlzcF9PYmplY3QgeCkKIElOTElORSBFTUFDU19JTlQKIFhG SVhOQVQgKExpc3BfT2JqZWN0IGEpCiB7Ci0gIGVhc3N1bWUgKEZJWE5BVFAgKGEpKTsKKyAg ZWFzc2VydCAoRklYTlVNUCAoYSkpOwogICBFTUFDU19JTlQgaW50MCA9IExpc3BfSW50MDsK LSAgcmV0dXJuIFVTRV9MU0JfVEFHID8gWEZJWE5VTSAoYSkgOiBYTEkgKGEpIC0gKGludDAg PDwgVkFMQklUUyk7CisgIEVNQUNTX0lOVCByZXN1bHQgPSBVU0VfTFNCX1RBRyA/IFhGSVhO VU0gKGEpIDogWExJIChhKSAtIChpbnQwIDw8IFZBTEJJVFMpOworICBlYXNzdW1lICgwIDw9 IHJlc3VsdCk7CisgIHJldHVybiByZXN1bHQ7CiB9CiAKIElOTElORSBib29sCi0tIAoyLjIx LjAKCg== --------------3410BBC0447F81BE707959FE-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 09:18:31 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 13:18:32 +0000 Received: from localhost ([127.0.0.1]:37663 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgUIJ-0000Dt-GH for submit@debbugs.gnu.org; Thu, 27 Jun 2019 09:18:31 -0400 Received: from mail-ot1-f68.google.com ([209.85.210.68]:39689) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgUIH-0000Df-Go for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 09:18:30 -0400 Received: by mail-ot1-f68.google.com with SMTP id r21so1540119otq.6 for <36370@debbugs.gnu.org>; Thu, 27 Jun 2019 06:18:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=e1qeXxLZxt1paQniviQWt2m+19gST+lcR2AvAUJrPks=; b=VwghwNpQNXXRE/12yrscAoKCyZsg9LfkGDOnr10sLrsle2sz/yj3tPGMXY3YTsoJCn wj3bVRlKhGx3f22yIkD0h1ul1ddLdsuk/iHYiOB9qe1ECihfN5Cdr7rTIrHINtK1TgAF QgQekUIIxX+wunIWQrAZ0nJRROOmVLiLouQZbtG4Dy0YE1D3sFT9vTI6S2slOJyZSG6A U+Y+Jnp8/rawrDAV4NIAscSk40xELTC6zJVfYs0n3blIUnbMlOhtB5CJh4oXzn20OhSo 6sMqZJ4/MGYJAAfp5M131PfzkHVfv1f+aPUioGWHkw4rDY0VumjghKTDvS0nQuq7f8Qg 30YQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=e1qeXxLZxt1paQniviQWt2m+19gST+lcR2AvAUJrPks=; b=FoF1wLnbSQ3dKkzcIxgQ2gXgqMLNDqCLG6hG/Nak3V8rG1fNO43goJj6CMlK01LmN/ pFhR8gWhzVwKxv1njy9brwrMlXdfW8badpEkm2phC+9Gq4TA9xHyTYExu8NV+BIQAkB7 UNceyzVZI+pa1eqjGHo9qtiBQQMJ/sQsoV27d2PxTnP/OXyzzoSRRHPzAonOhbR1W78L NWVhVJP6Q77+ZNRcMtw+6xq7g2k31PVkS6/IjrgNzqCiNk4dT6dK27Uq/q9YyFu/VGoc 60CAOv6yyuJve15uMlI7MUKmqcJ5FtiDCIz6TgeQp3bRo4ypiAM2o5j6fYNvTXCjhwCn Z/4A== X-Gm-Message-State: APjAAAWURrNrKACjBIyTBCwnNj9Af0fz73BLYsqM6fG9JS4FCWViIY/5 ZX4D03tLqmNLEdYu7OWo8W+VEEL2iq3xFGze/6A= X-Google-Smtp-Source: APXvYqwFuG6cR/T51LnlDJ4vDU26ThGykb4tSQB8G0GyplaL3zChvfAsLK7CRMTp6j7QBNK+8FOwHCJQtoGWXcbcq3s= X-Received: by 2002:a9d:664c:: with SMTP id q12mr3059475otm.175.1561641503693; Thu, 27 Jun 2019 06:18:23 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Pip Cet Date: Thu, 27 Jun 2019 13:17:46 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Thu, Jun 27, 2019 at 8:28 AM Paul Eggert wrote: > Pip Cet wrote: > > I'd prefer if the code were written as though FIXNATs weren't FIXNUMs at all. > > I'm more of the opposite opinion. The original reason for XFIXNAT (under its old > name) was performance, because long ago Emacs put the type tag in the most > significant bits, and it was faster to mask it out than to smear the sign bit > when you knew the fixnum was nonnegative. Nowadays that original reason is > obsolete because the tags are in the least significant bits and XFIXNAT is just > an alias for XFIXNUM, and if it were up to me we'd get rid of XFIXNAT entirely, > and just use XFIXNUM. But old habits die hard.... I actually think that would be best, so we're only disagreeing about what the second-best solution is :-) > > ascent = image_spec_value (spec, QCascent, NULL); > > if (FIXNUMP (ascent)) > > img->ascent = XFIXNAT (ascent); > > > > in image.c is safe, because lookup_image is called only after valid_image_p. > > Sorry, you've lost me. How does valid_image_p guarantee that 'ascent' (if a > fixnum) is in the range 0..INT_MAX? Because if it's not in that range, the above > code could trap. valid_image_p only returns true if ->valid_p returns true, which only happens when parse_image_spec returns true, which only happens if :ascent is not present, Qcenter, or a fixnum in the 0..100 range. > > I'd prefer leaving the macros for now > > I actually did it that way at first, but that failed miserably as the macros > evaluated their arguments more than once when debugging , and lots of code > expects them to behave like functions and evaluate their arguments exactly once. > So functions it is. > > > eassume (inline_function (x)) > > doesn't work very well on current GCC, while eassume (MACRO (x)) is > > fine, so I'm sometimes building with DEFINE_KEY_OPS_AS_MACROS. > > Hmm, I see I should have helped GCC more there. First, the two new eassumes > should just be easserts as the assumptions are not helpful to the compiler. > Second, I should restore the eassume that tells GCC that XFIXNAT returns a > nonnegative integer. > > > (The > > eassume/eassert situation is something else I've been planning to look > > at in more detail, though debugging it will be easier when > > https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91005 is fixed). > > Sorry, I don't follow. That bug report seems to be about nested C functions; why > is it relevant to Emacs, which doesn't use nested C functions? I don't think it's really relevant to this discussion, though there are similarities: ---- Just like having both XFIXNUM and XFIXNAT is confusing, so is having eassume and eassert. My idea is to define eassume as follows: #define eassume(cond) (__builtin_constant_p (!(cond) == !(cond)) ? ((cond) ? 0 : __builtin_unreachable ()) : 0) That would catch most (not all) cases in which eassume() causes code to be emitted. I wanted to test this, and in particular to catch false negatives like this eassume in lisp.h: eassume (0 <= i && i < bool_vector_size (a)); (GCC isn't smart enough to derive any information from the RHS of the &&, so __builtin_constant_p (!(cond) == !(cond)) is false, but we only actually use the LHS of the &&...) So I resorted to this old trick to see whether code was being emitted: int c; asm(".pushsection .text.bad"); c = (cond); asm(".popsection"); but that hack no longer works with -g3. Instead, we can define an inner function with the relevant code, put it into a magic section, then confirm that only the trivial function actually ended up in the magic section. ---- > > I don't see how either ccl.c or image.c are buggy for out-of-range > > integer arguments. > > For example, ccl.c in master has this: > > if (FIXNUMP (AREF (status, i))) > { > i = XFIXNAT (AREF (status, 8)); > if (ccl.ic < i && i < ccl.size) > ccl.ic = i; > } > > where i is a 32-bit int. If AREF (status, 8) is the 62-bit Lisp fixnum with > value '2 * (EMACS_INT) INT_MAX + ccl.ic + 3', the assignment to i overflows, > which can trap. Even if the assignment doesn't trap but merely wraps around, the > next line won't do range checking correctly. Ah. Right. Thanks. > > When you want a position, you want a FIXNAT, > > not a negative number, so CHECK_FIXNAT_COERCE_MARKER everywhere would > > catch those cases where someone passes an obviously invalid argument. > > But why stop there? Because it's as far as we get only replacing characters in our code, not typing in new ones. > 0 is an obviously invalid argument for buffers. :-) True, but then we'd have to add extra characters to distinguish the buffer and string cases. > I think > this is just an area where we disagree - I want a range check where you want a > type check. It's safe either way and the range check is a tad faster (as the > range check needs to be done anyway) and results in a crisper diagnostic when it > fails. Okay, let's agree to disagree on what the second-best solution is here. > > I'd prefer not touching the dosfns.c code, for the simple reason that > > if anyone still uses it, they might rely on the broken behavior. > > We can't leave it alone, as XFIXNAT is now checking that its result is > nonnegative when debugging is enabled. Do DOS machines have enough memory to run Emacs with debugging enabled? :-) You're absolutely right, of course. Thanks for the changes! I think this code is a bit hard to read: margin = image_spec_value (spec, QCmargin, NULL); if (RANGED_FIXNUMP (0, margin, INT_MAX)) img->vmargin = img->hmargin = XFIXNAT (margin); else if (CONSP (margin)) { img->hmargin = XFIXNAT (XCAR (margin)); img->vmargin = XFIXNAT (XCDR (margin)); } because range is checked for the :margin 3 case but not the :margin '(3 4) case; I'm perfectly okay with taking a list and checking it twice. From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 09:38:00 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 13:38:00 +0000 Received: from localhost ([127.0.0.1]:37680 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgUbA-0000h7-HH for submit@debbugs.gnu.org; Thu, 27 Jun 2019 09:38:00 -0400 Received: from eggs.gnu.org ([209.51.188.92]:59535) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgUb9-0000gt-IZ for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 09:37:59 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:50402) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1hgUb4-0003tE-DA; Thu, 27 Jun 2019 09:37:54 -0400 Received: from [176.228.60.248] (port=4913 helo=home-c4e4a596f7) by fencepost.gnu.org with esmtpsa (TLS1.2:RSA_AES_256_CBC_SHA1:256) (Exim 4.82) (envelope-from ) id 1hgUb0-0003ft-HW; Thu, 27 Jun 2019 09:37:51 -0400 Date: Thu, 27 Jun 2019 16:37:35 +0300 Message-Id: <83woh7i1y8.fsf@gnu.org> From: Eli Zaretskii To: Pip Cet In-reply-to: (message from Pip Cet on Thu, 27 Jun 2019 13:17:46 +0000) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers References: X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, eggert@cs.ucla.edu X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) > From: Pip Cet > Date: Thu, 27 Jun 2019 13:17:46 +0000 > Cc: 36370@debbugs.gnu.org > > Do DOS machines have enough memory to run Emacs with debugging > enabled? :-) Yes. From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 15:38:24 2019 Received: (at 36370-done) by debbugs.gnu.org; 27 Jun 2019 19:38:24 +0000 Received: from localhost ([127.0.0.1]:39767 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgaDv-0001dz-My for submit@debbugs.gnu.org; Thu, 27 Jun 2019 15:38:24 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:35762) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgaDt-0001dl-E7 for 36370-done@debbugs.gnu.org; Thu, 27 Jun 2019 15:38:22 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 44694161D0F; Thu, 27 Jun 2019 12:38:15 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id XKkj5ZAfPbXi; Thu, 27 Jun 2019 12:38:14 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 45638161D54; Thu, 27 Jun 2019 12:38:14 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id AUf5GYxEpo9H; Thu, 27 Jun 2019 12:38:14 -0700 (PDT) Received: from Penguin.CS.UCLA.EDU (Penguin.CS.UCLA.EDU [131.179.64.200]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 24E49161D0F; Thu, 27 Jun 2019 12:38:14 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet References: From: Paul Eggert Openpgp: preference=signencrypt Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= xsFNBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqfhpxxdGA9 Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9XmAAtmXqeZVIYX/UFS 96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Ygd7gx07Auwp7iw7eNvnoDTAl KAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kghy+P6au6PrIIhYraeua7XDdb2LS1en3Ss mE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZK QMr9amVPknjfPmJISqdhgB1DlEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2 Sf1tk5eU8MBiyN/bZ03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujC OJVxq2kljBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6CnrQzvJbB n6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQABzSBQYXVsIEVnZ2Vy dCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PsLBfgQTAQIAKAUCTIByZAIbAwUJEswDAAYLCQgHAwIG FQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRRGw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+t nfrI/C7fAeoFzQ5tVgVinShaPkZo0HTPf18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr 6g/+vtEOKbhleszN2XpJvpwM2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD 0dDiyhlDAq4lOV2mdBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFH s9tuJQvXk9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY 0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8YAZgKJfu oWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHUh6/BmgvdjWPZYFTt N+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1gpzTvPc4qVQinCmIkEFp83zl +G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZzEW4cLSWO387MTK3CzDOx5qe6s4a91Zu ZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh+Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc 1xdhAFHOwU0ETIByZAEQAKaF678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x6 70HRVahAmk0sZpYc25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/ IMnlZRaVlm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46mOhRDC2r FV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x1icmn6xGI45EugJO gec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9DX8njona0gf0s03tocK8kBN6 6UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZazWA5VslvTxpm76hbg5oiAEH/Vg/8MxHyA nPhfrgwyPrmJEcVBafdspJnYQxBYNco2LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA 77BMRnF0FQyE+7AzV79MBN4ykiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0G IPplLz6YhjrbHrPRF1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAHCwWUEGAEC AA8FAkyAcmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UGbPEd7HGF /VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD0Dw+0LYPnUOsQ0KO FxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h8z5ccpG0Qs4bFhdFYnFrEieD LoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZOIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFx c4W1URpAkBCOYJoXvQfD5L3lqAl8TCqDUzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwc XNOdiklGxbmHVG6YGl6g8Lrbsu9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu 5cEq4RDHM44QqPk6l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB 1thMYqlmgdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cXWtkGoi8b uNcby4U= Organization: UCLA Computer Science Department Message-ID: <7ef599ae-0a1d-e86f-2bed-a1503455833f@cs.ucla.edu> Date: Thu, 27 Jun 2019 12:38:10 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------DCEB8734CF7935EB7423EB85" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370-done Cc: 36370-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------DCEB8734CF7935EB7423EB85 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit >> if it were up to me we'd get rid of XFIXNAT entirely, >> and just use XFIXNUM. But old habits die hard.... > > I actually think that would be best, so we're only disagreeing about > what the second-best solution is :-) Removing XFIXNAT would be outside the scope of this patch. However, if we're already fixing the code for some other reason and if the XFIXNATs are confusing that code, we might as well replace them with XFIXNUMs. The attached patch does that. > valid_image_p only returns true if ->valid_p returns true, which only > happens when parse_image_spec returns true, which only happens if > :ascent is not present, Qcenter, or a fixnum in the 0..100 range. Thanks for explaining. The attached patch removes the unnecessary range checks that I proposed. > My idea is to define eassume as follows: > > #define eassume(cond) (__builtin_constant_p (!(cond) == !(cond)) ? > ((cond) ? 0 : __builtin_unreachable ()) : 0) That would generate worse code in some cases, since after (say) "eassume (i >= 0); return i/2;" where i is a variable, GCC would not be able to optimize i/2 into i>>1 because GCC would not know that i is nonnegative. The main point of eassume (as opposed to eassert) is to enable optimizations like that. > think this code is a bit hard to read: The attached patch changes that to use XFIXNUM instead of XFIXNAT, along the lines discussed above. Thanks for the review. In addition to the already-mentioned patches, I installed the attached and am closing the bug report. --------------DCEB8734CF7935EB7423EB85 Content-Type: text/x-patch; name="0001-Omit-a-few-minor-unnecessary-range-checks.patch" Content-Disposition: attachment; filename="0001-Omit-a-few-minor-unnecessary-range-checks.patch" Content-Transfer-Encoding: quoted-printable >From 7219f991a94015e06851d54b77acb4b1161749a5 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Thu, 27 Jun 2019 12:31:27 -0700 Subject: [PATCH] Omit a few minor unnecessary range checks MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit Based on Pip Cet=E2=80=99s review (Bug#36370#19). * src/fileio.c (Fdo_auto_save): * src/image.c (lookup_image): * src/textprop.c (Fnext_single_char_property_change): Prefer XFIXNUM to XFIXNAT for clarity and consistency with neighboring code, and to avoid unnecessary range checks. * src/image.c (lookup_image): Omit unnecessary range checks. --- src/fileio.c | 2 +- src/image.c | 12 ++++++------ src/textprop.c | 4 ++-- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/fileio.c b/src/fileio.c index 61e10dac47..ed1d2aedf3 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -5852,7 +5852,7 @@ DEFUN ("do-auto-save", Fdo_auto_save, Sdo_auto_save= , 0, 2, "", spare the user annoying messages. */ && XFIXNUM (BVAR (b, save_length)) > 5000 && (growth_factor * (BUF_Z (b) - BUF_BEG (b)) - < (growth_factor - 1) * XFIXNAT (BVAR (b, save_length))) + < (growth_factor - 1) * XFIXNUM (BVAR (b, save_length))) /* These messages are frequent and annoying for `*mail*'. */ && !NILP (BVAR (b, filename)) && NILP (no_message)) diff --git a/src/image.c b/src/image.c index bbf25b4d58..f3d6508f46 100644 --- a/src/image.c +++ b/src/image.c @@ -2385,18 +2385,18 @@ lookup_image (struct frame *f, Lisp_Object spec) #endif =20 ascent =3D image_spec_value (spec, QCascent, NULL); - if (RANGED_FIXNUMP (0, ascent, INT_MAX)) - img->ascent =3D XFIXNAT (ascent); + if (FIXNUMP (ascent)) + img->ascent =3D XFIXNUM (ascent); else if (EQ (ascent, Qcenter)) img->ascent =3D CENTERED_IMAGE_ASCENT; =20 margin =3D image_spec_value (spec, QCmargin, NULL); - if (RANGED_FIXNUMP (0, margin, INT_MAX)) - img->vmargin =3D img->hmargin =3D XFIXNAT (margin); + if (FIXNUMP (margin)) + img->vmargin =3D img->hmargin =3D XFIXNUM (margin); else if (CONSP (margin)) { - img->hmargin =3D XFIXNAT (XCAR (margin)); - img->vmargin =3D XFIXNAT (XCDR (margin)); + img->hmargin =3D XFIXNUM (XCAR (margin)); + img->vmargin =3D XFIXNUM (XCDR (margin)); } =20 relief =3D image_spec_value (spec, QCrelief, NULL); diff --git a/src/textprop.c b/src/textprop.c index 3026ec7e99..9023f4efa0 100644 --- a/src/textprop.c +++ b/src/textprop.c @@ -799,10 +799,10 @@ DEFUN ("next-single-char-property-change", Fnext_si= ngle_char_property_change, else CHECK_FIXNUM_COERCE_MARKER (limit); =20 - if (XFIXNAT (position) >=3D XFIXNUM (limit)) + if (XFIXNUM (position) >=3D XFIXNUM (limit)) { position =3D limit; - if (XFIXNAT (position) > ZV) + if (XFIXNUM (position) > ZV) XSETFASTINT (position, ZV); } else --=20 2.21.0 --------------DCEB8734CF7935EB7423EB85-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 15:57:01 2019 Received: (at 36370-done) by debbugs.gnu.org; 27 Jun 2019 19:57:01 +0000 Received: from localhost ([127.0.0.1]:39788 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgaVx-0004IA-5t for submit@debbugs.gnu.org; Thu, 27 Jun 2019 15:57:01 -0400 Received: from mail-ot1-f50.google.com ([209.85.210.50]:45348) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgaVv-0004Hv-6L for 36370-done@debbugs.gnu.org; Thu, 27 Jun 2019 15:57:00 -0400 Received: by mail-ot1-f50.google.com with SMTP id x21so3537661otq.12 for <36370-done@debbugs.gnu.org>; Thu, 27 Jun 2019 12:56:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=5aM9A4uRXv4Vo6JN3eKAAAQruxCdKG9C9bRfk7Z1sOk=; b=Mxxaeg/8KnxHRk6JxXyDSde+7TUUJ46omVYJzx5yIbeuZAymTPK9OzokgA6spyHF75 h+3EOuuEZOccJ1ohGHJ3i8WxQwDHj5UiLI25Tr1fQbXfJIpDOInS2VuQKU9pJP3eM58E 7VfeUxYwxI4A0DTWKtQTsjuWUDpHHrKhX85idvB1NbETopfXhKRf1z3QwECpJg+sss2+ Xg0H6DPh+AOoGubwtamRev5gorSbaDn6MFsGXxSjMz7XFcPjzlZUnEUFvD0PvqEMup9b BxyM8jgrPrK/SAk7c1DyBCoFbbjJ9oTdvbHH+noALERv1edmKw7XVpEmSqRgWQDYXpar EwUA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=5aM9A4uRXv4Vo6JN3eKAAAQruxCdKG9C9bRfk7Z1sOk=; b=MUfNEv3q6VxbcwM2NkUuPMJCBbEKqAOyuQQxoK5A6LF+a3Ubh5zbRvmcvlkRNWvSfk he9af/0qmne6zC8P2+DzrfF4vGJXsyXg5TxegbuB0WwKaRpuFkdsVf5DZL/p04TqMLy3 qeQcr7EGbvbCFoUrLz1q9JRucmyAuICkkX/dDdo9xB5kXrrNK69GsPZFMSAfBXz1r1up A6AGmSIQraEbeUqH8IegSO4uUJN4aEC3J05y2Q6i1k80yywsLbUBCHcoEg9Nj9EfbFu2 3UcgR0LahQi9LiBbb6x7L/gESZ+49d2dt8VLmiLYzFwOJYnTiAs24FyG3IPV288O+gYC 4qjg== X-Gm-Message-State: APjAAAXcZqneg6ySPAuWgvpu4zojulwwxU1SNWU7upGJYleIH6uXjpbw CAGS+cZpY/4gHw3wEoRlKs5qksCNkOSIsPTpMDQ= X-Google-Smtp-Source: APXvYqxPCiC5ASwF83K6/7VVCG78Pnj23Z+25nvCPrQ6li3m2Z9Df+aT4j2h9/vPGtqG5TSIJe+2cf80TIqUCdklNbk= X-Received: by 2002:a9d:7284:: with SMTP id t4mr5338119otj.154.1561665413463; Thu, 27 Jun 2019 12:56:53 -0700 (PDT) MIME-Version: 1.0 References: <7ef599ae-0a1d-e86f-2bed-a1503455833f@cs.ucla.edu> In-Reply-To: <7ef599ae-0a1d-e86f-2bed-a1503455833f@cs.ucla.edu> From: Pip Cet Date: Thu, 27 Jun 2019 19:56:17 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370-done Cc: 36370-done@debbugs.gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Thu, Jun 27, 2019 at 7:38 PM Paul Eggert wrote: > >> if it were up to me we'd get rid of XFIXNAT entirely, > >> and just use XFIXNUM. But old habits die hard.... > > > > I actually think that would be best, so we're only disagreeing about > > what the second-best solution is :-) > > Removing XFIXNAT would be outside the scope of this patch. However, if > we're already fixing the code for some other reason and if the XFIXNATs > are confusing that code, we might as well replace them with XFIXNUMs. > The attached patch does that. Cool! > > My idea is to define eassume as follows: > > > > #define eassume(cond) (__builtin_constant_p (!(cond) == !(cond)) ? > > ((cond) ? 0 : __builtin_unreachable ()) : 0) > > That would generate worse code in some cases, since after (say) "eassume > (i >= 0); return i/2;" where i is a variable, GCC would not be able to > optimize i/2 into i>>1 because GCC would not know that i is nonnegative. I'm confused, and I'm not sure what you're saying. int f (int i) { eassume (i >= 0); printf("%d\n", i & 0x80000000); return 0; } The eassume tells GCC i is nonnegative, since (!(i >= 0) == !(i >= 0)) is indeed a constant. So the code generated is: xorl %esi, %esi movl $.LC0, %edi xorl %eax, %eax call printf which is as it should be. For your example, it is: movl %edi, %eax sarl %eax ret with the eassume and movl %edi, %eax shrl $31, %eax addl %edi, %eax sarl %eax ret without. > The main point of eassume (as opposed to eassert) is to enable > optimizations like that. Yes, indeed. I don't see how they are disabled by my proposed definition. > Thanks for the review. In addition to the already-mentioned patches, I > installed the attached and am closing the bug report. Thanks! From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 17:13:24 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 21:13:24 +0000 Received: from localhost ([127.0.0.1]:39910 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgbhs-0003Jx-Go for submit@debbugs.gnu.org; Thu, 27 Jun 2019 17:13:24 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:49964) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgbhp-0003Ji-KJ for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 17:13:22 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 08872161BDC; Thu, 27 Jun 2019 14:13:16 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id e-Ddqz0_GO2D; Thu, 27 Jun 2019 14:13:15 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 23DE3161C02; Thu, 27 Jun 2019 14:13:15 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id hO_HKpPJzR9A; Thu, 27 Jun 2019 14:13:15 -0700 (PDT) Received: from Penguin.CS.UCLA.EDU (Penguin.CS.UCLA.EDU [131.179.64.200]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 01644161BDC; Thu, 27 Jun 2019 14:13:15 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet References: <7ef599ae-0a1d-e86f-2bed-a1503455833f@cs.ucla.edu> From: Paul Eggert Openpgp: preference=signencrypt Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= xsFNBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqfhpxxdGA9 Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9XmAAtmXqeZVIYX/UFS 96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Ygd7gx07Auwp7iw7eNvnoDTAl KAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kghy+P6au6PrIIhYraeua7XDdb2LS1en3Ss mE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZK QMr9amVPknjfPmJISqdhgB1DlEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2 Sf1tk5eU8MBiyN/bZ03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujC OJVxq2kljBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6CnrQzvJbB n6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQABzSBQYXVsIEVnZ2Vy dCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PsLBfgQTAQIAKAUCTIByZAIbAwUJEswDAAYLCQgHAwIG FQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRRGw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+t nfrI/C7fAeoFzQ5tVgVinShaPkZo0HTPf18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr 6g/+vtEOKbhleszN2XpJvpwM2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD 0dDiyhlDAq4lOV2mdBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFH s9tuJQvXk9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY 0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8YAZgKJfu oWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHUh6/BmgvdjWPZYFTt N+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1gpzTvPc4qVQinCmIkEFp83zl +G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZzEW4cLSWO387MTK3CzDOx5qe6s4a91Zu ZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh+Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc 1xdhAFHOwU0ETIByZAEQAKaF678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x6 70HRVahAmk0sZpYc25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/ IMnlZRaVlm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46mOhRDC2r FV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x1icmn6xGI45EugJO gec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9DX8njona0gf0s03tocK8kBN6 6UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZazWA5VslvTxpm76hbg5oiAEH/Vg/8MxHyA nPhfrgwyPrmJEcVBafdspJnYQxBYNco2LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA 77BMRnF0FQyE+7AzV79MBN4ykiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0G IPplLz6YhjrbHrPRF1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAHCwWUEGAEC AA8FAkyAcmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UGbPEd7HGF /VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD0Dw+0LYPnUOsQ0KO FxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h8z5ccpG0Qs4bFhdFYnFrEieD LoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZOIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFx c4W1URpAkBCOYJoXvQfD5L3lqAl8TCqDUzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwc XNOdiklGxbmHVG6YGl6g8Lrbsu9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu 5cEq4RDHM44QqPk6l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB 1thMYqlmgdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cXWtkGoi8b uNcby4U= Organization: UCLA Computer Science Department Message-ID: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> Date: Thu, 27 Jun 2019 14:13:14 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 In-Reply-To: Content-Type: multipart/mixed; boundary="------------0E9AA5AAFD624B3F33C2ECCE" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Gnulib bugs X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------0E9AA5AAFD624B3F33C2ECCE Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 6/27/19 12:56 PM, Pip Cet wrote: > The eassume tells GCC i is nonnegative, since (!(i >= 0) == !(i >= 0)) > is indeed a constant. Ah! Thanks, I didn't catch that subtle point. Would the attached patch to verify.h address that problem? This patch is for Gnulib, but would propagate into Emacs. I tried this out with Emacs master and although it did change the machine code subtly I didn't have the patience to see whether the changes were likely to improve performance. The changes did grow the Emacs text segment from 2556193 to 2557657 bytes (a 0.06% growth), which is not a good sign. This was on Fedora 30 x86-64 with a default Emacs build. I'll CC: this to bug-gnulib since it's a Gnulib issue. I have not installed this patch into Gnulib on savannah. --------------0E9AA5AAFD624B3F33C2ECCE Content-Type: text/x-patch; name="0001-verify-tweak-assume-performance.patch" Content-Disposition: attachment; filename="0001-verify-tweak-assume-performance.patch" Content-Transfer-Encoding: quoted-printable >From 9a5a83937544e7c127026fcf32030f7dbaa5766c Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Thu, 27 Jun 2019 14:01:53 -0700 Subject: [PATCH] =3D?UTF-8?q?verify:=3D20tweak=3D20=3DE2=3D80=3D98assume=3D= E2=3D80=3D99=3D20pe?=3D =3D?UTF-8?q?rformance?=3D MIME-Version: 1.0 Content-Type: text/plain; charset=3DUTF-8 Content-Transfer-Encoding: 8bit Suggested by Pip Cet (Bug#36370#30). * lib/verify.h (assume): Use __builtin_constant_p to generate better code in recent GCC. --- ChangeLog | 7 +++++++ lib/verify.h | 6 ++++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/ChangeLog b/ChangeLog index 5ae108e25..7059f4f2b 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,10 @@ +2019-06-27 Paul Eggert + + verify: tweak =E2=80=98assume=E2=80=99 performance + Suggested by Pip Cet (Bug#36370#30). + * lib/verify.h (assume): Use __builtin_constant_p to generate + better code in recent GCC. + 2019-06-26 Paul Eggert =20 strverscmp: sync from glibc diff --git a/lib/verify.h b/lib/verify.h index f8e4eff02..9b015c693 100644 --- a/lib/verify.h +++ b/lib/verify.h @@ -263,9 +263,11 @@ template accordingly. R should not have side-effects; it may or may not be evaluated. Behavior is undefined if R is false. */ =20 -#if (__has_builtin (__builtin_unreachable) \ +#if ((__has_builtin (__builtin_constant_p) \ + && __has_builtin (__builtin_unreachable)) \ || 4 < __GNUC__ + (5 <=3D __GNUC_MINOR__)) -# define assume(R) ((R) ? (void) 0 : __builtin_unreachable ()) +# define assume(R) (!__builtin_constant_p (!(R) =3D=3D !(R)) || (R) \ + ? (void) 0 : __builtin_unreachable ()) #elif 1200 <=3D _MSC_VER # define assume(R) __assume (R) #elif ((defined GCC_LINT || defined lint) \ --=20 2.21.0 --------------0E9AA5AAFD624B3F33C2ECCE-- From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 17:38:09 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 21:38:09 +0000 Received: from localhost ([127.0.0.1]:39934 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgc5p-0006E9-Bz for submit@debbugs.gnu.org; Thu, 27 Jun 2019 17:38:09 -0400 Received: from mail-oi1-f196.google.com ([209.85.167.196]:42990) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgc5n-0006Du-TD for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 17:38:08 -0400 Received: by mail-oi1-f196.google.com with SMTP id s184so2707088oie.9 for <36370@debbugs.gnu.org>; Thu, 27 Jun 2019 14:38:07 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=kY6DPd/lhoodT/J3MajDxafNtBMf44+P/tSEDklcj1Y=; b=fKH/j8kgEvVpIu16tP1R+kPO6Ydn5vFn/GlfvbFBwa+dunlWmWq3SEUGA6xUClhp1O l1INaR/EuTuLSA8K1yum+e66KR7V2frd7KXUhd++W+85itu7gaqIhNEN7M03daWQfs7i Y+iZB6hMFgQ7AMMG87d/QN0I6JuIudFWEbWdu6p9+A3+VGwbhTcK+B6bHKUY6hHJLaFp c3V+votZ+I8zaLh7qggTIfm5zL64apqwu/22JRudGQDyR2QEy4S0rxmADshRKKk3bRFw gBn0XzcsnekeiPwEw2ypW1DWdMzb0ms6aeLZszWo4gjfKSE1/AQET3C3vOOiwIFk+4yZ DF4A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=kY6DPd/lhoodT/J3MajDxafNtBMf44+P/tSEDklcj1Y=; b=bUJGAcE01Mhqndx04j4QuTKLSlHszsPPzWOMmCUCf5b833XQaRfSzEb7UBDiIbaB28 Ytv0DJB461CXjlOBkeocnWl9gP6AR0fvD1e4UIGR9lZFn7JQD4gNo+kgipMPDYEnKeHb 87QD2XwUtuwsvOqiHBP3iuFEll09KzFfeAcmChPUm4pPWLwcJF4CSEAje5IZJXdtURsN u4GMZg+jcRhUbahedlclI8upKgmr8//5ESvJ5JTNUesOLBJ+nwstrPBjZNMhk2ZZ3gqy jRs8e/3v+ecPCkMcfU+t0p7Q12b/U7dOIhgO8kBqcFyZjRgImaSYJq9doh2Dt/p7Onag epdg== X-Gm-Message-State: APjAAAX3Kv3an8DIrRwJa1ZF/F4pgnKs7PdX4UEKn4huoybfgmIPUBjK kex3xNF9GctYhWetjh+BpHDx+DYHAOxWYiJlp28= X-Google-Smtp-Source: APXvYqy6ccgh+8r9lFLLbG5zoraEjFU/8r0gnXICncaFTqLRVFN2ERqavdAR902Ix4qLcjIcJroFUkzBLyvj8f/4TbE= X-Received: by 2002:aca:be88:: with SMTP id o130mr3515909oif.122.1561671482017; Thu, 27 Jun 2019 14:38:02 -0700 (PDT) MIME-Version: 1.0 References: <7ef599ae-0a1d-e86f-2bed-a1503455833f@cs.ucla.edu> <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> In-Reply-To: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> From: Pip Cet Date: Thu, 27 Jun 2019 21:37:25 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Gnulib bugs X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Thu, Jun 27, 2019 at 9:13 PM Paul Eggert wrote: > On 6/27/19 12:56 PM, Pip Cet wrote: > > The eassume tells GCC i is nonnegative, since (!(i >= 0) == !(i >= 0)) > > is indeed a constant. > > Ah! Thanks, I didn't catch that subtle point. Would the attached patch > to verify.h address that problem? This patch is for Gnulib, but would > propagate into Emacs. Eventually, I think that would be a good idea. But right now, I would like to figure out why GCC isn't generating code that's as good as it should be. > I tried this out with Emacs master and although it did change the > machine code subtly I didn't have the patience to see whether the > changes were likely to improve performance. The changes did grow the > Emacs text segment from 2556193 to 2557657 bytes (a 0.06% growth), which > is not a good sign. This was on Fedora 30 x86-64 with a default Emacs build. So far, what I've found is that eassume (0 <= i && i < bool_vector_size (a)); doesn't work with my patch. Tweaking that to eassume (0 <= i); eassume (i < bool_vector_size (a)); appears to help a little, but it's a good idea to avoid generating a call to a function that might be out-lined by the compiler, in any case. One thing I've neglected to look at in detail, because Emacs isn't affected by it, is how this works with pure functions. > I'll CC: this to bug-gnulib since it's a Gnulib issue. I have not > installed this patch into Gnulib on savannah. I'd be extremely interested in any comments people might have! From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 19:45:22 2019 Received: (at 36370) by debbugs.gnu.org; 27 Jun 2019 23:45:22 +0000 Received: from localhost ([127.0.0.1]:40055 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hge4w-0005EN-4e for submit@debbugs.gnu.org; Thu, 27 Jun 2019 19:45:22 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.25]:16107) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hge4r-0005E8-HX for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 19:45:20 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561679115; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=AaEz2VxWWyoCwYJ1NzGHl+BVL2RXht87zbQGRVtl8VU=; b=Wtay4CxJAk/RnjXbxCrA2tUz/MrGQIuU4SdXA2HUHppy4cMYgM4OVd1VcALlitaiYY Hm+m7ZPAIWXNwDqN3kmTJrCBLYiZn7kJsC+F5aLyBw1MtgqDgnuSUojxOAW6W8O4636g KwEFrryYEmxJYkdDzWf6xZWhY/y1eRwL3HXUboLjyP6N7M/yKiZrJf/2WD1y89mHUmca 59a8E05WRGZJRQ32Yk4GwX4BiwckO3iAyG6ifyxP7W4lwjgRvkNWgqc99oAVcHUqH49B eRPdVcq7pLXVDkPlJNYdhFdZqCuKeKajYvXtmggSh3MtSeJ70x27hlcTJlMVrHxM2EIA o8tg== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5RNjBdtb (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Fri, 28 Jun 2019 01:45:11 +0200 (CEST) From: Bruno Haible To: bug-gnulib@gnu.org Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Fri, 28 Jun 2019 01:45:11 +0200 Message-ID: <2715311.ceefYqj39C@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> References: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , Pip Cet X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Hi Paul, > I'll CC: this to bug-gnulib since it's a Gnulib issue. I have not > installed this patch into Gnulib on savannah. Can you please show an example code on which the change makes a difference? I used this test program ==================================== foo.c ==================================== #include //#define assume(R) ((R) ? (void) 0 : __builtin_unreachable ()) #define assume(R) (!__builtin_constant_p (!(R) == !(R)) || (R) ? (void) 0 : __builtin_unreachable ()) int f_generic (int i) { printf("%d\n", i & 0x80000000); return 0; } int f_condition (int i) { if (i >= 0) printf("%d\n", i & 0x80000000); return 0; } int f_assume (int i) { assume (i >= 0); printf("%d\n", i & 0x80000000); return 0; } =============================================================================== $ gcc -O2 -m32 -S foo.c && fgrep -v .cfi foo.s and the code is the same, regardless of which definition of 'assume' I enable. Bruno From debbugs-submit-bounces@debbugs.gnu.org Thu Jun 27 20:04:30 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 00:04:31 +0000 Received: from localhost ([127.0.0.1]:40060 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgeNS-0005jN-QQ for submit@debbugs.gnu.org; Thu, 27 Jun 2019 20:04:30 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:50472) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgeNQ-0005j7-SS for 36370@debbugs.gnu.org; Thu, 27 Jun 2019 20:04:29 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 804A8161C02; Thu, 27 Jun 2019 17:04:22 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id AHbhy4zBZ49g; Thu, 27 Jun 2019 17:04:21 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 6E196161C3C; Thu, 27 Jun 2019 17:04:21 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id q9e_uN8-puXD; Thu, 27 Jun 2019 17:04:21 -0700 (PDT) Received: from Penguin.CS.UCLA.EDU (Penguin.CS.UCLA.EDU [131.179.64.200]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 0FA0E161C02; Thu, 27 Jun 2019 17:04:21 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible , bug-gnulib@gnu.org References: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> <2715311.ceefYqj39C@omega> From: Paul Eggert Openpgp: preference=signencrypt Autocrypt: addr=eggert@cs.ucla.edu; prefer-encrypt=mutual; keydata= xsFNBEyAcmQBEADAAyH2xoTu7ppG5D3a8FMZEon74dCvc4+q1XA2J2tBy2pwaTqfhpxxdGA9 Jj50UJ3PD4bSUEgN8tLZ0san47l5XTAFLi2456ciSl5m8sKaHlGdt9XmAAtmXqeZVIYX/UFS 96fDzf4xhEmm/y7LbYEPQdUdxu47xA5KhTYp5bltF3WYDz1Ygd7gx07Auwp7iw7eNvnoDTAl KAl8KYDZzbDNCQGEbpY3efZIvPdeI+FWQN4W+kghy+P6au6PrIIhYraeua7XDdb2LS1en3Ss mE3QjqfRqI/A2ue8JMwsvXe/WK38Ezs6x74iTaqI3AFH6ilAhDqpMnd/msSESNFt76DiO1ZK QMr9amVPknjfPmJISqdhgB1DlEdw34sROf6V8mZw0xfqT6PKE46LcFefzs0kbg4GORf8vjG2 Sf1tk5eU8MBiyN/bZ03bKNjNYMpODDQQwuP84kYLkX2wBxxMAhBxwbDVZudzxDZJ1C2VXujC OJVxq2kljBM9ETYuUGqd75AW2LXrLw6+MuIsHFAYAgRr7+KcwDgBAfwhPBYX34nSSiHlmLC+ KaHLeCLF5ZI2vKm3HEeCTtlOg7xZEONgwzL+fdKo+D6SoC8RRxJKs8a3sVfI4t6CnrQzvJbB n6gxdgCu5i29J1QCYrCYvql2UyFPAK+do99/1jOXT4m2836j1wARAQABzSBQYXVsIEVnZ2Vy dCA8ZWdnZXJ0QGNzLnVjbGEuZWR1PsLBfgQTAQIAKAUCTIByZAIbAwUJEswDAAYLCQgHAwIG FQgCCQoLBBYCAwECHgECF4AACgkQ7ZfpDmKqfjRRGw/+Ij03dhYfYl/gXVRiuzV1gGrbHk+t nfrI/C7fAeoFzQ5tVgVinShaPkZo0HTPf18x6IDEdAiO8Mqo1yp0CtHmzGMCJ50o4Grgfjlr 6g/+vtEOKbhleszN2XpJvpwM2QgGvn/laTLUu8PH9aRWTs7qJJZKKKAb4sxYc92FehPu6FOD 0dDiyhlDAq4lOV2mdBpzQbiojoZzQLMQwjpgCTK2572eK9EOEQySUThXrSIz6ASenp4NYTFH s9tuJQvXk9gZDdPSl3bp+47dGxlxEWLpBIM7zIONw4ks4azgT8nvDZxA5IZHtvqBlJLBObYY 0Le61Wp0y3TlBDh2qdK8eYL426W4scEMSuig5gb8OAtQiBW6k2sGUxxeiv8ovWu8YAZgKJfu oWI+uRnMEddruY8JsoM54KaKvZikkKs2bg1ndtLVzHpJ6qFZC7QVjeHUh6/BmgvdjWPZYFTt N+KA9CWX3GQKKgN3uu988yznD7LnB98T4EUH1HA/GnfBqMV1gpzTvPc4qVQinCmIkEFp83zl +G5fCjJJ3W7ivzCnYo4KhKLpFUm97okTKR2LW3xZzEW4cLSWO387MTK3CzDOx5qe6s4a91Zu ZM/j/TQdTLDaqNn83kA4Hq48UHXYxcIh+Nd8k/3w6lFuoK0wrOFiywjLx+0ur5jmmbecBGHc 1xdhAFHOwU0ETIByZAEQAKaF678T9wyH4wjTrV1Pz3cDEoSnV/0ZUrOT37p1dcGyj/IXq1x6 70HRVahAmk0sZpYc25PF9D5GPYHFWlNjuPU96rDndXB3hedmBRhLdC4bAXjI4DV+bmdVe+q/ IMnlZRaVlm9EiMCVAR6w13sReu7qXkW9r3RwY2AzXskp/tAe4BRKr1Zmbvi2nbnQ6epEC42r Rbx0B1EhjbIQZ5JHGk24iPT7LdBgnNmos5wYjzwNlkMQD5T0Ydzhk7J+UxwA5m46mOhRDC2r FV/A0gm5TLy8DXjv/Esc4gYnYai6SQqnUEVh5LuV8YCJBnijs+Tiw71x1icmn6xGI45EugJO gec+rLypYgpVp4x0HI5T88qBRYCkxH3Kg8Qo+EWNA9A4LRQ9DX8njona0gf0s03tocK8kBN6 6UoqqPtHBnc4eMgBymCflK12eKfd2YYxnyg9cZazWA5VslvTxpm76hbg5oiAEH/Vg/8MxHyA nPhfrgwyPrmJEcVBafdspJnYQxBYNco2LFPIhlOvWh8r4at+s+M3Lb26oUTczlgdW1Sf3SDA 77BMRnF0FQyE+7AzV79MBN4ykiqaezQxtaF1Fy/tvkhffSo8u+dwG0EgJh+te38gTcISVr0G IPplLz6YhjrbHrPRF1CN5UuL9DBGjxuN35RLNVEfta6RUFlR6NctTjvrABEBAAHCwWUEGAEC AA8FAkyAcmQCGwwFCRLMAwAACgkQ7ZfpDmKqfjSrHA/+KzAKvTxRhA9MWNLxIyJ7S5uJ16gs T3oCjZrBKGEhKMOGX4O0GA6VOEryO7QRCCYah3oxSG38IAnNeiwJXgU9Bzkk85UGbPEd7HGF /VSeHCQwWou6jqUDTSDvn9YhNTdG0KXPM74aC+xr2Zow1O2mhXihgWKD0Dw+0LYPnUOsQ0KO FxHXXYHmRrS1OZPU59BLvc+TRhIhafSHKLwbXK+6ckkxBx6h8z5ccpG0Qs4bFhdFYnFrEieD LoGmnE2YLhdV6swJ9VNCS6pLiEohT3fm7aXm15tZOIyzMZhHRSAPblXxQ0ZSWjq8oRrcYNFx c4W1URpAkBCOYJoXvQfD5L3lqAl8TCqDUzYxhH/tJhbDdHrqHH767jaDaTB1+Talp/2AMKwc XNOdiklGxbmHVG6YGl6g8Lrbsu9NZEI4yLlHzuikthJWgz+3vZhVGyNlt+HNIoF6CjDL2omu 5cEq4RDHM44QqPk6l7O0pUvN1mT4B+S1b08RKpqm/ff015E37HNV/piIvJlxGAYz8PSfuGCB 1thMYqlmgdhd9/BabGFbGGYHA6U4/T5zqU+f6xHy1SsAQZ1MSKlLwekBIT+4/cLRGqCHjnV0 q5H/T6a7t5mPkbzSrOLSo4puj+IToNjYyYIDBWzhlA19avOa+rvUjmHtD3sFN7cXWtkGoi8b uNcby4U= Organization: UCLA Computer Science Department Message-ID: <897ea51e-b56d-6d24-34d8-b2dabf01e78f@cs.ucla.edu> Date: Thu, 27 Jun 2019 17:04:20 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 In-Reply-To: <2715311.ceefYqj39C@omega> Content-Type: multipart/mixed; boundary="------------6EB409978CA90BAF8AD1F800" Content-Language: en-US X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Pip Cet X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" This is a multi-part message in MIME format. --------------6EB409978CA90BAF8AD1F800 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit On 6/27/19 4:45 PM, Bruno Haible wrote: > Can you please show an example code on which the change makes a difference? Not easily, I'm afraid. I grabbed the latest Emacs master , ran './configure; make CFLAGS=-O2', edited the emacs lib/verify.h, and ran 'make CFLAGS=-O2' again. The biggest percentage change in text size was in src/regex-emacs.o. I'll attach the two respective .s files, compressed. --------------6EB409978CA90BAF8AD1F800 Content-Type: application/gzip; name="regex-emacs-old.s.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="regex-emacs-old.s.gz" H4sIAAAAAAACA+29WZMkx5Em+Fz8FRAIKIKaqSxxu83iiU0Oe3pWOMORJkdmV7ZlSyLCowpB JjITGVmNQK/sf1+3W9UOd488qgogXoBKDz/sVNPj009fvX1/vD68+vr+8OFwvjp8v92f3u6/ /s2rtw+H88P0vzu6vT5+uPmK20s/3R1enf5+vHt3e3N4t/9ue//mq9+9/3izfzje3vwG/bD5 zds//fPvGRs203P798d3p4ft/cPd/e3+N6/239/tXn3D6Juvvv3t/Xh8/ZtX14ftD6+I/+vN V7+9355/8+pv21dv/0R/8+r723//j931q/TjYbQ/fn/36j+9/RP/9s10+fxGT+94ezq4drx6 e387bh+20xXfcp3+xadGcdugHz5uR//2xj9V/ifJ/xTNf9J/uH+y5j/7N5TL6M0bMoC/2TQl dJqS8+399avfHrZnO8N2+u8PS4+xTVg4FC2cadY2ax4Xm7S2CF5cD4fTw+7Vb8fr6cJ4PS22 k10KA1imUzPtuktrdflrqvu1J7yU2N21vRmvX31DqIov3I72Ao9/Tl89Xf/wyv5h3xzumC7c hwtHfw9u2fbc2Xmn7fX0dh3vcR8L73YXpu64R1xvpv/Q18WteYr31w8/oCl0TxT9t7LjcDM6 yTGJlD8GkXI6/kclit5eoQtQJNhV+PbjzfXx74frn958vT1//eZ30ys/7I4Pp+m1f/jzn/7L 79173XJ9+6d/+fNf/d+V+NvebK9/+o/Du/fH+9MDFH/ohyD+qGiIv7uPp+/s8BMefhsP79/t 32/f3b5/fzo8fEVkuB7/nqbyyl5MD7L2g5QXD7LpQXsxTORv93ZFT4+P4F20/S5Gi3dN0vqK eXFsZ3Hv1g6h4FW7u/ar+IBfJac32WvpuXPnOY2fs72x16YW5NVrHz593P0w7QBp/z51GiGt 7Cdy404f9/jR3T4t/r/tDtP+lq2jZnuuzya7CfIJ9tvtdTiq7KzEgd7agZ7GKB1URNiTan/R SUUEOKokOIoklMzwtAL/phL8Gx5YfPnf6Fsr/k1he8jj/0308r8vbVvv36QzbugeXvx7xVkm yaZYoVa+2lVgl5897OgmyVvalLfkMoHrTictkDhlhTgdsTQ/p09OW8ceHjyJ5O/v4tmRdDA7 JO7E+IaEd9lp2+BTw3+H8LHzoSzl/Z0adsw/B8+H9CZ3dNm//MV0dun4N9rO9kLYziqKKivv 4m4ME7M7g0FJbwsHof37NL1Nf2ulybRd97adSLp7FQEfZn+7sZ8lJLwjPB1lTHivG2i8IhZO eL2Jgy8ufJTy9Ci99KuqpZHZPufRc4L38DD12onAm8MHf7d9nKQvF0L5/vD94fvd4d4ehw+H vti/u72bPRmGfMtd//wKt/SOOCvy4i2sfxTHWzqntV6lqPFNGoHTw+39IQ5APaZ/O4TtXEkD f9oWR49b499QIdOmmRp1cF3a5WXnFoAdqtP2fpoV5t8WdUenObqBnNWX9SZvKbcfD3ZJud1h 1a13+6lHH27vf3p3suMR9ITdHdh7rj+2Q1ODomzyYmh7H9UTL+S8Tguk0i4cqr5fbpCE3+I7 d+O3bgxty17bttoFHNQCJCi+uUp/+w0rdDzhDXXvSOpn2DrcxJmZHx2zwa2ZeofEZuiHnY5t nmzfBvMbO+WNPTddlr/upeKEVZ29VMpyeOjaZ5b3Wn0e48Xl5jRYh9NQ7Pw22sV57L8pPONW sFMYb+yhzaaROn03zfg3srPwb++nBlxJHh5zJ7x9btNrXCW0/SBoNwhyc5nAKQ7uYzy4vcwZ 7B3hbMvf3J8Li3QfbcIrklTg5MWxn2badkluKkt1u7TnONkUXw9HOm6OEy5O5nnzOMu8fds8 zgqMThZ5UMWymBrxbCWr4LenY/Ib2O7Z/dWcK/sTllJZAbsiWK3gxI5RXMTpI9N/4x3MdCbQ DvCmtwLDtM9MXzLp2bdJYmcnAy3WLZ0bVq+fQhsLj27xCzoekgo8lo6E8dwYgjBHe7h+tVt9 UB3Gymvp8vAX910NfH/u6bb7c1NBvI4bLSjd6PHSY3KfftHuxfAnu+nmDyOOvU37qoM0X23Y GP5Pd964n71QySZHHiXwjvImv5LBMvIDwHn8iQ48//bB/iTiZpVZAF5HAQi/HAxst7w56CzH TQpXBbh6rFYT6uwx9eNYvIThl5R3od6OqbdiKHs7pt4a1Nux6K0zs8SQ++b9kfljaANc229Z IS/s2eB32vwSEd0zpFZaio99cD0T9i1ZO5Fx5Qcl53SMF4KSwxdOJ/GY06mSVX42GV6EVAi0 0BjPirMAx5iXWF492+ejxHfFjHmrusECwiT5iOAP+2hfx1eaMSkpBmmZ7lhcc+KxctbGYsLG PAH5EA3isTuI3qQQRTgGn/neqnAHTvt88Mf7Fh3v/rsyzjNTS6odfaqy62c1idafn+5rj7GO fvscZgpnjzdTOJvfwVxs4oaTQjC85biM0o5QLNwZ7Qr38Hbu4namfnuSpYLgt4/F28f0rkkg 28Zsslg2igiC26rS2zRuK5Gr2ipI6/25tRS/fyzeX7ZWpbdxYjhRAp+oklfHZmVGLJyiqPG0 9bl8pElRnVuFHlwcY7AvjG+yvEAKZdfOIFFAByFil5rkmyTBuW50QoryBtAQVoSVenGiOnTT CAG93d9ej904kPvVBYP+4qNBNk6w6YYomvGOVuykGZppxn6akSTv0tzd3jcjbD5qFZzdLtBW BL3eXhXu0P4A1o+HASve4a6GSNwfi0jcH9uRuMP5sP/44GN9U+/gHBQ/RTACnYvGiZXROFFG 4/jKaBwPM7IUxmtOZQi9QZvKPr8UxmuuFRR8u1sXfJNF8O0YPYpLUTwh61Vtr0Hd6pCjeHyY i+IZGVqAw3Gl1TZN5oiVnXOt7Ni7dtldyneFtmhFzvTjNVJ7YoP3LaeOtaippsggxCHtMHr2 +Iy6VniLM1j30Wmg1bRiDd30OrFK7bXDmkTjLrw2+WXP+F0qTUP2lmxrO7+y4c/YUt89FN/d uzGx7gutknJXTPIa5S4vmeh8XqPf6UX9DqiAc6HwBf0OqoB8WQUUT3B/Um3m/J/7j/f3h5uH dw/f3R+24zRDx7vW6qM8RrfcRcL5t72FSiS+VYNbXQAAWr67qOOQ4J33Asvbc4S4+Gc4u7e7 k10KkhCp5TBpGpozQYWPVdhue4GQwl6V6lm/Q2vJhBGCuvVlkLSKnUh7k5DXRdRvhFG/+XiO U0CitbrNlpaLAYooJ93QgVEFPfKBshg1+OEVo/nW7DItPBehnd5YBK5Xf0GPaDM7F7gPSsoh PAte6Do+3e4W5AAmM5mn7gUHt399n8km+q4o/h6Lf/rvUalipIkmkIUXjjzJpiz4wzeECzwm zTzFbdMtRMu1i7y9nr3t1Fm6HhbjkRxKN5abWzhuAMPJY1YsY7K8TO3iAmFaJ2LmQ8JiZu0p s3bt6WHt2nNTO7v2DmExhbUH1gLRpLH2dF56JPwdVp5fijqtCumaStHKA19jxUrXsr3y3A/1 yru5aF1F/+YK0blWSmpdSclTDKr+4V/+6V/f/fWffv+nP7771z/+87t/+ssf/tt/C+1I4ALv JiTuTPDTlucSOPNZgiM1hynBSOAw+ZWPd9/CyRTM3lK/ukkKVvAWqMU30U1DyQHAxqyLICzj Fjv2wzjYEU1iP8wJQXCvdqzBPhec/X7NPArfGBpI6CVKoJsmQ1frf2WIZl+rbmmZ7ZN/s6nN 7fMb+noeGKU9GJQ9uC0jaQFQzp8PViaEn64I1TBcZnhvrxjRVV6vGMOAJilKBzBWhF0L/H7h OvnTwAOmcf/skjU5OPdN6pDfbAN1mBieb7BLePwubqyh22VikWn+J+/HAsclQU1FP7h35q8R 1BzqbAtCJLhBFndod4fJd9DiBuOEjix6FOeQ9CeRGLe/XSjajz9jzfFnCILm3vhck+9etm7y t6vmfnphMdpxbqkZCqsSjIRKnjCqWs0AU37t223ST6xqovvdS804YakVg1O8HVo8PE/wq+0d 6KsX9H56NioSg+3G3esiEuQl3z69cRDrD4KB4wCTFdvhtRGBbFflLtrM08ux0UxoK/QZrj4p 9Ane0Qx9ohP02nWco0Bl3TTxHE1jl7btQ2ybn5QVsg4sd4l2vlHdjT8Mzyy+fWuNWsyRoEkr mXTLD9feXP7PzgI+WjUuSGERFnG6w6nFtQboR27SDexDMimmLGkM2QQ7HdGR59VgVujlWA2r cRoeVnrB9ExCpy8HOtKIDrQrjcJ30XeaI03Uppjj8dhUnJ16u7ve3vz9rqXQ1oOQzsnVS1Rc 0pTt9d1325uP3x/uj/uVLaoUmWojuDV/cSt2h4fVbYg7bu2gkCgcwSLnQ17kM3bK0PTmRCN5 f0ZoG2gk63W+nhW+HGgjL/bUBVmijZwV3rCQkH8GR+ujjbx3dtWA/TP7M4TmBBt5i/wzSEJ0 3DEEuWO2l7hjgkYp8QveODtagww4d9b3fATeD6fMptHiAJocFiHiJJ36Go9M46t+sygTQbhD 8CrubfA5Dgq7QMJptUqm0+ERMp2SlTKdELlOpvuG0kKiy0v6qzdPdH2t9EewoeO1JXLT2N32 /ZUMKDbqM21/bDWvcNEyNSMCGFkrAhhtiYDgUggi4HQs3WQeMrQtMEQzbjLG4JY+HUs32YDd ZAZ5yYxT/11sfZWXjJmO+4eZloJ4s84EJszMOG+JecEVDJ23nMDEIdeM+33Hf7sipvA4h25y NwFneyMYsZA0omeEOKdrHb0R8/PCjl7On+LoNc5J4iBEq5YwMR1HLzF9R+/aNfgCjl5BmgpU TNAhj/X8OrTOKs+vH2a3sAS7RC/9eLffng5NlXROVgRNwo75grmSNIkg+6A6489kBtW5U87c 9dJMrBG7oTkW+rkgxcSlio3hc4oNU/njZvHjaSxy/uD+nF9AFweT1i9IwifszDdOCOnX+ZDj fOas5HKNUAgttBjuBakm4fhu83namN8wvqIc3y0YXxvkX73WNNvUCZrL4yOHmfGRdE1kNmYj LZ6ikl48PnJufFzmO5VqA8+L0918aNRqfGSzHIN/UV1v/Ump5kKicnVIVH2akKhaCInO63rO s6BWR0RVLyKq+hFRKL/VoiUodC1yst+IiOVNKTfVBiQMbUAXWuxtQM0uEFCaLsbX2cUbUM9t QC3yxxcHc9AbnMkIpP9gnIRXjdEiaLTU3GipS0ZLObVMXT4iZm5ElLhgebHKiXaaUVZcJvLD dnd9eHd/eN9UWnDG4CWqgVDP3JT1IXtKVdtmcz909DA7uu6OzTMDZ6JLeHEvKbOpc17iZlh0 KBu24OaZd+749NJhcK8CEcfWcKtiuNf66wvfToovrvbJ0uGxPllKOx6ZNY7alSd16XIp0XN6 1Xm+MAJ6RlpRttZRE3GFz+urpeKJvlpKKl+tRq5aOqe7ULeB9TDjqqXLS0xeatHoYc6ioboH HWAD6WEG7EB2wQJht9DFw4CyWfuILopwTvsCiS9C78xFEa4P99u77x4RUeqH8Afa+r772N39 8cYdNnedSJGL/mWx5II6L3my4miC08Nn9UTl5DSln6hN1A2BgqQm3mX59O/lLVXRI2BF1Hkr P1sDuEXcsmH5/HnO6QjfNl6uJVdLxKM/FcULMS0hcPECC2rd+HrdWevW9y8cLge4Yhlo81w+ 9KjHudlw2lYzLGAz5noqpvW5REvPK8nkGTosqFNcxeazpTXEI8l5TzR/joUaR9utS4hQqLyU bmtSY2ZucauLGlncUvianHE68xbt38I3C2ZRzcJJEwtnlYf39qq41Mre+/7jw8dpTfz07nDe X388Hf/98O4OpvC1fo95fGwmj6+X6FPm8ckija+XQ0QbWZn2mtc/KZ9LVwMJc4hRDvEDJno4 tyJBVpvzraFLNjlcbAqKhTHBotjgUrwHkDeWYokg901B1koW0KcBsw2ui56OYj8DU8ZPx1aL to77ZslAnN7V7I/7TrBBHDIuj40TPs3unb67D93YXaOk5F2HspNJXSZDA3JpRtjl9NLMp/dG AmQJqCtdf9IfkDQT3wapOBllvdtW/tH/DmrOY1795D8g+SejsDnOk99uNfpDwT8k/EN0XwCH 13kwVtB6MgdE9WvI5uOW2wEQep6ahJ7h6ho6oYLH8wR4PEEavBGLTRaYAPKih6Vu0tGxIVN0 FLJvTRYnyJPsyVuQJ9kT5avyJBkZ5vIki/CPU08K9ujaOgZ8l2EglwUczfBT5ytI9hijmC4u rJDdXcGdCFChu+sg28ILZP7lzv10F9OQ+eA/rhrhLgxjBtka2ZeVrHMmlCOcy1Fm3kqnJrFj O095lvH/Q+yTz7O2yS1BEofP+OvbnGC9L7hFmMufYNm9A7qiEVnbbEeMbAyj5zUZnCEU0Sul g4JbLFwV+MpHJvR+0NaeH4+ZDmzMCpjnxmm9e35BcUAlT7F8aLPXuw+FIG5smn7dJetDiv4+ mVPwrIx0asCLenP74CcP9PWMfar2Da4lcS2RilKuzzt1TNRNbkFmrhlIwpXX0vrtydYtq23L Wz+eWyFRN6BUsIIGyS9jI4v4jluvVvq0FN5yD5BW9PrcXZ7UZJIo3IqMn5x2CYn3tMbPncwX fla3PpvOHjeBxDTeuW9xy4GR1wtDn4XRmPVYWvR0P9NTop9rgHWXuwFEbWsBOrVr12yYetYp cBuRyOfpLI9+iULuYebepUVGxDP2kDt3KSP8snfGkjSz76QXvpMsvpMPLe7fHPgKY5ppY025 QUX/mEeH8Jpj37fRIo3aWgdzwyCKU2h7Lj2uWfw366nwwWsWLAtyr++MPUXLHcWbi09YWh98 92QY2+BP54YdPNk8yRAPkpIQwGnp70BXTHK+ME4WD3LWP8jBsNmkYHDgwtO0PDJ9xi9p00Qe 00nO3aJps+ci7jeTPsZ9izkA+JJx7th16ukTlM+0Ct2K66618EHmHR+89DwCEse8uBKr6ql2 cd9Ff6VbHH4o9yW9Z1BnraC228IvI/TBgoPWne+VTwx8otR2+cA2vexpRjXK9TuVpSJkbGNY mkZzfEWyVnKg/d1PwpWMFq47dz0LnEy5nWG6bv/dDgB4OHSAegUtud0RjTvW1/4GteZy69Vb Le4sRwc4qGKE4LLhaISqvPWSuC6MUL4iGaTOK/ZHGqF9PULIMgojBJhTwWplVBcZ2GCK2dCa YpAESqFE//HaGoBpZeYuZnV0WlAUdykblyAlFdigcCDs33Agqtl2qQdhMGWh9TPZmox90ZdI 42X7Mp4bC3pf9WVfLOA97gu0LJrLft+eF4c3SjiHkIkBwI+5deGCd6qnIMfp4f548yH4EJB8 rYZNNjYJEqGOFr36bsllARq3ui1Vt2XzU3HLiWYMgKUYQNub//aqbdT06AJDIS5SFOIiTfq/ +8O777cP++/e0XfHm4fD/Y3VMnP8oPFzDB+IZwwfRPf+XeTDQw/fHz4cT9PHv5KYaBByB0I6 QEjnBwMTPtjAHFVG9rhBRsIm22CTSbBNCai7LH0wBgFiaHalXSnqTwUU0rjSGl11JAuYrS+q GFdCxludKgNDIEW87ooQ/DEXpa7v3bt7mUT3uqhdYCbYFe+lfAD3lsEG8GZ7bl1RAd+MkQU+ /iBzZZZg5E8LJY1IwcyaQxaOYzADU64C0W/4UDCipqs8Xs11yQAZcH47qDrkh0/JYq7cZVaM 6kKgNZYemBoi0HMEGOcZn0XogK+6e12R0XfWIbt9f3g3iYfb/bYZ0t37+dGthhORGu6RSoyY DOgJfkiTt84wYNg3o5liuvNeP8ICK68O9xWYess16mBztloDTBfIBRBi9m1K9YNaFchCSE3I mMNriMJHOrrT612wzQoN17dIz1ntoLJrxW4LDwdkw90jBuDKT7j9hG1Q8q3hnqaH8u0xPuF7 ygp29Iy1iATsMCiyL4SSX4pZqEB2dbSwTHtHDGmLBSN9Rbp57qo12OE78sXye+4iaCy8CEcx p0clmTCDv3a2NUm5eFEWoxHNAqmg/M75U46xhOe6SaQSIUhpcduNsua8jmC6NWaIaSyOxeIW nFI41pl1yoVp4fURXG9TnIP++lAAddZXdgqnEw5F6tGoFmXj0HrM+zDSlB0ROY6fbVkKOH+G gXUYisDobhKc+w0sNZJmqkL+9tRYEOXj2TVYr7l6XFxRDSg7wBHrFIKsJmARcyzGZVcctuAY jxvflYYJSjlJ2Nw0VkW9PWuUX1Xb3F31gB942QkPyvB5mIeyeLUXNcU+RwvjhBk7S7UoviLN vl14Cd3hprF4Io8HEmd+xinHezPkIpPRW6LTCkJzlmWwAO+0R4hfDrnk4pgv+WRql2vtawi4 5WtYS4xSWY6vU0n1UF5NBdniBVEmxzI02dEbt0iUyZ2FDUiooAoZmFqdHcazyZcpo6qjDSl+ mAOqwJfsYvCBQ3zJrsSXcDU8ony5y1HLVUkNwDlwo+AfEt6H6qxyCArBf3HD4B/oFwL/AGgN rg38Q8M/YIu0hH/AhmsO/4At0LAFGrZAwxYo2AIFW6BgCxRsgRLdP2BzFGyOot0/YNukKf9Y gTEh4GTL4gmfoKatRkG5kOHw3CzB4YWEFZFTtkhQVJUpoGqFBhW4Qbjhm0IpTS8RUoJABjRf 4NbKEjo8pNAmI/06eid3O6wVcSWHxj4lcZ/a2w0Sstj+K+jLg5TQLZTx1tWgTGdQeg/QAVAa zvAIvgmNU2wHmPETEjmMq81J+0kkQsmVCbBCqVYC7IhyaMaKj3osCyaN80k1Qq1IGyIU5s2M VeKNLqwhQhFn9TRpbmByAho66IpA7AmnzyZLAxQpCUyD/t1DmfLdzgxzdYyUUpSItDN3gQLK 0V2LoYVOdz8w7Brc+/mpiRsys4ls6qTEae68OowpOtLaEYogXTgQRYR0Oer8iTMv4UzWrPWA 9Y6GiQD0QdcNOuiWTlH2DpsfhHumPkdO7IAW2592h3c/fDw+5C0Tkt5oogiT1Of9802xwqwe EjjRpAQZLou5Q4PkuDR4LrqWLRfb7knfcVqQLj1m4aGpz+mh2DSRmv/hENvjm5jHu3o1OEBk 87vBUxK7DSvogpLXg+Td1odP/DitlnOOg9etvo4D6tueuKb0t/BteV86kkuRVmS8GTInuWup RacjrqqYfihGGXvVgxCQ+cUG+ETPkOnURnFMZnRGllw+kvC3DTaEs0x3Y1JqkKAQ9DAmLXIa Lj9IwyVqpH0K6pEEaVMQL/sl/0EI1AjJoIb+b1glq1+yQkHj0sDQUGkn9HS2SjvrWhUNBS/K F0GXyR3Z03U5+6GuMmc/0dfmMOOuL1beVvKaql38Au9oedNPYqWaB5JXBrF0JnFFP9ukLufP D+RZJpXMTWr2R0MHQdmnPH2Yf5l4tI7D94TfsDsm3BFhbXBycxLwAB0ABFWASV8a2q6ReAoR 4bvKNy1nzP5cvD/pv7VXBRXkjRJ58G+vGFSrVMnOPrCXP1zf7rbXp//MlNDpuYT1yX6wrMUO NsYIdO+y8qkqLBUWmglKRePKUoRkpl+e31gUxh7BG0mzmHGktl9B+pOCBg2egtIEkFSrSZ0z cqGYafryfMSqxfnn3ogy9kzubNRDmTKIwzbOj4ZcPNP9rC47j/RuWbm7BqywBo30/u+H+3e7 nybl++72dHQB7N4yyz7Y9HbkMCv0dWQyJiXGjWBWs9x6HXCeCUySn+mX53L++N61fmr8u4db Z0BM/1yYICBMmx2JIaVCu69HpMjDHIu6vJC5AdDS74u4nGAcTT5QA3u7UwDquea4hIkt5rTq r5sN4HLnhTe78ponX2X0hPttTwfMl1JKGygD/B6Kx0LK/XZH1zGvnaCZU1cSYmD1A5K3HiDJ Qk43GlmJyqYUbQFrOrZsLK0yoDSej3eT4nt4d/rp5mF7DunG72/vf9zejz2T1rd4M6/cAAUj 6ysAJ4vxrdNPbFZfqehsGiUGyGvANc8y7X5JjS6Yt5x4ncw/y3gcWK5d6gugPO7S4kxfMOt4 cRqF2qeH9QajUv3pGNC+4zVEmjsvekaWZiA50BqcxyGmTJvFeIASOetBwC8ggew0mBS9QLqS kqITuEMNtc8zWmlAoYu393GtBJRIwnbkJeJH231uVjMLqhJ9EaVMIhKvWuMSzAZPpDGbpiZl W+WjzVAPI1byqJp0Ii9SvaAujefOcawGAnUl3VOVyh2Q9pB2TaObxo6OPTbeOcc3OShGx7iQ p6eJ6AmR+Ao+NIOWyWNYDCJpeCLzyUYyE1OEnB5KYwBBrb3rYEkChe5PN+/8M7vEBMGtsFRU 9USRcpBtlSPoFwgi5QCFq+QQKGl4iRzaV4xdgPjuioI4tRML2d84NY6TVYer4hR5DKuDMpXz EQ6Hr3iyzeotGlamQ98rzi4/oBTnnfNJcfE8x1Nc+lx214Rj81DiMYeTEmvXhJKPomwLB4DM iBslQb5BXgNo/TirqiOxQ4UVvKD879JoXIEluPK23g9lyh/t6egjBtL4olzaAL4gWvAFBfz8 YUld//H2fny3u/14M27vf3p311XDm7PpW6Jk+zC9Qaepuxuv2nzSxjM8RAbUpoNIcH54MhPK 9+gYtkgnKKjqwCtSkUK6S3tRt/YiT4UDMuKiD4zZlgk1oab0zQ7qChV4JRzMY86JHmF26c43 FAdfBI9QLdQC1/Cda7gAcp16uW57G7ol+jLIYymZQx+wBFDB/Q/6xNa12t4n8UgPaNI5ywHe jB+JXSzyYvr6UgaepEEQEZlCihtWK4k5BRSfxAmshMFzJSKowg+VTiigqEGMb4jbCC7TLTsM GvKnBrdJ/74dcJ5BpGwV5sm+KG+4NqoArSORem+Kywj0k3FnAYJArVeOa73pKM5RCIi+5n1z WDd19i2bEo+bUy29CStjSZ9TrMLGXrcKqLGS7yugkMrAL2HFEIsSP1Zuxzb9x5jRd9KPVmYB Gb7tBARtH3HMrSnKM1E3RlK5UF4O/bnQHHizLn+wyTn4PMThvVB5zk04SHMvrfYqCFtLfeAa KoPPoLwrSLaClUofQ7RCcY1TOM9FpByuJm5kJ3YwB3nxRttuCV4GfMgurdTtfmN6EXH7Y9pl aEenGixiIM3BPuL2ilqtBH7n8CbaA+MM2OvBey8LaqOISZvhR1B3rvN+42uR681SNGh3zt4T QZLyWQN1OtyzgpRlTE8Ray/CHvL4Ho/FbeJ7KrSOXcIFoqfjGe6hecgiykJm+O4i4oesRvxA yvsO4qdLeS+IXod1ymGC81p+4RQXKmvKTIepcl00K7nyBQhCXQjrKZI9w5rL6dJxjVBQL4fy tIau0KFHwfUWjh4Wk/aHsmj5XeI07SLWKTrdzNgTbiHQM92RxM4HJ3Y0OuXCwQwkocgUBFhz rlRgUBGKkpkIcal/OeweN2ZBxAG+5keJOOBjELyNK5y+wmRDaCXfCrDEZr0p1oHWBiJGL4ez fgRTeR3FWOiIFaPWeskOuOby+KY8hoq14HcMSQvhJh5A7pugTEF7RXDFNuucpR3vIjddj1i2 HPtYNF8FlG8avtLLnJWToFkV8704uGvE2tiurwYv1LIMHVux1nFFrLVJ4pid1tGNNl4jtqaE SfAD1Y86ixzHXhV1FkM/6mzkZwo6G/kSMWdBLos5C7oQc35KcHnXV7xzv3YZeGxkEUSmFwSR i4Y+NYjcsBQaKUkvFj4W7OLwseCrpq4KH1fRSyPlppGDlcLEuzOQZ3JdlNh4QnZfxLgfJE7l zY2jdzNqPkScb7dgPSdEmhHimfm6JEKMjqinRIhTuXGX4Kv4phvp+xs6lft+mip2t3vG2J02 bP50FdYvow27OHanDX+Z41BbH9D641Ab+WUfh9rImeOQXXYcypnjcBg+03E4DC9xHKoLj0P9 JR2HA/31OAzzYi4+DuXwXMfhIFYfh9qYdaAp7hj3zcJxmLIZjOO3M2SYR0zllA3h6PqJxyM/ XxKg8Tl6Sj7NGpP0ydaYzsVNH2+N6VyP+5mPH8YuOn4CWvDLPX4gXKw6foaLjh/J+sePZvrz HD/xw897/Eh+2fEjxRd0/Gg+/Hr8hHmRlx8/6pmOH83Z+uOHqVXHj3a+bDIYus4a066EjOZ6 nTVmX//zs8b8oHClvnBrTEm5cLp6SI28HEmZ6zo/73GopL7kOFShyPIXexwql7vXOQ4nVe2i 49D0j0MVyut+8uNQpbq+z3kcquGy41CRL+g4VA7w/etxaOeFXnwcgjrRTzsOlSuyuO44VIqu tMYEd7ezddaY0tZvpzRbbY0plybNcwTpWawxpR2Mzqg5nqd0GgmMTHSiKrlXK3xWOKd2nXNK oHMqAAtzOT9/IWJKfbQ1Q5NTHVgA4pOJtIGKegwSkeYWoXQieC8jAgM5b5HImHhVSCvPNuMp xk4NZuFKX09ys83E+MHf49QHkUz0kuUu9JPPsxh2CMIcLWsV0qbtlD3IekEiiDEANcFYZTiY 43/ICAncCtw0xFwQ+PwrNlWsWgyz2pLGEqSx4Emk9M7oqxAblssoXT2AOrHTKCIB18HqcMEK zS2WEXDDyHfNPRHu2bkNxnYgVM98qJ4ngKxAPEa6jNRbSht3V5Z0QOdBaWoVn4cr7ZCISBKm JQTchV+junzxvnyxg8tzAQqu7/37TSwc4MP+ugnLAEe4cVQHaBLImzr5JJLxgQO1sdHC8Djx y0Vmybwis21DN7kBqlrrh0e6IBWk+YHymAiAMyZ5LQf5lhlZSFuIl8SUrhHf4nJsH7AwbL+J kVYCV1NyQMjW2NhyixWiuBTlMI8+kx0wZIYftuAHgAopVIlUf8SBgaSD9EpQSJsInFFfnUzt PHtM+Nc0clrFzyKKrwJW++SnDPxdVzkWv2mXaQEQ0Jm2eI7T5q54jtt6GB/04typpLJ6guuC 4/aKckyHBfZ6alvQ0M7v7w+H1RWDm1TN7e5GGdvuadiYKhe58XigxerFY1PXLfwJ4DbFwPGW OKcr3SDQf4OLIanZIi/cI26k8+/+tw3aEeldykGsTtl4LWBYfew5j8XGY6XIwB5ZVIoMV5Oc ZRkHvEtAblGAlHcYQryAMQ/IZ8SuHE73kxOVuHHF26o6AilVqupTA1ZWtQW8rsVTxgt26ixr Au13MoM/uOQkWpKMf789v3u/PV5/vD+cmizjHtlfssY2qBsIAvxjmm5CC96Q6T+8IPCmxcmb ++ZzO6SQXgFKQUSP/OfhTbtzoePEnM8P6EpDSWzz5G3dgLF5NvDxiAI1s/TgiZ4v0oOPR5cC xsv+5EwGb0oevt/f/VRsnyTcVsxke+QtnBeMfCKzTs49Xg4fZKHhiAUtLrwRLzxgTGgytwIQ IXRmOp9ZEuGtSxRBUsh82tNkSE9CFx8kUc24a4CIQUnW8E9XgCL8k+V/5vKtropFUaZ1rgLs V+pNrNvq2GM7tVnnsu9BltB8FlE/+VqzbvJ1lVCdCfDIQoI21jxGmP7xLcieQfkpbopPOTgq MzdCqNeWjWHH67s+g03TJsfirnGg7HEfi+ymkscKCpmo6u8yqNvJX2vf+aZKSZZNPb5Beo1L NwJ6biMHwktKFyuXzkgpSgaUhIbbQheAWoTPZ5W0b7nED9Ei/VSD14PlVeYPVCqATnBJMAva fUJ3Zw2UPgPKQa0yAGII/cjZS5UFpVphqItHzp4D0UnnkV83eyAAQAgivpeKNknxb8CH1MrZ E0kD8qGEwE6StB//N0wjS+xeLhEoc0Ek3UpfkEymIVidtxL3aEML6vC5tnQjIR6pGwF6VjEb PmPF4QJLdjxZK1JtrYjQQreBWlG+Mq8V7XAtFSnUGq1ot6poyr4smuI8NVLovlaEhEgKlDbV pLqqzvOpSYSWalK+8mg1Sa5Qk/bnS9WkdELKZcZHLV54oyXwwc9zo5lPuNEsheULbzQ9/GNu NP0iG81cstGGIteeNnPt+w4PvezKCDqchglrc34F9wmxsszHYzwQyca4YPPzMr+zdEnohkfi UhlhF9OlMmI8t2WEIWhPjeeXlBGaP5+M6Lgo3JEAdNGXdk2MeMShdQIuwGEr4kbAdosrco9X 5D5vWjM8g2sCLIXwVnKBKFDmQlGwuO+D1m5ozyc6q2uTriu2lEGZ2oeuLLGw0l9KHuUuBaQV RR280hWL6TGSYzdcLmt04doKDU5Cvx2a9VzX1olwEkRTEJMD+coHEJEZdBGkzSO6OyeKH+HL IdDXAb1VlBdO13aZ2APAEByDFwUOGtvU72yfv4VcKFXyNF5HZhl6KJbo3bwDSPCEfCHec0TI 61ZI4RA+D11CrtRSi/xmrm2Nlxi6mV2fs/U5WgUtqqorCfZzIdMKa+nsHbrtVQe1eI5Qgeci 4/ySUMHu/Fy6ujDs06nqwrz4MSyM+NIiBS+hmRv+/JECK0TWn8ZZfWvXPKBDv17yDFHRobeo AG4rS4hm/dhF/hvvAQ9cZFQ3EHk5dFyecYy1adHyIddwjJYAciTFmyE5wN9XI/W2Z0QB2C6H QPQ8YJww4dkgm0Xb+w8K4xhxjMHC9Ip2EIi7FSXKoABnruh4K3B6xURZK9wB5BjNBFZyAKlv cmhAb2LNzJJEUhjRRGnmOrgIFcS6BTXDDhqWCufJQWyKrQiIbZguhANhNeLXfQa8hKGXTB9o DkVlJBanU4047JDJ784lCmZoVnTNgHtcdjocKNeHVvERX0iZt4r9YRhfgTqWA/AOArUNdvtU 1tTNPoy+Ppv5GRUt6phkkqS/3ez89JlmgeD8I4qn7AvqRVYBB4I2JgrZvquKtfC0AO1XFqIv cRPPkmMZWEQPIGVCEb0MJQz9NQhVOX3EqhmS8pUMWpLq8mzGDFpjk0FrCxm0QtIGG92XQVSU ZlIx5xagBoRe9FhwsI1leTyANK852DrF2uUyqawkGEQIEPqAbM2himROgGUUA5xyps3pWMby TseCHtnnWWGyNUBcJUMVk5ddGI77HRB2LywMpp5pYWi3LgAlVixLrAElVhDAFbVaVVOe8DZ3 Vn2jQOIeipdQ0pEnNq9wtEH253yL29yIPYwEHZSNfd7I3E/g9Bx0jVhmkVxMDqZJxDj9ErkQ 4/cFpPe7jpsJcZdp93adeeBNjxtNElVuWdczv2eJhOFS9jKblpLlTUtXb9pclPeFNm3YUMZ9 jG26Nd4lFWteH04Q6vNXKHnmksJiqaQwV89RUlj0Swpz9YiSwlxfVFKYu+KxfJlkNICFnFQS okMyujt3LQvHAdU+4IQQcwdczjwES3aNwm7KjWRrIs/VDxar6weLT1M/WDxD/WCzUD9YDm5g REEe2qgUHBtVgn9WnXD7VEnaJbQREvlwr/GJJwTH+DC/TjCFfkACNk+ztjMTn3HJoW8J972c NJt5fusGD3YwCz1wSjZRTdhPcBG1tTcnETe1y4sbunWeC+prUNS2sFhaVNjViEHjFaQBQY5x AdmvO6MW4v2kHkYH1HnuUbOiEvN5h4kWg0+g0ZCbhbaIzJEZujv3exIQw64n0Z8cKbt3Lcru HfLZt7q3jsl7fhAcezm0hg89XnQ/abpeDB3C9FzdeLcubGBdgAsrpIim0FXDLQxwoDR9eNhl 1hnxbemumxZEsxh1c6m5VIryofYw24WGsH7o7br+4aqTaFqlmV4Ukui/JEB49y8S1VjQUUm1 JfXQTROer6Poq6TTYW6F8WI90tJ9kpwWrpqywvHTel+D3b4mnAvCmkXIbmYs5+qdJE9EpeB2 gnHBzsw1LFo+LdOMTtnq0ptHjrb3SjUL2zeSUvqzkoIPpBWiqpaOxgZqpkK4ovleEL7wqY6+ yjbpx8PG44w3mVyKjKlTbGLlZMUXTbwhxcZeLLNlagf7RaS2sNmAlRxoHZbys7DpAlxw4Aoq 2jwp2imUuSrbyb8D9il/hPW1+V1Q5xneciWdxf1hb6tinb+f/rjdd73n1TymFekCa2yyGJ3s HjYNKV1VPklZ3ymSEjxYNgLh5EpZlJQ15EQlbGppEaqVKtmsXkXEbPWqxWJZ0En2AiwUWbVH CdkGsDZkzhrOaVMF2rdVoFQ8DQEH7QCZFtjnisHeLGbzcgay6EO2fFuVamkZtojl/COnY34E JKtuC79txktNLUpHlys/aAuHbRoYpdlSYnKxWJhLEWd8M0eZ5YuFxdawxbImRJmiqFB5Gq8p EgWDjFQ3Fwgq2VRU3WiYckkBb6GXwILSBXImklQdCzqH8VgkW4/H5GGxp2/TNlyqCl5ZrEAW +uTnUm921k3OitudO2twC6zJSS90uYepSOE3jA5D9N705WwSIMMcpcwPr3iRjR7Wji9/Lbi4 RFAQQuSXIymY2RT208y2H4+1pDgtSBd9qaTwtW4JKSt5pZOjxI7BCuZldqWnVGjugKrMS6dk 3YIe7iIratj0QNUrVK118B0XmV+A7/Sh2axJaeCU0EuSNOTQy4ZiBaIAIb/YI5M02IsnaSj+ 5SdpsAoKxp4IBUN4h2dL0pDDBdlQ04kybJbUycrRcInrAB+IleeqrEBUOlXjoUIg4QwmYZpR 4OEZCYqtebAZLf23xEMrXNyn4op0gSGqliJCuZCUvb3EL/iQn9vKgjkMJ6PPUUvKqz7tYlII wXbtvZihgbbEVDtmdTqWxbMB02urwN3piIkwaJPCxdteNbcGXVf8jvkinnx9gbt8sF4eksqV lXMophOS4iuKMCQnQhmSWhPL6oapXPk1V5w8h6lAQ1lRiQ8AMXIQebHGXa58mGuWhXhlPpum tUTjaudT34kSCbBwnT4eiFan3weozvmSZm4bCg+TiDwGFhDPM9R/jXs9k1NVDHYVve86+vrG cztHQk76ttA23tDmvE8vS83XLJhkptn8im7p8ubvcfON4PPNN0WJItT8kuPAuKIyxEchWtxF vXS3EoVbHZ5+zWT/eswCsTtzV6D9Wget1PoZsP6k6TMNvpuXxvoTD9v5VHm5+uXzcs0/ZF6u w2U9v8pHBqjyeQbVTZfHMNjmiWcmtHTIYOupt4caZ+QDOE0/KLbjWaSgu0HqWI8qlTXeoiPr YPHl1nuxu2B/bmAN++SM/rSPigRqFLiU+Gz3q/hsr1SuXx+xI/iR+DKng2u9wEQJyQgLklmQ ClodFy3ySOz5QV0ueBwrePw6gka7epyHeN/ChX+LAAhcDN6ehZwMDNiFjwWQVLCULfCyhnh1 Jyod8CXuznE29tzwqy3AS+ZeivWYhQSEXHBXZ2Wyw7oTYgqElGzOfiIScrvL3yodp5ikVQGf 7ISTlC5D1tUGw47fOFNOv04xJcnoDACS8QsAkGzJFSwZv3wI2cwQWu12Zgi5++YwM4SMePUv DxMytLNjUiBO14RVFURvurDYyZZYU787qODEASDpsKllSIeGOXZTlCO0TSPkCmzPDK6zh0uH I0zMEUQtLzI5v8jSevW3Q3L63bnP0OyomDeFvuQ67mIiFpLYUKQTvM/dgD4DQLXCY3+T1zwi sIvwfzoi4x0oVm+PRVuWIFRQuT+8D/fiMEeGecdoD9oybh5UDx/uYBvfBNstQbtb/pAOcNwu DwcD3/R7FnDup5ftq8NHy6FA+PKy/RWu3g7PHHp+eRxu/EA4G5eITWNUdTKF/W1iAD4ib9/5 ROfS4mv1pMLZbaNBlW1wwLtgD+9TTsNpfcX3YBoI53oYcmGVbxhFpqcIzj6vADW9ZQAiVAOH ti1IsEcSSQzGlQyXpyFG83gHdFmdUiH4K/eIDUCmsfBq8imXukmpJ/nhKIccOHggL1/0PgHv PUsg6aTBL5o/TXaZdYw2EjipxzOke1kR8HhkfIMOnzC+IV8+viGfFt9YP7nZKG5P2TPEN1Zz IVn8+OLSeYSxS4cL4hvCDItYWxgy132obUjmpb3Qf0p4cWeLZhdQ3nxB4Gf9COwzu8Q7m43d xhgvZhlEdlmXmQohIc8G68qamXR1KyQkH/Ffye2b+4qgq8Bj0rj1ItTL9kW44xoiz1+gLzYT 3+cHdrUCqzfMaQUkaVUAOSxxVCOc7+CK1wDGczzvc8AGnvfb+rzXSPXBmaZIC5Mzmo4sNB3e 6hNv9clp0LhT4FK7VyBVtNstwnr98umYoWPO+0JYsSNLraTapxjNlGkWGKpvxPLlor4RQo4Q z/vSUKSKiEdN/MBNSmRmzfIi2PUVLDRe6Grlu2J8uCLcYzPQcNi2wCJBnT0rNl2OhWDfmLH6 WnRpVEKgbfYg0Z4sJ3ywmbHtOW+ZR97+l/qFxasZXAVu0Qq3e6fAYPyZQdileaw+VJ05mccV hbLnVQlD6NNTW6fPdFNbDaGNLNVss6zKd8X+sHN6dQ4Qno52kKf/BpPWBCUw1twLlfEoTyX3 3FyY5EBKt7j1nKuNuvlSOQkxtKJbebLK+l4TQU/ggrCv7fowVPUdX4bSlbnehrJWrvcWgQVC BBJgA/zm2eN6oTkz1FC+HOLfId8eoD0P6aqZDgrZMOArGc0oYmRJ54Qu14x+jq+h/tgmFRgY bhDp1i8vTkG/kEIjFD7ySFFEpjDboZleGvLPaba79b9ZWOTeCUndJs2Oz3SnWxE4TIxGyQ1Q QmGwxpLYt6oFXbECwIKhGBiCEywvGFAK4KIEtNjikH+/loZaqKWh5mtpSEq7aM9OnYwMJi5r ycG6G1tQywsJUpyjt6u9WMCX1ApJJa+WzyswTK4qNWo4rYpkrKg4SryD2XC6WSNcJ/2aLkhX jCPbpckeBg4k7i4WyJuh1BhhRchZges2ZiYLcLLWlcbqyVou18parlbL2nFB1mYcluH6kbIW UAOcjn1/UdBKUjZRT9hyPSNsHbsE8dGajrB1n3BluOd0I497H9RL60a2bO28bqS0fLpupDTv 6kZKy74ahBWmsZ+0GWUXn0VxVru08NuESuO7LGjGxN/nXePuOFUa1BzHLLjKmckqOxYuOGaU ef5jpiihWwLH5s+I5VNm5hSRn/MU8ajDMhgylMcIgtsWAZLBsnNosq5stSb6kWeJcl/Ra3QY Tczli0o7jWflolJPWlQqnmRUiIz8dEcZMQT/6I+5HaQ5IYZsEPgPhQoDVnqpnPuP1mrd3X68 Gbf3P11CYX3ziIpcmrE5Ie5dIA7dV8vl6elIqDSzifRnV8WWJGepkEU5aU9CLbpyUkvubhCP kJPa1cH9pHKyTwKuFkjALdPg1GQlNmtPuaROaJvV26Sx0kqt5K8C6GutvJYn+2uWeHYgD9Vo rVmjhqU1y8hnXbMgvWFpzZbuEiIdTNto2lu1xCMpTOYBusSKVOYLtCIfv67tBjYRlIOX8O48 y3gYpHvWm43qChKXcWyMWnUMT8o1QRjfND0yH6XXof0uHj0MZJX7YBg8gj+TBl4w81bnf/ZD +LFTr0onPWFigzJgPeQMYPraDFGd/Q2hEYERwEqYKsGoTkTfYQbtwCGwP6MOIW4Zj0fFzC67 fvpBjGR5F3gZL6u5Wsbz6jAaSoUDOduinXFeRQq1cCEFkl1wDmQAITcpzYvNQ26ABCwgN95V R2gDcRNX1I/XVi5i1x0fGO0570AJS/ChJZcfBtuwVvQtbFLVHY9BofHgvYS9ZAXHARmPrQGB NSGrEZl+/DHXiZwbFPQ1ir82Myr+sTAsniJEDivI5iim95PKB8/Zy0Z3FHcYUlXMW1YkBDVL +LAwLgU+DIwWwoftsaN5f17Ch+2LVbc/147mkPc2QKAeUTInebKcfJdBfMCX4xM9JdHdXStD aKW3a0FIvFyPAXjo15/+MV4qVmhnMQKmX1hkFgA+8+i5v+FaLOPjRKjCB5QTT+J5ynnXE6RT bkXg9bn3i6ogqcxOLZTVsu0S1NdPJgcVQ8klTYRcyDa5P/TSWPbn5ZcUWS2ZbINI3Onm154t iyV6FrWDEs4cIrI4RGbQDJV4ZHA9EvZjurhyRQKWa7gkAUc2XJPuAhKQFbhhEHxTpTIfZ7Gz AygWCD1DQBjhgEKIfYqSK6MZvN9P2uCH2/uf3k1KTPZbeMYjwD1SuiLQWshsxo6HCQ+qyqLw vshFcbNHkssaTKEdw/11ISXjn04ry396CelmzqrgUz9yuZPoDM2nMzey0CVFpA9cNEyhj7VQ +UViJasT1zsJJP6Z5Rx2A6LMKR/fKbtkhiZZi7U56dkuhDnpexT62Fc56XsoBbLK26dJ1urS nPT9+px0neStLjLSXY6+B/mtIU4GEwnPhMWU9DEZK/EFVby4maQuhuTVzknqKIudsV6W+qEg AQJnvPJkGpHN4YmhhdOxEVrwsPuB8a5fcuBLEI0q2eAQuPw4WSO7MPCoI6ba8SzPJyRY7ROZ jXMm5gHbxApZkuoePyuyJIgBT+3JZ6Al069rsSXTrS8BLpleuwJdknm1VqJLyIDRJW76ZiOe tiGbmewukaISa5Pt3BOtZLvYceU/azYNmR5XHXe6TraRclWiQpnsGDW7GpT//Z1vdEHC71kR p804fY+TTT92kKpD4bYUmi7cf0gB3p0xwFDKFzbjnAueCNNB4O3aNSNKSHfJ2CUd371Wss5s GsZHaWcgbteM0Sm9Lkan6WrfoIteaLoqKpfqQl8SwtD8M0XlAL6EBDdwGbEronJsUwbhgBTb nT9DVM4HmBoJdlCrLF6ihVgEOepY1aCKQL7Q4amlQ+fl5Oi63UbLx538BmVjPH/bjTK+OIXZ PBN2fC7FhPg8OSJpRikW4Ayl9ZM0NGybRHyMcajBi3PyRcq/ap1xhlYLWsQE8nlt5oyYpo7w sCsVBUm1mibTyEalxaDKJPsOK6mQojTRd8aD17uEfKGumcSIS118pf8V+lo7Tj5/S+VFXcCT gmwtjCetfbDCCxn/TYnlsmB8yR8/ouJR8+7n0sMJvc/7QlPs+eP350d4nqGpEzjvVaKgvHKi ZjyXPLq8ojmLdqznCHReKe/zen9/OPi3JlVt//H+/nDz8O7hu/vDdmzRw1OuG+wI6d2IRteT /QFTGzFiAaKGqV++IUkuesI8mMg2+KQEMWwKH/vSOXB6uD/efHi3++nh8O7h9p0VrescPolW DwbAswAy0kMBoS74eVukmfcJo8oIL9+iII+VS70Ry6k3FdHCU45Ab8dRAFw943qIUF2Tjy2I GCO02atGfChIIP/jpxpr7eKkFoy6euPWjfEb1/29LQSGUiApO+GRYQddT3Yf37tu3N2eYk+m f67vzLqWoyYm356SGpd+AQzL5aK0GU2/DtTsQIUVJWJW4qyqs0WqDipgdJmms02azva6BZvA pdLyrA5hVtnPdlaTBf8cs7qD1ZB259clw6XyVe7Ir6O1PFrxVHcctsEj/S0M24TwncJoCD5k B1VWCv3Bowb5cnsKVAkfC0snfnd+2LIrt+DsqGY7djXODlMmPWWywWUQ47/kFJY6QlqpZ/cE NKK+Vsv93w/3/nicFsjx4Xh7U5jZuQNA8S0Jr3O/coTFjoneIAQjfYOcs3Mtm13BvSEez0uU 3IWYrztZLO6xRGKKJSU7TARD8wYmtlMZfnqEr5qrYpqqnk7DTsimYHIpSowVNd0Cg63jwFOD WOVFVI7oajoWikK2FdA/kJooRz2uiOzcDpyPH8LrvWxLdxjZmKV6AgGLdwZwdca1QqG5gf54 N05vfHf66eZhew5a8fvb+x+392N3eYWz0g8K4BG8IAa0C3B59aLeKs9BJ/vsFUINS5glnIZU 5MJWpHvbcwcbIQuPb8QsZcscYR6RMwN1D6VKeu8GKHRYZMtmC24y3TyqQXQHY/pRrRyN/bmX GYyi2ZgdAxhQPQTX2CIxhI6Lscgd3te+nrGbOwwrfHlmqoGVOMQRDAcTT1ocXyDh2ZJXNIV3 PRqR9ReLsTXjQWd2zSEYz4Vrfd8E7ZX0KGgR7TBfCsCZd+lSQO4wpksBG8Liz11SRbeLWpmf mXAoMuAWpEOdJ+K56juiUpCnjAakb1wzGjU9UAWf1ct+X93reoY7CsdZbDJL/3pvv57z9gsC vP2eHjKVl7ySRdi6e4ZzdFgHB09y7Mwg5QDnHqoePvs1sfJrFVhUNoAgUIVJqvkjVJg6dJ5B HmtVmEpjSHnZPvfJBTY6hRCUL6otc+2R5+9iyRbkg67P0/VGBbnrckSAINDO2aoWna3PHivF ztPK+wosZJZhBL3qzVdF+eaY60bl09Bp9gXO5SE2NUrNwXGLvJr9uVB/tykH1qPMhEMFnKGY z8+AwiunVGPVPlcj1JfAbIkdt1wTOXElEVFPqxQSUbuanT0iak7X1NkJTeHEvY82iKg7SM+Q YMjniKghVXdNRM19YSbdpuEGdNQe0yaHYVMNSKKc9gMi5pi55SIzN8iGcWTR0yMXM3Nz1R4Q f1ZLmr/gownULPZKzfVKX9IrhxIQ+hG90nO90nSGvb+RQJ53QlsmpO0xn/GNIjG7c7FqRDgA NRrfPRpfn1miIfYQ9N33zayBBodvag/KNY3xHc9ztPXczI2vyQejQ+EuULEqNVvmAgKnx3OR sEC8Vd4pnaSkDzcK0b9HG2+jULCx2VwOCWAwkSq5IIihJYX/sZ8nu42PWGwR2yD6h/HYwUEk 11PwZFeuNC+tXAUqQRtJUKEIieRFUhOhOmZgebST4ycQtAeW0WKBGq5mRFmPoyJDpHKA1EUv ThanFe1LLS3VSkCvlvoF8Lxamk8A57WAslk0r5amn+mglQ9LELJZgKxpNVxuI5EZG2mauwIR pSWgzTVYckxT5CUtuXzDW1KFtOHl5RveceUp+fwb3ijx+A1vlG+X6G14o9QqLshluGGV0OA2 vNl8egy/MXyGsSwdo4uMZRnh8JzskIZ8CnZItQDfN3OpTcZ4VgOiNgs4T2Po5RtezTlFpjMb b3gDSWmLDW8cI5pQsrgDKF8O3WUo7b/D8fYpzp8jkQcV0CgyeZTlyqsrqrQrbriYklgmYFWC b8qkwirCo3XTd/CICiuxTG2F6u2HWJQIRXaHy4WyLaIThbLWFwtlp0cqSp5fKKuUwP0Ioawc 56iiQxeyHOqqrtPCgm/GLxnK1qhhHEjlgN4HPIELHJItHUvNOQAUEytFrmLyBUSuYmol82XC QOCo/KysBryRY+GUUGyBNlIxNZtDNYhLhesgZoTrNEvONRWdCYGIB0eAr8PFXPg07GPnmbGM N5vnJS59Nl0AEZdmYLrPCs++rSd77w/ZY29fP5cuOIjV6YKDfJF0wUF9AnVjmSDVNqSvcNjp WaJGtYPZPcTt8DnmvRJhU6CUJ9nn4XukSXcW2M7op8WqDc+GVdPPCFXT4EDUr8t0D+pCYq48 1dxwExcZ0ZpdJDMARaQOWfbVUfWyLgMzw3ms9VrOY63VS7gMtF5XQv4ylwEtXAaaL7gM9Azl sdaB8pjOuAy0ywjVjwir0jmXgSnDqlrLvstAOzHOgXOWlvVu63K0eXQ7SWwEXebdyiHhJZAO DNRYg5lwWUa3E+TCu8FZHreqJN4pwvvF6+bzebetfF5jfOE2xp6A7TLpbTp4boZnbaRWvsyB ZpfbHhZqmmwPdbnt4QL6/AUcQi7S9Vjbw8e6pldsSo/N9twzXF3MpY2AkoHfqchi2/eAGxCo UQJblmAsbdDKHiI39gUfgHR0AFryR6iscY2S7F0Mhdb5lw1kWEcJP6dOzNHC2/8Ojx2A/bl9 SKecu+cYkAW4bg/u4S0kzfLhIZZI8KdjI7NhsiYbZgTo7M8FhsaXvx5AieF9Ib8zwwRMXIGG WbjDbg44qHD9E8coLT7jhO3OLzlhmidTT/PlYtHEbBYpawZOZ+wM7nySuQTDL24LGKDmc7Uc 45XkH1UcGl/gK8cFf3G7yyiS/f3D4lIAgXYIv8gBH5IDNYQ2MBkJAOBpb9mmsUDagMVecXEz 9rNgAWwRD4AZG/xikJxWGfFIJ5gK+QyfNgKeuHRb3lmj13pnM6fHc5qzw/AJIuDKLJRL08Mw Y84GEOgwU8FHOYNI50zH9T7bOZSwHlgREFNGd88nFZKzB/5pGWuij05w9qwGnOLhtWTTip0N /djZikCIYrzHYZRjZ4q2Y2dFNlondobyokDsTNF1sTPm8Z+iH9/U0mWpkVYsKSwvfqE7s8wI e8HU25V5ic+Vfr4m5y9huu0ZBBT8VNteNNKt/BFLioEnuNwBw+WU3O9hGChv1cvlLl6jBL3Q e0qj91QJDr2n9BkCfXIu0CdWB/rEiwT6xOcK9ImlQJ+YiX4o4fGOg9wsRNGVuDyKNci5iGCA Isc1WhZFUM55qEQ/8qJCmhyttOBGpnQ8l+1QVkuwn96aZE5PLS4KN/vPVEfc8yjHQzdtIiUF EhD/oIuF9HQ3v1CZX37u6bp8QxXiCQyy1g4vy3hTRrs4I62zIMGhnasFkY+XjtVyfrWVV4t+ 0koizLKm5YzIOXav3bJ/dfcM06aFT5hwRHkXsDIqs0J7M+rT6rhewTe8H0wyjqLWRNT7qjVg bNpEzfDWLKdCWvRtn6qm8sopN9pjB+v0p1KtVWzmVHElNBQXfdnI1bOmXn8pRIMr5WFIWQpl 17KjYZ9zx5jMeUtLp5DOSWldU2hFCuKMKVRnE84lH/aixTa7btN1HAkfn3B6VIVKgMnrxvNS 8Dk+P72GMGbmdFk2baqUIzC/zvqwaSibZlmt1C5UKQsKXjerxDwad0HJEyCCa3TwpqOKzpCv a7qWe11T9gK1pjXlj8RdzNWazp67+JVhwVFF+YyjivqA9zAT59BOm9GPIK8d5gjaNSKvdbiL GdS19qhrRh+zQGNolufjgnuuDlEQs0KeT6aWmFnD0VCcuODAeNlKaeBDSwf5ZSwdIJ322WM0 K8Dlj47dtCHmDUR6PBSt6sEJfyqjLL68ezLRbOCZ1a515rlZdNe6yMp2zvQpBlJmeHM5MXmZ eWoQNfTLFCq6cvOV2wzuq+15Xp9bV3LqUL2GzjDyrLGkIH+SImyVIySTbD2jIwR7q1ugsCc5 QpBKAzZR6c0OGjqRkAhsIXg4CNVdPdOP5oLl0yYZKhdVwTqF11i9fMZzDbKol8/YoCpqPHXd J5wSg7qIA+bZgpyNWpMkJ1Zdpn6GtEOjZ6Y0hP0WTtkdmJpdizFsbqM/60yVvFCE04yobIND 2wBODwmqUaAVZhQBOIWYKQIr2LrtkapHzg56q6Bko+TkfMFTPT5Ct6lIlwTjF2MAOsbqUzZJ y06tKFtqdTvb4RVXi9srH9zPZL2ZPpm/ObXZyCZhUSzQwsnj9q5HiGplustNa/LzOcznzu6x 8gGVdGc2sXvTG68KEYyEn0uebdsihpi1FgY2KdrdbFgi9WjBccikgVnWtWsxG+IJI/p90XK4 YI4vKECxsgTw7tKlcqn3Wrk08Hbnlfklq7UXhWZIzgRfu1G8k8ro/vgaC8edH7bChl65uPpO 9YsG+1K3uIoekVWhAUXF84WHlmq9LHit9+dmoMlLzBZp5MrFQz03EpWPoOjhgLFjuJyxw3nB XPrmc1P0DOYJFD0OYKijA69M825naOigc66LOhL2+ZZVvXj6C22Gi9Rxc0/Lhj6C6IWBZSMu XzbWwWoYfwGiF8aeQPTiPH0mZmMVHE3tVWOYvCBOyX62seoggZnnZRT6cXqxZ22wiV2XnnNB o6bkSw+xUc/zpJIHS0nWjE553VioZGIoBdY4vNGHIzJ7YeeNxse7RJ6czhuNr4HKTVdnkIGF uNAIxkUFbLvOI1As5y6B+ZzjCGanTVKMfeHJJLMMuYYHWfwJU2JkP7Ywu2/menchCS7xtCd9 w0jxlT5LFPef8coUAAXsliH0xwK00HPMwK9d4Jm5GJxgdDN9oz3R8+CtJdDW4xVy7bz1HcuW iE9t2T7G0mt7L3zxEm42jVNpPeU3DOeVVUJC9G9YmjAcrQNBvAY0/gnLbTqNaD5kipB2cWzl 08hpD6Z9ag3iiaP3fMu6Lkshck5zuxOahwqRcmFUdEixkGLh6PVvBMP8uUelKl1CclrWamcd C5EO9shIR3g+cwWu9n6QQMbEHwnx8YaiJl/IdDScp4PLnpj76lxrP9PBkEqbZNCE3xC6wmh5 9Y2TTSslprxRmS9q41zi3FO0j6tRVP8cTsklCsfmKeq9U9JF3iq95dmnCBoFQrAvZVuXITkb uW217eUHaD4cS3L1jZq/H6UHVyiMHO+QQ6AV50sGqycDIVpfKve9H8GwmfAQMz+/kApysogM 7e6MHxl8mQyw0Dv6SRhpIeiSa0B6RUaQec3I36edT+IzLNqLMidEplfq9HoaSN9tRue7nW/k CyOe5iajjzuzGHRHyZe2iyKehIovzXa4UWTdu7csosdILcy2cxgZB7tb1kRe3jqFcVVbo2PT r+FgQU/zuWMu6e6yNdxBsC8h16+fEt2pieOBc5R6x7XZfM4jJPiGaUlXB7UB4WsZTwf0zJwp n/DEQfaLh3yXJW40EZ+8x40QCokCBudTVMWGcKEgDuDlY7P0CBG8gx3LxYRQiCUDYOE5Crag Jz8isgBNSd14dSBTSt9NMK0W2je8unBw4IASeLO7uSTH5cSz4RFRro0RUIf4tUHYzG6wMaC3 +/fHd4eb8e7+dj/9dTrsbYHbV28fDueHtx9vro9/P1z/FG6btt/9Q7jx4ae7w6v7w7vvtw/7 797Rd8ebh8P9zfb67f72enzz1e/ef7xxb/pN757N1L5//svvmT29pz45Yhv3lfHw/t3+/fYr aWH/4drt+/enw8NX1rcpimvS+WjxNavJXFmyJnTRPm3LV6OLFh3noFDworCzz8PC3+5u7x+K gZqa/kfXcj9QduCO/9Ecjzdfvb1qXJ4b6t6rwtA23+d+m5r1hz//6b/8kaR2vf3Tv/z5r/7v 9Ln723H7sH077Wfylrz5evvf//L1m99NvfqwOz6c3lhx8QfqHnAb/tXX2+ubj99/bS8zfPnu u627zOHl0912f3CXBbw8Hj8cH9xlCS/vrrc3f3eXFbz88e7ucO8ua3j5+vbHcNnAy3d2qbnL LsCeW3jaH4/+OoHXP9xv777z11FH76b/hfegnu5vHu6v/XXU1XPuFEGd/XhztEla/hfU3+8/ Xj+E37oLwE/i7x2kC8xiuJCO6OnfFjx9bVfKj3u7Hd/dbe9PB7A34eViS8Kf3E78PfOdLva5 jym4yMghF6NjyZBxFeCISilnVfB59+obMz3tg+0JkKtIoqsQetrnrZ/vPp6+c3bUHRYMaZd2 BEHK9Qrl0O3z3palsRJWoIWCXE53hVoqxSI+Ujpzoq5J72tbWZSIJwknmZhaOsMidxxXvLJv TIPG/LBUP5epbCknDXbCowV4YR3aNvoJihMpUqO3vtHBNfCf3NfEt65m/Bv9upYf0xU/FDr9 y3uyHH3D2x8+bkf3RovYy385LTP/pdFfCv0l0V88S9rZOfH111vLJZ4G94fTw+394avp/feH xfdJ52u9ZPkVO8a13r7j7vYOreb7w/eH73eHe6/Udtts2+jHY4M7EJ9LSYJKGDF1X0zWPueD 1FxSVI/uG8cFGaoQJ7gKjVvvke1LJP4ZEXFA4efUAdXpQMA2S0EGJRUVoE1+KynqV5YGSmyK orvfxTOMr55vnmLcyIFaMgFaSCupfR2EH199Q40eppnnuMQBSeIzyAZba6XsSBQ8ymdVSmeU ho8bNRA1GKUaY+N1QUeMGJsqKDGactK421sVkuW7pVSMDcQ6caq7vc/ZBWviu6VmmmupG3d7 jVOqfLcWRCvNTeNu5qvYStDLqZNaTjZ9o5fMW/QK9nKYVHpJKG/c7UECCvVSE8340GqJ3+gK 95JQQXVjBIO/XsFeasEZ56p1t59LlUyYbwSKpn7jlJDC/PJiPKEkpmU8fajhKAUvjFAqlzQx JhMwr7bq1d3WJNA2+vgjd1cYoeRM3+3wmveuPgNlxeKhy5cEoWaGaq6EFpNpbDQbtGjg9Hq7 2KYg2D1clCkh/BF7GLr9tpDTxi1JLSgllJmnC+Hpf4G812HVYir39J/M/xAEnaK8L+i8BCMK SLDO6MhidNTlo6McDje+09RSMz0WmiDJU6W8ojOHkFW6VNUKWrWCPb0VerYVpHWEsKod4unt MPPtsLGCsh1D1Q715HawYWE86mkh9byYp7eDLIwHr9qhymaopy9S51y/rBmyasbTVyljF68O XTXj6YvUe1lmFkc9GrxqxjOsDb7QDFGv0XpWGnul/ckn++Wggd/yyVW/R3+cdQN4U/BCw6cn 7t1ZUHvPvLuh8J5hj4XzdBW+jUWvWaPj1Xuwt0yV7jK1WfbO6NI7o7vemePJfxvMTrxUTEq8 HD0yvOGRiW4RwtZNj3N72ovpQdp+0Do8KyeqvbjkiCndpzK4VNNz5/ZzpS82+me988JRIp06 n+RZt8y0nFuvciscDImatSfB9mSatifRzaGY+da5hC5ycygXQ0oOism0AH85alLwF/6Nob8o +ougv6DrxCF8wV8a/aXQXxL9hdrCUVs4agtHbeGoLRy1hem17hgxLPGj7DCt7q4g0PXEzoFW q6Y6v0vzLinkOr+LIalKKlUUUnqZQoqsYA2HHLYRa80Wx2euFPb0K2sUr99iEqrgA8nIPlY4 BzML1Yg4brPXsqLuHI+9En8KF/ceK3J0UGDO21om+YrdC2ztdveeUKwoqtj5kwwzYRFXauO0 vY/lFl2E8OR3HQ3rIaX33KXvLOe3a5jvjxxKrjKod95iMbRGabBbJR7y577EXNADnOC9vZsT 2E6oh1vYgjaxsEvFvPMLbLYPXjRlIeu2GvAhEGzbX7GU3+JnW0IvpJ399HdIlPN0jFaMpRUS KDzv4jMm/jn1cRcs32hc2jyzhe7y7LxhBLzq+hGv4pv+KFnfd/gMBZ/JdXaKrsyW11nVHFdZ Lo6reOIo0c67tpe/irRGaXrVh8tfNXRe9ZjJE60e+vPEnegBefLdwYf6UojeTcvN7YMXHNPn v7vfeVl5YQvE3PKxwRK0iVxPwSbKG4I+ca5jJKtbBDoI1XQsp1vcaYPpv1C6n3uKpZ3MGqyH +2whxVG3Ja6KEy8fAJkXmoYRz5vqkj7T/uxbKvJwcE7zguc97OjkkMk7orHXP/gt7Xr7yD0t yEw7NVtqJ+22kzxvO3P+z+UVFICqB2gsO6peLOICVT2zhix0jaZH1tWHAeWfzaKeMcwQjRKd KjMslm3WuRw2pBrdIyVvj6hGce53BSRrco8SjQss7yti0SJ/HTLtp1dw/Io3VhPUsb3+I2BU 9kkRjaMi1rQ/LE/3taXlqWdEra0/64eQsbyLAEau9N6bpNVEs1M2NKKnqEArVJ9HHMTr5LzN xLhcznvymlVy3pYOWiXnS8r2R0l6CZCWfnJSfKtMbveLgALK3jO2S+BZxarmRruEJbtkm+2S fMT5e1aKS9zqOflpaCE/uzz00dYMW1GQFsp0YVRVYcGdsAUHjEZ3qhcWXGW2gQqUDaHgOCT8 ZMc9z/iy4B3WTrwbhQoruTwKeuCPHYVtxc95bqyaxrCAE+RRwzJJuwUp0N/64NzyuaFKBwrJ a7+VxzOuBlLag5UkYBJKgnG9xnfzCEEwPNGuxxL++EUZ+nYcHJ7ybnHREtqPoa+uMpj1McJr 19vQUMigQnNc1sXMsiqmkSZGFqtGajrMqWJErFbFyEvUlJpeq+ZrD5rCu6ZxbSiiSV0calLO AKW7/caMz9FzTZBUW6ZZgE8vezY1ubh6lLaO8i7lO3Fk9RdIOQeg+iVvdofA3h0ejvu7ZZHf C+b+kgfIAbrtEb88PpL8A46PA8KvWj3mOc8LZcjP5bzwdZ9650Vk5FxxXijDXuK8UIY/7bxQ Zlg6L6ZvzMWofHkbLejMeeG+sjTS4vLzgs6dF6768dJHMzCTPMY1p/4Rjpibj98f7leICT2I OTGxflrZrBowqItswFxOMkQs7QpnYYWHzSnF3C6Xak28NC4bucIMUXCpgyoZLcM3jIkqxwQm hihPSaN5erH3BYSwudfoKGuBUYGker5AOJSxZNmRMBsDV+tj4Gp9DHxcjIH33aOWsqmOgY9l DHwsYuDoDbJekwSvSTW7JpVa0/64JtWKNQk4QHSRC6XkClcLKZ4fgbmwWJjUdujyPUFm94Qy F5kLkDHHo4RGeICtMHjEzAs0WZ4CNTcFysOODFntypw7jL3V/uRXaRJkrFysrLX6Q9gfFtus lXeapklCaKG2C1TndtLQTtXPmA6S+4mwy4jga0Eu0W8Jbsk3PnKvNn2oWwsl10LcNeF7TTDg fGazBx4W2MyMWXR4SoBqXMRkFqOCnsdYTF1iMXuwyrvrd1a/ODxM//twPD0c7k9pGhq/oalo /B4Qlzk/AExu110kcmUFIVvMOFcKMth8A/l1QlAjPlfmaJ7AJbtSdXFNB4nnrq2A+GgRSGx3 vlXFd60ERV9IIhVf0viT1cLx4+envTkL09S3Z25mirf3NtW9ml1/uTmx/qc4p2YORStWomhF Tu/MAt4+nd7EV8JqediX6PgmfBnZW+1wVgBte/p+RXpAgwxZQvaWskcGWoUlZK/o8DYEEnOv J/awvSQpR4xiEiJAiuHXZopVhJLCdynhGxwk7i35Vl8I7wjNb5+27opftirhubiIe0G817xp kYbYj0kOPpYEAxGQ/CrsX9eQU6bfxuSBcZHpeJPHGNmUgtPxOrF5gSd2tnCLFSmpCVFwmaCW h+ikpLhQ5u7cUFSv8a0kdwNpZUAm2pdTIiRQ40535Xj6feOKyPic9dJBMZ6z7uw5YU8Jst1Q BT3/gJY88w+EVo6gld7HlKEu+2vEoJ8jvTG1BbHRT6+XKRK9v4ZM+PknNM7xMZoMLq/37JZt aMk3QKvNazd+TiXOfB3hZgc/8F5DyrZlHoq07hJxyO3ub9OZXWlonmaprMiHB8dk1gIwp5ho O8TphShX4pgq0sb+aGSc1SRxRxBNzKx6hXGWzMVpGHSrAkH4zVrJdKCtMl+2MWrA3iDXaaso /eWPf/1f//PdX/6v//HXf/o/3/31n37/pz++++c//+u7P//+//jjH/66OKVKA0vOt38H1q4y IBibh+xv6NdYyS086lArWg9wd55QOYqdz9ULFZ/fOFUZhk3d87nKW0ZYxMXrS6v70lyN9QgC sO5XsN19C8NbWOML5U92tKOczA0wpNVzL5e0AEqJwGdBHGN7GgYhQ3i84DwTUaDHi7WYiHOj odsly/bYA+tYoUShcLrgZWvuojESRzZOqSgOrfhVQ1BXtEZvjHMQMwwiadekoSh81EmOJwVU BNRDo5XpFM2G06LjlhIJDOcZqFZk+Baj13eszj+Za2QtfMJQUYNXGqgSq2BIpRQlBbmJe4HH V9jPJ1P2AH/8IVV/zscLHRiNUsqWARlcwV5UO6YouLcPTBgfMhmaCP0NToJQ6jwMhgDrx07M pNmhzTAN8uAfz4kJBK1x/2eAicX5zBsjCEdX3NFO6gZVBvBeQttEuJgSC6wvfuJ7HU4UO31x X0/Xdv75XVQxDFFlLW37cie2ptEcZsGaMQOIID+ibUvPEDNEL6/S5BtcjNWYXMl+CWYZeRhW wyw9L0Nc0cOyx1UHryL66DqMKsJmJvkzjT+poJnjEWEzDYJJlJ43u+Uv8+lPT3R8+nnztdBN 4VnuZ0VXTMDZQeSqHC4sAehfM9i/RodBLi8hsen6iEPNpKDI5ppJTlePA+9YRO2ncD0nUOsF 4w5RVSmnNO3CiIQXCayvnI4N3cer5Y7XdnpCFUMAzJd90kzCqYlQaT8kTRxCIJVGPTHFsybV TDGlDl+etZNatozeyUdNKNYSEC0ueh/EYmFcronECbkYeHNW73zgDeR99QxxEL7rGfkwfMeX w3fiCXlfViHuBOwC9rgH4g2rUCXSGZj1HZfGCuEWPGUYpR+2QyneJNWKcG5ksSjHKn6ohhXA 2lZygHsjwtbq3FkdjwRl8kOmYfyF+02x0TCpZz6aPc3O9v7v0xq1zIDv7m5PR+fO6pUwykWJ xbeJyy42D+qU0axhqch3sgbCU8DZoBFqePfxvWvN1Jh3D7eO9XX658K4jiWitUoX6uaCjChW h+EMVRm7Ma/BNNd+WgD4uWNyTo8QPOhpvN1YJdlc9WHWeE6l94IyBZMT1LIOHUuRze6WBOuA y/Z0XN4tuoZ/eBy9O51iUT7nPApnmhfa2dauTpUgslPhcGdcL/ZSbRo2TDPLwo2nxtHVVrwz ua7HM/RTU67jNTdi31yl5R0m1y8LJ9zG0eVgyCjeTt/dwwyG+8PdV5NwPP3Q9OmldgDP07Hh NItlkD1Hyj4FAfbX0Pb1Tj4RXExhGrLPDDj99tE3sb3ZXv/0H4d374/3p4eWQO44IoMBn7K+ vrmaK2gPwxXeMAmLW6rlUzvzPLGh9KzxvmeNrxU3lQgJXO5DvhpSJ1PZlOJq8svcJVC9+37q 5XIyuQbaZaBZ80mifs26uf0hFEvI51fhNvHbcn+NdxwYFOsa6PhTjDPuDFebjl8lOSX93Zvo x/dBU3cYNdUNzZHrAPOmnjPyDhuO696dEHTw3NLQVX8qGLSh6Ehx5CbDctCRxvNMv8I9+/NM LKJl1TiteuDRyvKbB8Kog6mt6aap82YHcXD62MIiLSdSsJBMHBPou9qeCw8XoLjLLjPvRy9d hNDgeJOKmo7nrgWhalcDBs7ZAXGJBUFsbbOnMx6Ei2b6wGDd0uwqSmYeXYQTGaOwjyQ4RcqB zQrRLqsZ4Vzj3r4ifFNoHlYlD16MlCMJZwQcMHkCUoTpmAb63nuiB7NphF52frxZa7yT5RNc 2cOmb7+Zi8ffrrNN9Vk4lhe9TevUvHKQkPjorWPow3aDt8U+7NQUTZYX1tBeWAvjQRR4jJd1 dHfnpVS7Vj2OFavYLsHWzF6yk+imrIAdHHyrfY/BOSO992PY1C5t7wTSDTezgl5qMRum1UDM 2w0WloJG6y9JzzO2WCKVk5sssewDSqOS0RhVDergrSGgpCq60xG7FXdWGqxXqnTCsudV6/cT T/4L+4LS6siKiBWqlykiYtMJC0VBBCT+ivhHdfTH1+zOb5p1r+6KEO/uXPCUj+ci6Es4ZqpG dNIfDsn1lBnohyLUHkcOuLyD99AD57TW7SBN8sWqBhf8uihNYXLXagpAzBm6LIN5wz9Y+PyR Z/CUbVvhdUCqGw5+EMMdAiH/G+yG5X6ni+ZqrHZhDDScAUghejoF6atNQQW1N20KfwHYzG54 F0TcwForPZnj1ZGbnb3LnA2x8noRI2HjXKiPsCIwwQ0IkzAfJmE5TCKGfniREu5A3SYPk+SV DhdkORsLSzoX00mkZMHmsX2tXCymz8RgVhj2uTCdm4h9VqhAcCWEFvI5wkCRhtMRBldOxxKk nfd/VeioDdI2kix7VEbkUYlVIY4rwisgNk1K/5Lw/aQosgmayso4kFRe3ZSbBgIWRDjHboTT ysndIZeVZD7aKNSmjMPZBRw87naBRQaKgYOfP/hW6az5uPUVys/fw/Lzt9Zf4YMf4zXkWTyD eJps+n22hTjaZnF0g43dru1UaPltlT7sebKMYddJHV8RmW9E0eH+BJH5IrRenRmE1yoNUDAL eAMcQhjUR+H/pBHxZY1ojevxkVFIg62b7E1XjjvADGx19H/wGS7m+fZIiMgPetOMVYc9olS1 R0TeI64s8iT/KqvViSK4V454rxyvK1LS8ejbYzZ4X+x8gBboKiRIXZqxBGTQTb9AdX5npzYA CkTDFrzerp05lADs6nkOC6CDi8d7ClI7/WyyBhqiWRoxn1iE4WMMYEQJmcEIDMte+GyuLmME cr7LC2EEwvLT/mt0hivJDPwCriQzLKaymIFvLg3wJ5xaM8A/mLkAv/bgFlTqdygD/ANZFmVy UyEbUloVVMKX85G0oRtsGYY1HY8mjqrbBg17j4rZgr1iZVNe+tGPbzRPt8FSuvvkgweGe4AV uDuc7em5N4yIEQyPP5IVlIfhFJy4a59GgRRGQbaFY5CdetlZRzKdoxSCiUrAkr5gJRRLVm/A tyVrT6KGhtLlhrKe+wPpCp/B/eE9H20386lEUmJrLRgp6gKryy79bjHp6Ufd2hfjGdWYhhuD oY0RC09Pd/yYbgTloceqPPQY9wo8jUC1anhsgT3mL4BTJuoD2oi2PrALHWStjVTttefYWUla LbsMCOCIHIyaTPhqI9GZjaTxRvL+rc5GSq0yy44Ms5kxf6dtxzqGbScZeFLiVdOeCbhClYPZ 4XOwvmxLmcjmL4AaLrN+GRTWqVSNlMCyrEYo9YxqxNiHGir9clDD0haGUENdHcinAmqI0PGV aqOHNZ1GZuq05b1m76DrqyjGjRaPtSoCtlgDbDEd8WaOP2Zs8QixxaYBIM43+KdL8HH05QQ7 X8uWi6gamRn2u6lHQ6tS8FK4aKiHuOWVag673841I56XOBnj7YfOdp4NrLTmMiTIv/DTeBpg hOyisAwRskBg2tfdHD5EZGFy9C+7K1yszgOPoPU3W9mbogOqrOl9jfDqWSkQywcQiKvwdJyU 6xqqh/4EWTSaAeRlnQ29/oCyqFgcDcpQpzoapFA0CNxZRYNUY/zb0SCfyZfDQdlM869ZAtbo zSw06xFkzMnlGnAyGWRWYcKeASe4lI/WgPZ4EI/UFYeSh98BBqQL4HcyGfOihkl09fY1Yc/K DdNU+XsqfhUVWQ5x2khWaakQdoFbk5Yh+rsu/IbQIhKeOljaREuKInY11WmA23PhaMrgJx9J oabjZKLEEz9fP/zgPsVK99rUYUwcYjhb6Vaz44rcapARm+GUtamPvquVHbmrIPgZlRbeMmMF 5jsuWSKmcG6AxD8T0kOiCRcmw8VzsyGWY7Uzng0QB5dJakLJmA/m0q9hGK39GqE8i3HUyeCc yJ8hGcKYzgmXominP40QWzZdHA6pY+SaQFlbjFBh5IIhatu4gINplYELNgGwbyvOCck6ME7X 8jIg5CH7MR6kC3cO+HV6VpSeGv+zty9tuSjolsmTkBbY5ZNAF1rrm1UvhqfNvjVMN83AbJkM F1zRdIQGqjM9xJJCTsf1jDtQq1HLwyaGynXpjO7g6+L9hS1ky3uzLb03bISeGvZjulgICLyQ t9lT462RbdtTw0pPDRvRDsjRTbGZyc41ou0r2IVfyZMspvW+HBvXzdMn1DLya3hyMlOFrvsH zG6yImm2qlV2lCE5RrFXLIsTt10y6tCLywVBEmuiVAZxXA+L8HmbZrXB5prLEgrK9mpFGoGF smbsJcJmftvLYl+mwEWxVcGpk3dqdcAnIerVai9EDyhCC55OG8ejKkBRKuAuAfPHWGGHAhK1 NWdOjgGuDn1l906Lr9J4IgWT8wM+D4xHL6+07EZahvFkyM8SjAc6LtswnjnHpTYXOi5Px6c7 Lq1jCzouT0dIi+vT6oyGtJWnIy5zaIBJNdPpuDCX+XGNIXBh7tcsTAQvi1OKfOn9FG/tERq6 TBiGYVS9LAAVZl9tDqQkcwMp2RoQWJKny5G8zHS5eiC16g+kl+EzA+nVVGFmBlIuT7+Sjczt pBQuaxVMb1p+8vV6pfVUF/nv2f8sZnBmVvSBNSOX1X55sV9zPDZoYOxcANxV0+NZOHeSm0MU gNJ0gqjl9aUbIW2IqzN9XB2hGFiXvJA1sA6qEP61zRAgxPtpU/pozy0fLZw6qVaAAKGPdg0m EDfdtmszMyQavze5W5ffK9OeU4rgBPOkAgWTSW4accKne9ErDcZGKRc2ovCCM4l7JYsSWant Hq6thnxnobMUd0q9Qd5d3R4OC3rr4LKAb93LxSJmVMpirx61AkvzosgjijYzKTRDUI6bNZuW Eshq3kpT81ZGfklAWZmYKBfYKptclV2myshTqRs8lSHQJOcIE2GN9nGOOD7cY2b56PMpZoqD d9/aEvGlum9Zorxt3dhnPoWzHOQQF5nlitR9JlLdntFqPudmM+SUFtMZrjbmM/wSJtSVl342 4tGn8ozun84zihlL2ROIR9G6IvTxTKSIVtI+/DRq0vnVZuSz8Ci6V5gWaowMvAEbazMsdvkt DLuQUtHMMirSwXQZFanHP9NBNhkVp7aImlExf5WUGpsG4LQ1xIsA+56GrkhY258b2TnAP2YK IlkwLaY48E9lUCw5VzTKXW8Krn9YHiJ78DbT8+etDeqQoY/lJqIRCt7iJrLL8vNwE6UvX8hN lNjcUKzeXo3dpS12IoiH9x4OeyU+wko2tSPcm5TXe7Par6djuWFniIxgCrhpbDfd5QpKe1jj RMs8Tvs0Im6Q9RrCo1yl4xKJNAt40HVvWgJlNX9Sau1L8SfRlHu0mj+JgnPpyevkkUtEFxxX 0wlU5aymsZs9rAGuC4BvyCLiyR6LL0nZVPE3riZtMvOcTXRI0Sh3fC858AzbzL5qHcYINGtm mRiwStrQJNfHCpp00cacW1dfAmBp1eIjZHOZ2OqHjlbKrMdEmNZ1hS04aaw8X36LWHCXWBGx /BaKHSRkeFRb+IJDJrSlslm9wQht1mRqJqM1m6Sp6sr97bh92L6dppi8tfn/fyDem+Gm/NXX /+vGPXMYv/q/v7q9/+r//n++tvc45ph0z78ePny83t5/dTjfTdrWaXrtVw+3t1/tjh/8zaT9 wm/tC//t3771N1F403+7+fdpTMavdtv937+6P7w/TBtrf/A3staN91UTvu51Ur/5evvf//L1 m99NQ/dhd3w4vbHD6adAuy9w+IX/Oene24eP94evptH+6vb9JZ9y4+lIm6sG728nVfbmwb7w 3/7t//23f/v/fOckvPev99vj9fQvNwyn6+3pO3+Tao/n9B7/u27//tqP92t/k2m2atrZ2/2k Y3+1nz53+upm+70fdYYm/L8fvr+9/2kage+2H08Ph/HrfhkfX5rn9w4RBUrzhAtd38n+9vu7 4/WkBW4frMZf+FCKXxu+lOKO6FNRz+lTqQj2Hu1keapPRT/ZpfJ5arkoOe+fIxITEOqyEIqr cTJg+GAumwRuUqRRxwXVa4EchRqRKW6vK4Ag/LxGhVi+IQPl2E3tfJVkGFoBpqJZhbILmiXQ gXz+fvqvXbyhJhMVkauPvQbBRh2vgCNWUdwQB/JSFKtO9mHFZHWNSPRGe4mnj0QNP3LhDBnk tj23i+q4+3Ur6yKYFtf5G2CMh8rzkuYXIYtdN2jTs0NgDQg+VD0tLJNc0Sq2GpCv2V2E0yIZ p6Rfl4NSyhoMO9seQHm6n//GPwYdYgqjQtG7ducGwR51R1GVyu/dfW7wd+dyh9m+gc0TIpMJ kufwtlO7QhLof3J/DN86UPQbu43KgxEctfFfvm/+hPnh43b0b5ToL7X6L/HI5+b+YjN/zT3H X6AtX+5f7B+qt1/uXxT9Rfp32rSHWKdx3iihvAv5n36UAM0/J5QA+LxACqK6CDsMat81wOk4 UWBXgNx3vcQAqpn18THm/BKwznArX2DXlYILo8VUj1ms5xZTIayFU1iARy/7gpPt79jJgKsA eY3t8RbmRwWeWTcccep24ZRyQXbFEwgAnNkoPhGu7c8lV2/JULo/V+SyApPvJVY6jxKZGsF8 IxLRPMFmL/hgUUwPIhop0jCQT6Monvmjz54ISEv3adrof9IQiv7H7k7taXaX4u4mckKfZ654 SgVMubpVxYyQ+EGV1KjSNkxjxuU90vtpgqYjqqe7BilyNUew5pUoS26U2fSK6+4UD9VMgTE8 YZdP1r2i5sQbfNBZl4mAUDhAaVmi2lw8Kst3QVnGDJZNB9QQlVk8MLyhNgEboFUk8lS4iWGW F3g0dd9KJ2fZo1YS3qqBmAbXzkNm+EPSppzc8Zwt1nNDJ4fareJq01RfYx3mc6xHGNaCoI20 xlmBJ1iRnLNL2qQSHOCzdgXwo2D5LwNdSz51TNaw6I5TCF5a7QEhVpaXn26Vq8vLnxbLy2PI M6A6m76j1mGXqxL0p1yCviyrSQiC1U57VPg+6ZUcCdM40gJLsoojYZ8XhceD6UFtGuoCvnDn G8fK/C+3YHcH8DoVC2aCrDV3V/imLJZ8mSi3O6MDJmbbxfpNQZW5L/IeJwNvNxl4QQeKj0he V0yId+BDzDVNAFHhslDjQSiSo1jJpfVt7dQ4nhBTYsYUAJ/+Ha/4uZyekQ1BB2OjSWh2cNlU qZL0P/X7G+vcioWigwTL0G2/2Fh9mpPwiH85TO0CfozUAciWX3pmChUornhXrVFpUK4w8w6j qiAtuZpdJoquI6tRNalIjFWd398fDr41OW5BizMH3FlJTue/yLUASy/cr0WvZs4DQWfTwsrD bFo4kNpO63IpOoNkWrJBAw+iIe77sjBQ0EmxW0dJ3bM3pgnOkmR024MxnSNMpdcshXbNsuBg m0r2fUZFFoseWuzJ6sK8ZsvLSlS8rcbibwB5F5ohkvhgZI0OO6OuhgUwni9TY4PGhyjSO1or NB3b+nk4VThbXhx6M2889WxFPiMXg7nI/MkdM+J8oZpvnaqMmc55R6CHbizS9lmX1qZp0gQv LlNtZBHYoRn1HApAeDx5Vdc7bjy5mEhDZU6X4UkJAQUCkCfkLrlsF24NNXWn10vs2A7Htleb qFQdx3XgmKJVDUo/P94H419iaKpZ7VoFfUk+98JTTBSs9W1XTGjMFUG+bz+Um7rz6Tsi+dp3 d9bZPv03/aoZB8xz3DPP8ZQET30BTc1AJfCcaplmUi4vLzEXQ5gkYFJTDM1nQuyCXX3l+VDI 0/zCHVqxDQ+c/w4nqCw8aAGhvJiqxWQm+/gFfqXVbqQZ0RA+a7JoCDQtopAN4sknoA1RQOkA QnlYPGDNWgPNWo84X7UtUWBZJlwnarpfN5jnYhf4sCin3RJuV4cgtAD7MacBU94q/wyWUHYP hznhs2vc9uAC2eFGqJQd5S+mbILw85XVJNKmQd+dGxWGYPQrgKGuDzf1PI04xavkbIeF5REb 1haG6kz5kD2oQRm0igCqOPh163HNGy3R5bm+ZsnTlBOnh0Z1GDIDG3Wby88UzxxBVxSHB7xP h1YSzYbiNcYPcoplE/yJJYE2FDkHTPlVzFod2Z8b2wnK0zxmO/8hlYdvhTzkBtdmqdz2GYOu gywDnji7rK8I4sa2r/S36U1RIAdWHKo2ip+FTyycpRfOydL5xrygbCbz4XlCZ8LzXJi14Xlf ZMk90AmPcUl/DuExHxBihkGjDiY/Th1ZhEByYR4HUIjaJ8+1uOMJFGwvi1AwbYQCbyAUtJhB KHApH4FQ4E4zTtFTrjn6i6G/6CeN+XJNPuNf8y0b4F+OJyD/pR/XW4X/kr/oeD5X4pHP8U/c TrQDFJ25E60lNfyy50+aRz73yN0h8V9iLcYj8uX1jsxUsvQ51QVvPjFWKQuqHfefGspI23+J tNCymHbQhDPMMahUPFA6v475MaHEYswRrMMx4nXv4/UrYRggwy6DYsAoA3oPKWCZhLYdnFtk kfjXXAreSMOAUuH605XDLw3t7oPvC68ydV/GGcyHRumrsqoV8stmj9wCXkA0nOjA8XQ61pWL ITtVJxy0a8WHkp+YJ6TC9JbDKyJod9bTb43IWf8DIpdpdR+Q/WWVfisyl+c/QBvomxg89l/U zSChHc70W9u9jt3hfm7gAFXYil1zaFv+8sLSS/5ydG+AFeRK8XLo1iFmQAG13YYlT+vJgBBw qhtu+Ox177UofQajO9BwtycqPUnLoMC5kZFZYkMYTeIXyRFHFHm+vX/12/P331ur2/6v9guE 3gdDCQjKj3en+ChB8rMF7YY3pxL1y2fXdV361V8ifGgU4/TZeMDvonGFvvkDlTHEuVaKW9Qt WPmblrXpf9zb3Jd3d9v706Ggq8n+/SuC09SnI1S3BlCncdKVM05LOWMVM8DvinIx2ph1Jpyb gQm5aBLqFmTdFbSbHtfZINSNI72y/Ezp62dyQGujOomnoXJOFCaHrAGNRR5GxICAEsG78Hqe nE0ixVnjwuODfzPftCLEQdnhpMFKuYuH3/S7i3h50Gpveqa74hoHDJEHwBDJNd5GzqgGUCQN 63t717TjEt9eR4xOWG15lSaozPR1byPnKmyqPsmuITEaoFpyA3ulgYhGHH1XvPwFIsPSFogY HReuunbeDC2xS7Zg+VC0WUbTM32Akkd+MCJxcfwSAbiS4CGhatHjztWlBTPHp9XSCYtD+OnR zZKZOw+pcbnhYU+w5QrKOhf6iyqc53m/h7WQZkBd7iP2RSTTCwJud8x3eW6RefstqL2o4YRv ZqvhTHcINwkOxNGuihOihzyXJKmxX6ohrk6p+Agr2r9LoUHPJO58d7/dX2dK+13IxI+g4q2H JXMiY3/SWssdcpFUD2fnGeomyvs+5PumF6pNVYwm7p07JNuu/apxLltOAebOc9eYEV847Jqa RjhWhGwB8ZxfjtvqkzPIzoh7gfU6dzW8tIRw8EEs7sQCNzsH3uTDavAmtAg64M1evU4rHPzX VL8+2PSrabyv+uJCXVw/MQP32RCkXOsgjOhc5UuuA/64/IECJP60+EIg9PKy7GXiChb6uGkx f+YY3tCI4WGbvYAWRcspBfkallnBa6F5/87HRPXITJj+OkQ0Mpf9+f4ALTL3cyvRlLU6nAyt 1LxlRgQ35rBcEko+0qBOxoqAw3x1gjK4EosM2FoFuzMOt1SVCUB4pSpMMFNiY4tRzPn8iENE l2WZi8sW9SVCpCSbCFC5vEv5KGpo4xMP8Nc2htqoDuofHQ39snGT5OF9ls7p48sdz3yo3zD+ CWGI5/l8moAIFA1fUO/IYkQ0KjdVDql0PMISIvwCdCMjsg1YXpNfE70ap2NDjDXcNY2kl767 JfhsC4nWOSN259nE8uLmpqzEqTfDGsQiACU0k81mjzGKxbb7qtn0naqay0/kVIUtayJsCV29 RJrbhMIvVEyIYOV3PI7NnbTCJ+ldXbTcQHWxRnvjTXanFeubNjnJaOErg18pHJ0LTtTTscyg 4NiJSllfOaAM45PwDqQlJLzZ1MqLirPdxIK/d537FC2CZfcpLd2nebYe5SgNrJuxc9WQ1pMR nzwdL3aUxjOMEb5oRrNhU6WpXnD2c735kmIvKDaRoyVIUFSHVW//vFCYheqek1w0EPDVcqca K+R0GMpIYJAmfs2VG7aigrlIRDQjJb5bZb1B9FHdlhL1GDUzSXAQ5Vwdj2WSQj0wu07IpY6X JEsqULvPxk/qIx82sRf/iRGxm/zlBMzsDSMWN3VmK2KTHs8NazR9EW3MKFazRFlltYJWVWJn jSnL6DPJDbRVkrfjG0cTB7DBBYOoly1WGe0kiC8oG1XuTVf9LJNhck5PSgVhy3lfBuqHAOTa q90yCWZT1n0BhUJtZrFP3qLNzC+c5VXOU0rwFMsNT76ZnpV2fnqputgl/qRC6P4FoW96WHam M7n5YmEHRMxQHzQV7gbu4KXOP95HAdAqFJoPse4HsCJtPzBzEnH9bDCDfdLvqJBNHLedYyoK NpCZpLswPcOMfozU4Q7K4Px6tdl7KtVk3gZM4JS9PsrgEjX5tKwmC/mCeIJ0XokVuSrs183+ qM0u++5iKvkzbHY1Y5zW9HvPsdk7SRtus+vhws0uW2Yp6tSFJjIvAsrrTeT1WKJn3uVlOs8L 7fIVARbaBHcWmTKlmxpkFOVIbuaL4BTnqImUo7H1CakMBtfFwIQxkhouJwWLxDW2e8BL8W/7 xK61oIK5TJsWs9VMqqZrE0r+HM+vG2nuieQLZEMxD6EaobbJKUjgHpZjLnrTKFjmgUuLZfU6 tfJaFkwVALHQDlUaYJdEQgAm4RL6qMczRb00MVSaNrFMQZ6JzHShwcxmsXGQNLrMuc4lzmKr zlQQYWbEPwKKBF8RYEukiq8egnEssj9Nkf3pAQlTIzfFJ73dtWukiF6RwvACv9vswGja4N99 92i5AFdQHzCyeZ71dloVM8kelx7Vw+nYicU+gtnBYjkKLAiCutz1oToe7kG4f0uTxWk94oAP l5vjdT3bbcqj9HCnXglXixXxXxWbogAMWBx8kMu+WlzQdvQ6QChoC0EXi8avRc5sGpHWSmaD OxQOFJSWvrsTqj0W5bPe/GdMmwYKfBEOBoFcRHuGGrPprqkS2eUhkoJ6gFPixgBkYBE4QwoY kue02h3SmisRYeY1SJfsBdBjKmkLpPUhrJ7FbWVcDCCPNShrnuCOWdAl2i/uooxvOMy4rvGf HivmWLsWlhRNBddSVaRD4LmBODc0wE7Y+5Gg8Uzn+fGkNuRrgYMPAH3xGx1JSxw6Dyt1WiGA NGWUlp7v+gc/u56vzqN3/KcphHSiAuoBApJAr/F0Q+X1AMGTCO8mWKQ5PKubod35dYW6gzdy dGMbjxf7obwYkZiFDBlZoDAqtCRDh/3+ykLcgVsLK7AHkGKCLx9/etOsnRamU87wW1QJVWXi 2UKhII+LjsWu/rOzSVyxw8i2c24lHtOx9bAb0WO7lNAW51Ftm0iE9CZ3yh5hSHCFr0OsKQ9l Gihh8wiUsMnT4yH7TlsDu22PRT6oTz6dm40yr0Dk75seXycztukFCL6dKRDibz8kgb3PcD8W qqpjsZxv8E8H889L9HCDfzhv1v0ZazF2SeCDLpUHLAC+EMk7Jnyvw/OONZyXsYLUaJfHxrFF eqESZkL77Iehc8YDqCbIFDmefK5IIycDTRcGNVc45Xocio4Xw1LjmmPB7WocsmOBxSwa0LQ5 IDCLKPiMA85O1oVMHK5nSFwZJ2txwCzbV4s4YFPigE/HQuXF9Se9NhJm3+ejcDaDA2ZcrPlA FDqcL48SKAumC+WWcbr8vGjo5KdjkwU06NVymAuRMa5XbJhw7xqpqnMWToFDZ4L0zJo//OV/ //UP//KWTI8H1gj+ukZw4gwyy0BBhxT93D3g9/7tZu9kWJrClGmGTpLqHHY17C0EVqShWpgT wXtJ3VGAk8VhG9jmQvJSBtK3e+SlLLPkz5KXpmAyMSU4hiwbXJmBbN7gYmtIDRvGm86v8uTL MztWCbOG1zm5e5bJe/mQyYGi0++Y0/nsmgblAl7PM+n1SboW8gKlRMhqUDO6kxnoSf6YXMgM JI0C1NlkAM5DAdNTJUgYzOSfzS670L/ZIAWk0rltfp/fq5tnUI8F37TspyANScsSCjRCKcPe /+jMU294pFf2rB+iQIqaXEYMzHk5lFix6UQysyypNYr3lpmI2xJaXNTNUu20icI5BjL76hwF 5NQ4jE25VdG9pmEPnp/s1XPV8C4WRTYftl9DhQmzRBKlWxxR+tNXUOFQBdPQld2tnlLk6cbt IpfDEDKJb1oY30Fa7c6IaNcDn4LYcaroPvOe2VyGGVZPRRo8gD6U8ffj3bvbmwMMZiDgO/RE g7ZYDpyKHzRcGM9FhZcKeFw0Ynuzvf7pPw7v3h/vTw8tE7sihUhspnJdchbAXfGKqfYMmFUV 2xRQ9xBh3Jch+Wz+5cxPH2xXqQyKLIL5+14wf18ykuxngGXNtI2Ks7kL5F9O7igQ3tnD3lOK qNKNtbxvBcJXl0xpeLvDt0zx2v25hzHYl/HbFTHzJqi8Uw2gwjr2o2cgJjaeG/AXMGGMNrHk JxQ5Q+8aO1Aa53emUWlAGPVOkNuv39YTuzh5rLaAmlTDVA8o7ysXo/QiKqr57qUShzp88QPH a/Rt8jJMfdkU22SHSiuwgpxof67KIeZtAMot7NIXrSzg8xQdF8BQZeE39W5ioLAsK1VUbS6u rkBWVFcglxkolDzCQOGp+zB1G+i7Oe2uiqlZSMb1oSYDQQV6nPOfKYHM25IJAdbsQCwIyVct EVPS2GJQYDU3w3lRKzLDZsElhTHgGfcSjRzaLSTE7CEz41OKWPDhUU4lzeecSkqvdiop88LJ 5UHH1MPnYJ7whXaYJijAdSqNxG8KJnimRSGittizvF0oGGRf4ES7KVNM56kklnl9tCqiSGKc M21CcEmM2T1+XbnHEY7Bx5Vk+Jruc1Vse1HRKg7F3gSxWgWe0i9WmnzI5QDo6D8vcjwneIT9 hnRNUi2eWug4dhkPp3xtm53JCcRZePhO39mfqQGU0NdFkaOWM77tk7bnF3SHlvjROZ81jz5r IFSB4Iz+ATMgmVkZrCHHMbLzwDDiIYcC/QKp4JipWLEX4jW/iYC5p94o3N29xgxDFND65sJU 7nr39KkiJ9AZbJZxWJLOO968QJrzb2vqU8SBN2JG5sWm6UWQ1CSaZ/wbTJllAUAbjm7oVwB9 iWw6YtbRrTnogVgG4dAWYUcHc2MjZV6yFZgbv4/Xf5YptWlkjaBlPh774BJsDFTAku5ZwCYZ 2CiEungWjBBYYnzcT88wnbiQ4tKyZutdWxCOwwoLZH+uo/ZuVuSsIwt6+JJ1ApWw/QrvFgPr TgPI0XIkgNNNh8irEheABcOTG3VOqwwfCWRQfsMnYQaAggXbElJ1E87FB1WWlE61WR8HBQRU ALWye9aoaPT6HkvuukSx8Xins63UulldmTVqbT/nIqwxg2yRjs36XfvcMkySJW6ZkrkQ2vC1 j/ZliWb0ap6ZtHRWlD+VuYiSEEyUBTJVbx9ldKDfJQR14ZsrRheqXc6V3CxKalYlN8sByOmV FNfcDM/gZhCcg1ny8SwnXVouxk3LbuZjjT1qx56ucXw4niCmFr+TwTW2vsVaNrpeFo1m069l KEVdAtj5aKpjFZ5DBoKMqK142GWDC2Xygg/hDlnnTo80ybKq/OiwnPuA5Iko2TsIYoFdAEUy PcfGxii080E5dmDne3U3JbAFO39ESfTBzt+j467Ks86hBGzno0gh48t2/niEhv4epSvOW/qA THUoaqRKTxfoypoV/HPV4igJ6W7y4nhKBnF8Abb6AKYyaHwhrk3r0sEYcQbJI8Grcz8utcyR le3haPbNADS5x+9WeVVUiwBa2ADHVhrYpUXt1Bg4Po83pQuU2BpdB6CcOVRk/abP+n1UFDQA 3dyncY0YV8CGaekqlzYzhwjnKgkFIA6qZZNjV5aPN+OctxkmnXDO23MRF62U1rus+4a946kf eQF0HjHQudP9EOcPJK+8RDnzNf4pX51yxP6psZkuGw4D7b9GMETR+Zv0m5yvln7g8IclJLrZ VOp27DgZK/eGgcC1wgPTI84wyC0TRiCfCheAOqR4BPteECqWvzDu/Kz4pZ2/q3b+rt75u9U7 P/rSdufn8qU9QgCkyM6K4FACujeTmMPhFWs5hePUn4GbfnSUM7nmeI3tZGJZR5DQIwQyPPsp RbJiB4H5mtxXW9SStjSr1LJhuWXJVwV1RphqxJaRb1JtWtLQdyRRRCKxFrrBOZIBqQq1/WUz J8vs4ogtXCHXGZlJhjKFjalbGROk5X41UHns+7Xg0JqWMk46yniP+nLFmlNuAFsmfLcItXrG ItQzsfwm6dVMsekL6kpzvt79lkS9oi3eG5f40oiD4vILhf8N5QDpccHXlhdZ3A7DcJG/LWIZ L/Q26qKnbm1XcQnTWO/juVrwBd1vKUUq4Ww6g4JTC/OOiLdpIDTIBaNkYa6bXomGiDRbJuED LHq0QOKyFUhcVoWxvWmsjGrRL6HEPr9fdBsatpgBlK1eDQ3lWG5lmMEjK7rYL8U2a+1bpT6N fasUXxeQhirCa2T0giMBRa2BLat8lXklNotc6jeZKvlJ5FfVQQqnaugbpoaqp9qhwCvoPrW0 KnBwbw+R8PuwGOYUMKUuUcCWeaDtCy9VwJjhbQUsD3g3nGdrHfoNVEYSITmbWk77pXN58Msz YTGtmxeryicxHTE1CaqmPh0dcTrFS/6lluZTcTKt4OimF3B0U8sS8HjubAwxXYBVno6XcYpV dEToQpdHrIWbdOx7rCzE2+XlnsFUG+pfRjad2NDj4dE5W2AdPDq2aGUVy7HcL+OjilIol79O DW8NQLNiJcxlBvUmU84aBAyfQYuA/e7Ai3pTxjScePOWvkZgOJZFZirP5qz4b7EXZwtN//Bi Gu/pQ1yN8rH3pB5gjOlTa33ziHi1h5wuqIQihjDJHQ7mOMs2lfzOislWJh4dGpDtTH8T6oAr BliWVmTWRe2iYtLx5dwgYNUT6SgGThyoZVwDXcwf+JTHkzkXNsrnl/BvGy4GzjK2DJxl7ELg LL08ncYDjDqR2xi+Xl0VJGye5Cr9kquErC/HbnJpWEQZFu3t5ZReOZezJOdzlggmdAKdLZP6 cCgiDet+MW1pXwzPHmuRwJJt5jIxq2BViUsZJkiLXMN9mWuoSCvXsFnK73R4sFBt+/EqutrO x5ye2Pp6xDCNcrzOGHYzgwYMmBoBWY5XcEILyFQHql00meoCXZaumOdc9DzRaWWMkaXW8kWp X05rpViyC1Qg6LPXh1mlta7WRwU17Zoxl3BnuxDFDETncWpn5QQcF2nI/Gxt5vR9iUt7J+0l XKvShXSfYn93hj4T9i1itc/6lBvCTrKhYIt+JRHPQsd8xzGNVnHye6UqhEsiLAwvwrCnprf6 l/PWaOW9MMBkqJAChMuT/2jdhT+CkruxZ7SxgHfnpeHcolSjbwOlEdZOw2edMRTu8F9syAQz LxLMQrnytkRg4uUlQrjZFKvSXAilgylcKytkz7EF7s7YtGTfZnLYo58FgLbGuXRoXy1XJah3 O8YeNgwBoPK7Q0IB6greqOmsZ0gJRKh+HLU9vsBJIHwJYMH0YrVijFqoKBdjxNr7wYSjaAgy MS+dmFV7B5IAGpUCITVm6c8zGOUteJm6lRaRbrKuBmHGssIbx7BQNMVixv90y7A4bFgVBLUN 3PN000gFbXd/tvgzGpTJzpH+9dY7WCWC+UdELht3sC4DuyZCyEUIiu5FFC6+QmpKmKvKebvG Dy4dwwFdAWsM6pcPXtPXCH4E1Umw3KON7UzspAgKMTQGurnWvZnqHuho9UKwJSaC8IHTcZap A+KmgVI/Lir1Y6HUjwUXga9S7MkIrIsVREBgzIsllEil4Y/nMvuVdZaVGxDeqH5rf5A5HcfQ gguTe/51F902I0I59hbNrJrNIkHlDwAVP0/m4hRykU/7omWlQI5xD5XTvVzDMy/VNNw6WS+p S37ZGEaaMj3fDd4TJLwBVLkMJXoWH/eL1iao+D2M8tCKL0yb2Nf0obsidWz6D38NUtuEfkEr xJEVQaVDp1p+vijOJyrm10qXT9Uqnu4937UK8XStFa0e6z2PC2KBZ34dU8E1GqJAcgtADnyW fnnezz4e53mXx8LPrgzws+/Oc352v4o2ELMXtwGAkN0VG1No3VkXaXOIhOw4nBpGVcGCABzO MAustKJAbLUym3xUQMTkw9I02vdMo31tGuV1FPvrs4imb/Q87sE+kaUddMJECsIAUG4pjSY5 qWvhFltgLvBz99AwaxzfOZFxRTBjuez2IyMcTpZLleIN39An1N923TJfQLf04Lo1pOpc37Dh ad2Sn262whlU9cltDSmzsi74kDytIH1CxD1hjx0P1RavV3YzJ8dWoZTOwcAcc3qzQEJdZC86 voYG4RHyPDgivOq0mXVFuEcub7pvz6YltNpzHew8lmlWcvxmG6cChU6253bCsbvW0Ach6URy CVIgY5NDIWDe84KCJ/h4rksyHsZOUeRYh/IGF6zJyPpdZcPhI7JVshl69M4Nd4Srw8uxtkm9 SZfNQKbZEwO8vQ3lD7JYc2TnkBFYRlAcVbWm2xWZ31ArXCNmzjWywNcoB3ORa0SSIArNWtcI dkIHG18ScoH8q0o1NgUipEAn9NnEJPPtFflE02la3XISmwq+Z/tcz7gdl9NPNw/b87vT3WH/ bn87HjJDA047XFoWpZwdvoRTkvvDP5+SlD7x8B+esrSZuGxpMye9JRNPW9qZyvZLX9ou7i9j zs7O54rMS6y7R6xNvvmkKBvtplEBOUyeugz5Z1fWlFfWJFDWSCvXNSlr4yOUNYbivbw03azi VFYms4sI1FfyzyV9SPussOxbKQE3tX41NlE2pnZ37XCZvPjmJvBaECBIPJFs6VHT3uVPZqea 0WalwbE01TO8osmF2NLwQjiocqoUBQ0Lvj5QZqHJ7+gPJJoI+sDq3zfriQPVri56v+/gJWFe HvBAZmYb0AH9LWS5iOpZpmkTRL6MemYGP8EqiQX5GGFXrFXfYlzKoZACjK42+oEVkPS+Qsu9 NHCm6KeVvt7jokj2ABDyROnLnqIE6AuVAH96SC0uDP0VSoBWm5nDnTeiVXJAKP9pJBN6SBYB BSqN/vzqnvGasTFZ3VNPnGn5lJnmlwV5Jfe+Kq6fpu6J4Wei7hmvnousFzH6AuqeEk+ZxFA1 bPUkUr8IKX3aJFL+c5lEr7NT4GA1eRL9VLDAdskV+cSy32veg8yN40+UCOoT90D50wuYsOLx PVhEfBcFnb4tcuJXlOkhYlMmLjXZvFwVg9BHvbrqeAeG5P15dZSQzmCQ+qBBHG8Tr2fTS7Bb sFlsrUH9tZg6pTNKHdbKHWG112W6JFnWTHrmMsm6XRS5KIByIa2XpXfbXDL5AsP3H1O1tsfc 1oiSwoDdqUftfkFRZIFqd9BH1O5QuQ4FzBDHFUoR86Wf1qp653gJjdi01bPxX0fEKyL/vEcb W7KAM3zmbdpy9Rc3V67+/bkr3dOuXyGAH1OeGeyDqlmX1GZeYEYARAjelbKsVrXBcB1AX4k6 dI4auenhyqwLaiWu7OTvD74ftRYMWJd1cs+nOokVqG4O+ycy762nabKpfiE/Qpc/cWxYNeAT +cfj9x9d6s/gf0t33DrnxeBjQAPQgbHXLKQk6UUpo4Gvzwoqfrmg0rkyLMq0zLgCRvhyUjH5 ZOkZNOOi2D9qUrFWjfpTFyZxLPGszidxtAQ9QCWPzTAtBEsVexMhnKBfBGUSgw0HM1F3d6/R SJcHTYAeoUJVWLgG+cgHj7Ays7m3V6SqqoLyL2N+w128YWHzxNrlVtIl+C9I+kBZHpkUq5UF iooCxHoxxn9FzyTToho2xyLzI4IcgrwnxaXvQkrv8Rkyc2mCUFXp4aE01UAw/32xFAACzc06 5fhAK/VT98ph9XQn5bKe7pxuvqCiDQDEBiYUJ0qnXOo1sw04Raa3+480+5RgdxKUdxR1l/Bk n+rJPh1f9/JNrkhOETkdIcQmvQslo5+OKOgCahpPvVi2bQeGRjMOWD2aMp44lw1n+AqfwQZa egsNeUsDNBAENrwji2Lb3aNMlmxO0rI54RnPl8mFWRJohOpGGA0Vkw3Q9jSgM7kBIauXAd4k ukyoqTYQ49Nf+vU0xfKhvkCMZBvgJUS7JaijXNXoW/+CBtlySp0m4KQGpehdyYW1Ok71ckjO USo+ngjS7Q5XGS/kdowtnaigPQV0mznAmNg9zUupRs0cP6Qa3bXVoFX07ysdTxgAXWWoVki+ VBDqnEtC2sglNbJZXdQpEUY266tszzMfiMUQ4wfYwLsfYB0+ufkP0MInsj1DPN30RUK7HhFW OJqXEwTRAIGKexnRXg9ty9OzP69QJsOxlGQTGryCBYwBg87HoHfnsrJKnowmKrD37fjCDEt0 nWakQ3uRpyQ9WXLgjOeldAS/aWePGlTPAzIIg4RmV/TbM9UTcAhZtolKtmU8K6KOiZUlEkVs iT2j87fnvLr8CIuPRNvZPwMo1IzpiOVm1ZLqDClSKYAOp5LHPwjXe50tDLGK554LCYig91k9 9w5/hoAa33Cw3oPyfgXrKIb8hX2l5X8XEDn9G0N1BFmbB1ekyHXQRaoDt4mZmcAHDUi/hnzc Iqfjm4wbFhcFMYS8vCC8WFEQXlxIG9MqCO+5cl4ihNQMz03mJW1HA11DcqBcPwMw+BLLi83I HWAznVHJX+hXyB0vMPOJTmQ5zGD0Zl1QqVAHVvqvS7q0z+zUbhEa1oGLxzuvbW5un/NICLHE eVSz8RSJu5DjaOxzHIGaG7McR33anzmOo/Hcq7wiBF12vyS5jlwKaNUHfbL2JwDhD4mJzfJ+ W425qiyHYFx3o9ZNTjXNVKeWNO5oaQ7sSnMAsOhrpsva45c5YwvejXlmjALqWPKXVPM1UxJ7 P1+5e7/KnOgyG7bLa4uLymujoNGKUBPlC+W16xDeGmUcBNpWVcbOC/X8piwS005m1dHVS+TK MtpNV0yBQA5yMpTyY6ZhKFW0kVWt9qUNLLHn6YgLJBQJqLGKRQEBRbY7cDxRy3cbhvyEM59j 5Y3MArJCgIAj21PWRc1gmXKWybmKZ4rOniE1z0Mh28fiENnW5A/xENkW1b3iIZLpH8Zz8SHW ohFJJdfgmdJ5STxkGgzhPnQpeRnnf2Y8R7DyK0AH4X1Ah2X682Sqs7bkOhd6wT9YKORQbueE bTYMDSxI1FuGwbdOrdM4o8PB0wvXR8wRKZwzraIGkneVLn3kQQu7Y/EcZyJ62hs56f4Nm/W5 6aciN92+3b9FLwxVzgZvh3hylivIXx+P2EGwCLWj5jFYiCeRw82Wa/Teea0YZuIvFEB3BMjN xcJSJmEZYRDlPqMqqJDDBgRWcGjQvkmjLFjAeWAKG2A8FvRo/cVNkjkYHE6xRC8fCy8IOGd2 VSRZLOvHvFjgoLI8WNjZFXGvd9mDHz5sMB+6fat/eUqZDOG+yACHV+gOIB6pS0pnKZ0RcblA wWDmVM+x7ew2877u5EZsUjdC7RPRt7X0yZ49egm6cpldZc4tLUknZT2XgcEgA+xvloUGzcr0 85Ta3QExtTKzFxzfOQep6br2vm+q+972nNLVUKJZ6URqzhESUZWrG0C4mh7okDgVmYhKJ3M9 BS0HNfBmI+lZJNND5x1U5xMHTW+odr3yO9ksaWaFlTIntKYyOKzsoq1KMlWGknRgKZsx9AVt 9ja+B2z2mj3n7nng1E/b8IL341Dpt6I8++x2zIns4QOC9j8g6AsEuoQcuoGu9NvqQBcaoLG1 17uRryrMtD7ChUYNKEa7ZoSrlhV5Fh4V4fKPp0gGGtFnj3AlDxnR/hDnv9RDfDX8+omHOB+e dIgX6GReVk2cP8R5VQ/smQ5xrvqShOfCZHgPd/ZiSejWskf254XCdWhgduf++Yv3aHnid2dn f+4iJndnTMLXOM0bB/8cB854RFue94JymUTpWc5yFc5y+etZ/uR9z2dAK7wCrTzmLJ8BrYgX Aa2IGdCKuBi0wmdBKy92lnfQKp/pLH9RtEo6yx2jGfNVdbIb5tez/OKzvHTuXXiWF9PFa4r/ 2bO8WeLrOc5yPvRFVV7bn/As7yyWX8RZ3tMHn/ksl4Pf8+rXPf+0Pc/ok/Z8sWk51xfteVQg +Dn3vJhRT4T8DHseDswvbc8L+Wn2vD/nlfnVZn+iza6fZrPjTcv1RY73dPuz73ndd7yn3z7p ntfDL3fPa/1pbPbgp/vVZn8G/7vsb5D025NsdtU/ddNvz2uz6z71Rvptvf9d6s9hsyv5Jdns mn8Km53y3/gaMZcC84UeFoH5Qg8XAvNlE5hvuZZ+lTtPlzu0b4CLKgz/GLkzE3IXVL+E3GGy L3eYvFTulIv008gdqr8kudMrYPDMcT8fA9DsS/UbgEWH9zXjxVFXEXh8UiOCsUX0TtYwaSPh hTHZsANYgQMg/X32HFidGcAAEy8T5vOTCUevZxqsVvPba2R3XofwgfYGH9s2DYRC9nc5aE6a +zERxHjIT2fEs3lxkSHBVxsSLvXeEoz+7DY+L/fA5934fNBP2/h8aDn9eAHne9mNz2k/ushB eZZn3/ho9J5v46M18kVu/N6Iv/jGF97SMOLnd+JDc/QLOPHl8MQTX7Y8f6zwPLzwiT/jomBK vuCJL4cXOfGl/tJP/M6Iv/jGp8F1+DPc+IZ+URtf8ydufN2C6aVefpoTf5hBAQzDC258zV9k 4xv6pZ/4nRF/8Y3Pic+50ptGycWUOuUSgJhK1e59Fn2fszWxSBifOUy/FLFyt1asyGF4abFy d4lb0NCniRVhWoghOQyfUKzIoe96lMNctg/q/v78SGFTJay3xMrYFyv7QqygNbL/5GJlvyxW eiP+0mJFMePhB58oZYC1SjDNk/iKxpbukviaMsy/ik5411yo8ZXygshCGyGxQAscQ+xPSt9d SAguSSK0q18R2br4LP9GStwO4S1+eXiLrghv0QvDW6IT3hr0xe1TK8Jv6tLwm+qF3+jnLxkq PKWtNKDeinxSxRghxGY1RwPQDAvc2gJxQxomiM7anwvWhvHcpneocthtLa1fcVdPw12pp2Et FVZ3ZAm7m8ddSSFfBnclZd+XKiX/9LgrNDC/MNxVNdgvhLsyxptH9DPRyxT1gmr+G+UpZrR6 YUaQiyoNJBtReYomDQtf0Vk40t/CYUNnib5Xl1foaihN3oEmDmCep6varutJutBdkFDQBedt vbxM+OQolgDhk6QCmN0ral5GFihQpi9Sxsbiu5DwyVVFL7j+/N/EaB7vgOx/HoZiWcCvXA3M cWrsaQeIiwBjFDGcqIQ1msYBv6bNISMdVooKZvrDIjhZOSz7pWHZnxtkiuN5aVjGBikiHJb9 NeqfW7CXj9LYQiZFPcWXz5BkmFk+2cvxD7N8SOCr+QwOq6aJ2jUtqGiUlVkucMObMjbKU/YY k/STWqDLFWn0IDfzJbkqC1R4oSGZnNkMgT/zH2kzMF+kXs8Ni9Y/A1n6eOHZGhavsEg+c8RI Qf7hVosIWYY44wieQgYpq37Qst0Yatoki0XRIqLf0MbK6u1wmyvaKubnxXDY9yTAHYYXl/Yd gtsnidq1JQoB2bEgyheSGzYIQ1w75Xy1P1rmj60vqPiCinKlE4cQWpuU9rjIj5XCXG5wBDWP LyI5f77FU+m8plCk8DF5MZBfXUlPcyWZp3HnFQwd8rIUPvlSKXxyJoVPfo4UPvkLTuGTnyiF z1AvdsVjRRDljxC7T+MRT0T6HkOUKzK2nFd5dRdlSXyY7XIfEO8XpvrSY2vJlSM8Ne7aqo/1 yElXBbvD+y0FW6odEdTOIK8byiik/S50UVg7ItfPna8dAT5E8Yfmakdk5ZM1lU/r2ZkpocHX DkNBP963XF62osbKUVnl5qEzyyPvll/s8iA+LEnFzDBQ9Ysfhujn0DPDwIdf/DBEv8bcMJjh MmHxhUuH1jB4P4ZmZvNS1Sp8nfZNquGeC7WD6uyB/iG/dXduASJMz+TvVHefVAMBSnBm3bym V/cVcgQhBQ0GsEpxNetkTQ/eQrNi5ebwwfPO5/vTOkT3W+jP5lmt/35Oa6WHtJSYriEab54m t1cfqzaijZcx5mK0jBqWq8ip4dIqcqyNlhED/aQadtOx0fJgd5wbyJty7oAVCz8GIZtGuYyy TO/NyS9NmksdG7pcSUNu2oWZQWXqUIrXmzSCgOh4Lnw+ycTpGZEBlHdxp7lhNh7mCGpsSGAg ZIxHuYIU7a+NxIQovHyysLPj9x+drB78jk379taNjY0z+8IOXHe9on+7CTe716b1dQFabJDL aLFBXrj+h3YVRUEfYWqpLzE8lOqLBMIrWCGOlRXifOUO4uvtcZ5OJp5CCaneHu/hxEDpKo0D aHzQoMi1EHh1CmEa5fqaxbr9lpTephHIHblQ+s89F/Z9E6cGBlUhnlZbMETjIuJWjwj72Yxx qHJZzq1vpUDmRwafeIiL9ekk1w48GFPxE3uTgRMVJQDiq7Y9jSOKVBQ7nZO1XLDcalwjPR7A QTIqcsGQwmDG1o+wK2KDlmdwmjUGsZ0g0RrLaYdp/3q1AWpNKmRjHUynNKLu0hmqettzUrTS cj4d7EvsonIC6xspBEX3oopUH155IG5v6bseuhIvTiF4k1VQ1HdXejYURgc1CYNjhaHt0iiC GLCzZO1uCSeYfaCH+FB8KRwXPhA02nY5tIzYevYo5en43GFKEfRvaOWU48KzlbMwLvtmVdHi 6wCHtj83CsSVtspYDdO2UdmtE8ytzKY8SmMepfyaWG7NpyQJl5nQ8xQp+Ysvtqp8DV+lNkh8 1zlc1FnLFhyy+czHfy+roBnhaxonIjBpDReXuBaULCtnlFyonOm2ciYF2xQ+vedGklYFCe8W oe3BxyrN0AXkV01+nsatwN17Z4YNB2xeJrDeXY10uWr0HH9Gz36m6ktcAsGBCOEDX07jvKBi Odm067KxPu8vsQfeTS04uzjlJfeh2bjqq73clqIXdShB6GZ5yxSqFi7XJ0v3FDUW3/YKsiPZ cToWtRVPR1DmGYZkfDKRKMwyEFv0gtt4ld+ACsBXMqvoCSJZVkacNLKqMmIOCkdNwXhrul0e NZ1szZEiAy7gGip/Gv/VY6qr6Apg40t2WbN4CZfjPuaOe0eEgSUhCap52q91Kopip9uy5rHw YkoYMVPsFLQ0li299jMWd8OPttTpQFCxU28903glLj8zeHfN0NfbuKEr9bZtV519ufrG9En1 jZH6OultetN0brtN0ZiKXFPWredU2zRk+XWK0VYYIrAF8xxv4wJdWZrWepK+rFMaq4ciZnpm X4WJDQQZRTnClOMm8QMElpYhrJFc6DKBw2el36lyBosvJF1pqbVNkn0JKF0wzfYzptm+aZqN l5pm+dxJ4+CPvwwgaQjTcsF7x4PtqYEGvE08HfJ69wvVEamgLeBkMNgD0fleIbQu2AHptBvP 7dOuyj/an7tSXIaEWlS5GkjxsSfFx44UB0jPEIPzZavlQFaiT7JEoaSsUh3Pqm096KsLVwvn wn1GVaxIj1uXxxujl/SJbWkm6xW+CDmDzhCS/3J8EcVG16uPgegjJrKbmneNwmtmXEwceXys QRlfy5ypFmlOFRCfr0jOOM8B+JgEkdeIEh5VJ4dN4YPc5zdN7/A3gTf5UT+B1cY8q6cYys/B m4ILWvInrvvuxL96u39/fHe4Ge/u7cy9PR32D8fbm1dvHw7nh7cfb66Pfz9c/xRuOz1s7x/C jQ8/3R1e3d9dv7s/vNvffn93vD68u9s+PBzub97ub6+n1fG79x9v3Mt+M3PbZurfP//l98xO nh06h5xzHxsP79/t32/f3b5/fzo8fKWJDD+EC9OyvhLFtWkTXXGNr9mNdmVhNOiifZrR4uK0 SK4mpQNfnFbSlf22G9ft7vb+oRi0qQN/dO33g2YH8fgfvbF589Xbq/Yvc4M/88Iw2L23up+n Jv7hz3/6L39kJDXy7Z/+5c9/DRfSZ+9vx+3DdroSYss0zvMf/vK///qHf3lLuMWM/O5297fp idgs9JuivwF/25df3958eDXEfxCq4z+tJA0X4z+om0/3TxcBD1fTfelXXr24/gcZaLotfZTR +l/o0Q/Xt5MgPXy/3Z/saH6/Pb97vz1ef7w/nKZf0fDoODrNu6tx6tylf9P8wQ7dDx+3o6Ui GxoNO23fH945cTvXIHBXvz3oJtAccD21hkim7agex8PNw6uv/+sf/rD56tv/+j/+1+uvzFvy lnxFB2IGMbCvvv3Xw/jVv2wf/PUr8vpruNBubh8Ob6fHriaJsv/7m6+/fvO7aSt92B0fTr/5 /wESsKnIigQEAA== --------------6EB409978CA90BAF8AD1F800 Content-Type: application/gzip; name="regex-emacs-new.s.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="regex-emacs-new.s.gz" H4sIAAAAAAACA+39WZNcR5ImiD4zfwWFghQhuxGQY7uZP1VldtZUj2RPjVRmy8yVKbkQ3wB6 ZjAQDA80nXXl/vc5tqvachaPCABk8oVEHD+LrWq6fPrpV2/enW6PX33zcHx/vNwcf9juz2/2 3/zuqzePx8vj+L97ur09vb/7mttLP98fvzr//XT/9sPd8e3+++3D66//6d3Hu/3j6cPd79AP m9+9+fO//IExuhmf2787vT0/bh8e7x8+7H/31f6H+91Xrxh9/fW3v384nL773Ve3x+2PXxH/ 1+uvf/+wvfzuq79tv3rzZ/q7r3748L/+c3f7VfrxeLA//nD/1X9582f+7evx8uW1Ht/x5nx0 7fjqzcOHw/ZxO17xLdfpX3xsFLcN+vHj9uDf3vinyv8k+Z+i+U/6D/dP1vxn/4ZyGb1+TQbw NxunxK6Ry4eH269+f9xe7Azb6X84zj3GNmHhULRwxlnbLHlcbNLaInhxPR7Pj7uvfn+4HS8c bsfFdrZLYQDLdGymXXdprc5/TXW/9oSXkmF86/bucPvVK0JVfOH2YC/w+Of41fPtj1/ZP+yb wx3jhYdw4eTvwS3bXjo777y9Hd+u4z3uY+Hd7sLYHfeI6834H/pdcWue4v3t449oCt0TRf+t 7DjeHZzkGEXKn4JIOZ/+sxJFb27QBSgS7Cp88/Hu9vT34+3Pr7/ZXr55/U/jK9/vTo/n8bV/ /Lc//7c/2MH0y/XNn//13/7q/67E3/Zue/vzfx7fvjs9nB+h+EM/BPFHVUP83X88f2+Hn/Dw 2+H47u3+3fbth3fvzsfHr4kM1+Pf41Te2IvpQdZ+kPLiQTY+aC+Gifz93q7o8fEDeBdtv4vR 4l2jtL5hXhzbWdy7tUMoeNXuvv0qPuBXyfFN9lp67tJ5TuPnbG/stbEFefXah88fdz+OO0Da v8+dRkgr+4ncuNPHPX5yt4+L/2+747i/Zeuo2V7qs8lugnyC/X57G44qOytxoLd2oMcxSgcV Efak2q86qYgAR5UER5GEkhmeVuDfVIJ/wwOLz/8bfWvBvylsD7n+30TP/3tt23r/Jp1xQ/fw 4t8LzjJJNsUKtfLVrgK7/OxhRzdJ3tKmvCXrBK47nbRA4pQV4vSApfklfXLcOvbw4Ekk/3Af z46kg9khcSfGKxLeZadtg08N/x3CD50PZSnv79SwY/45eD6kN7mjy/7lL6azS8e/0Xa2F8J2 VlFUWXkXd2OYmN0FDEp6WzgI7d/n8W36WytNxu26t+1E0t2rCPgw+9ud/Swh4R3h6Shjwnvd QOMVMXPC600cfLHyUcrTo3TtV1VLI7N9zqPnBO/xcey1E4F3x/f+bvs4SV8uhPLD8YfjD7vj gz0OH499sX//4X7yZBjyLff98yvc0jvirMiLt7D+URxv6ZzWepGixjdpBM6PHx6OcQDqMf3b MWznShr407Y4etwaf0WFTJtmbNTRdWmXl51bAHaoztuHcVaYf1vUHZ3m6AZyUl/Wm7yl3H48 2iXldodVt97uxx69//Dw89uzHY+gJ+zuwd5z/bEdGhsUZZMXQ9uHqJ54Ied1WiCVduFQ9f1y gyT8Ft+5G791Y2hb9p1tq13AQS1AguLVTfrbb1ih4wlvqHtHUj/D1uEmzsz06JgNbs3YOyQ2 Qz/sdGzzZPs2mN/ZKW/sufGy/G0vFSes6uylUpbDQ9c+M7/X6vMYLy43p8E6HIdi57fRLs5j /03hGbeCncJ4Zw9tNo7U+ftxxl/JzsL/8DA24Eby8Jg74e1zm17jKqHtB0G7QZCbdQKnOLhP 8eD2Mmewd4SzLX9zfyks0n20CW9IUoGTF8d+mmnbJbmpLNXt3J7jZFN8PRzpuDlOuDiZ583j LPP2bfM4KzA6WeRBFcti6oBnK1kFvz+fkt/Ads/ur+Zc2Z+wlMoK2A3BagUndoziIk4fGf8b 72CmM4F2gDe9FRimfWL6kknPvk0SOzsZaLFu6dSwev0U2lh4dItf0PGQVOBD6Ug4XBpDEOZo D9evdqsPqsNYeS1dHv7ivquB7y893XZ/aSqIt3GjBaUbPV56TB7SL9q9GP5kN930YcSxt2lf dZDmqw0bw//pzhv3sxcq2eTIowTeUd7kVzJYRn4AOI8/0YHn397bn0TcrDILwNsoAOGXg4Ht ljcHneW4SeGqAFdP1WpCnT2lfpyKlzD8kvIu1NtD6q0Yyt4eUm8N6u2h6K0zs8SQ++b9kflj aAPc2m9ZIS/s2eB32vQSEd0zpFZaio+9dz0T9i1ZO5Fx5Qcl53yKF4KSw2dOJ3HN6VTJKj+b DC9CKgRaaIxnxVmAY8xLLK+e7fNR4rtiDnmrusECwiT5iOAP+2hfx1eaQ1JSDNIy3bG45MRj 5awdigk75AnIh2gQj91B9CaFKMIx+Mz3VoU7cNrngz/et+h499+VcZ6ZmlPt6FOVXT+rSbT+ 8nRfe4x19NvnMFM4u95M4Wx6B3OxiRtOCsHwluMySjtCsXBntCvcw9u5i9uZ+u1JlgqC334o 3n5I7xoFsm3MJotlo4gguK0qvU3jthK5qK2CtN6fW0vx+w/F+8vWqvQ2TgwnSuATVfLq2KzM iJlTFDWetj6XjzQpqnOr0IOLYwz2hfFNlhdIoezaGSQK6CBE7FKTfJMkONeNTkhR3gAawoqw Ui9OVIduGiGgN/sPt4duHMj96oJBf/HRIBsn2HRDFM14Ryt20gzNNGM/zUiSd2nuPjw0I2w+ ahWc3S7QVgS93twU7tD+ANaPhwEr3uGuhkjcn4pI3J/akbjj5bj/+OhjfWPv4BwUP0UwAp+K xomF0ThRRuP4wmgcDzMyF8ZrTmUIvUGbyj4/F8ZrrhUUfLtfFnyTRfDtFD2Kc1E8IetVba9B 3eqYo3h8mIriGRlagMNxpdU2TuYBKzuXWtmxd+2yu5TvCm3Ripzxx1uk9sQG71tOHWtRU02R QYhD2mH07PEZda3wFmew7qPTQKtxxRq66XVikdprhzWJxl14bfLLXvC7VJqG7C3Z1nZ+ZcNf sKW+eyy+u3djYt0XWiXlrpjkJcpdXjLR+bxEv9Oz+h1QAadC4TP6HVQB+bwKKJ7g/qTaTPk/ 9x8fHo53j28fv384bg/jDJ3uW6uP8hjdchcJ59/2FiqR+FYNbnUBAGj57qKOQ4J33gssb88R 4uKf4eze7s52KUhCpJbDqGlozgQVPlZhu+0FQgp7Vapn/Q6tJRNGCOrWl0HSKnYi7U1Cviui fgcY9ZuO5zgFJFqr22xpuRigiHLSDR0YVdAjHyiLUYMfv2I035pdpoXnIrTTG4vA9eov6APa zM4F7oOScgjPghe6jo+3uwU5gMlM5ql7wdHtX99nsom+K4q/x+Kf/ntUqhhpoglk4YUjT7Ip C/7wDeECj0kzT3HbdAvRcukib69nbzt1lq6HxXgkh9KN5eYWjhvAcPKYBcuYzC9Tu7hAmNaJ mOmQsJhYe8osXXt6WLr23NROrr1jWExh7YG1QDRprD2dlx4Jf4eV55eiTqtCuqZStPLA11ix 0rVsrzz3Q73y7latq+jfXCA6l0pJrSspeY5B1T/+6z//+9u//vMf/vynt//+p395+89/+eN/ /++hHQlc4N2ExJ0JftryXAJnPktwpOYwJRgJHCa/8vHumzmZgtlb6ld3ScEK3gI1+ya6aSg5 ANiYdRGEZdxix34YBzuiSeyHOSEI7tWONdjngrPfr5mr8I2hgYSuUQLdNBm6WP8rQzT7WnVL y2yf/JtNbW6f39DX88Ao7cGg7MFtGUkLgHL+fLAyIfx0Q6iG4TLDe3vFiK7yesMYBjRJUTqA sSLsWuD3C9fJnwYeMI37J5esycG5V6lDfrMN1GFieL7BLuHD93FjDd0uE4tM8z95PxY4Lglq KvrBvTN/jaDmUGdbECLBDbK4Q7s7TL6DFjcYJ3Rk0aM4h6Q/icS4/e1C0X78GWuOP0MQNPfG 55p897Jlk79dNPfjC4vRjnNLzVBYlWAkVPKEUdVqBpjyW99uk35iVRPd715qxglLrRic4u3Q 4uF5gl9t70BfXdH78dmoSAy2G/ffFZEgL/n26Y2DWH4QDBwHmKzYDq+NCGS7KnfRZh5fjo1m Qluhz3D1SaFP8I5m6BOdoLeu4xwFKuumiedoGlvbtvexbX5SFsg6sNwl2vlGdTf+MDyz+Pat NWo2R4ImrWTULd/fenP5vzoL+GTVuCCFRVjE6Q6nFtcaoB+5UTewD8mkmLKkMWQT7HxCR55X g1mhl2M1rMZpeFjpiukZhU5fDnSkER1oVxqF76LvNEeaqE0xx4dTU3F26u3udnv39/uWQlsP QjonFy9RsaYp29v777d3H384Ppz2C1tUKTLVRnBrfnUrdsfHxW2IO27poJAoHMEi50Ne5BN2 ytD05kQjeX9BaBtoJOtlvp4FvhxoI8/21AVZoo2cFd6wkJB/Bkfro428d3bVgP0z+wuE5gQb eYv8M0hCdNwxBLljtmvcMUGjlPgFr50drUEGnDvrez4C74dTZtNocQBNDrMQcZJOfY1HpvFV v1mUiSDcIXgV9zb4HAeFrZBwWi2S6XS4QqZTslCmEyKXyXTfUFpIdLmmv3rzRNfXQn8EGzpe WyI3jd1t31/JgGKjPtP2x1bzAhctUxMigJGlIoDRlggILoUgAs6n0k3mIUPbAkM04SZjDG7p 86l0kw3YTWaQl8w49d+FNxd5yZjpuH+YaSmId8tMYMLMhPOWmBdcwdB5ywlMHHLNeNh3/LcL YgrXOXSTuwk42xvBiJmkET0hxDld6uiNmJ8XdvRy/hRHr3FOEgchWrSEiek4eonpO3qXrsEX cPQK0lSgYoIOudbz69A6izy/fpjdwhJsjV768X6/PR+bKumUrAiahB3zGXMlaRJB9kF1xp/J DKpz55y566WZWCJ2Q3Ms9HNGiom1io3hU4oNU/njZvbjaSxy/uD+kl9AZweT1i9IwifszNdO COnv8iHH+cRZyeUSoRBaaDHcM1JNwvHd5vO0Mb9hfEU5vlswvjbIv3itabapEzTnx0cOE+Mj 6ZLIbMxGmj1FJV09PnJqfFzmO5VqA8+L8/10aNRqfGQzH4N/UV1v+UmppkKicnFIVH2akKia CYlO63rOs6AWR0RVLyKq+hFRKL/VrCUodC1yst+IiPlNKTfVBiQMbUAXWuxtQM1WCChNZ+Pr bPUG1FMbUIv88dnBHPQGZzIC6T8YJ+FVY7QIGi01NVpqzWgpp5ap9SNipkZEiRXLi1VOtPOE suIykR+3u9vj24fju6bSgjMG16gGQj1zU5aH7ClVbZvN/dDRw+zoujs2zwyciS7h2b2kzKbO eYmbYdahbNiMm2fauePTS4fBvQpEHFvDrYrhXuqvL3w7Kb642CdLh2t9spR2PDJLHLULT+rS 5VKi5/Si83xmBPSEtKJsqaMm4gqf11dLxRN9tZRUvlqNXLV0SnehbgPrYcJVS+eXmFxr0ehh yqKhugcdYAPpYQbsQHbBAmG30NnDgLJJ+4jOinBO+wKJz0LvzKoI1/uH7f33V0SU+iH8gba+ 7z52/3C6c4fNfSdS5KJ/WSy5oM5Lnqw4muD08Ek9UTk5TeknahN1Q6AgqYl3WT79e3lLVfQI WBF13srP1gBuEbdsmD9/nnM6wreNl2vJ1RLx6E9F8UJMSwhcvMCCWja+XnfWuvX9lcPlAFcs A22ey4ce9Tg3G07baoYFbMZcT8W0Ppdo6XklmTxDhwV1iqvYfLa0hngkOe+J5s+xUONou3UJ EQqVl9JtTWrMxC1udVEji1sKX5MzTifeov1b+GbGLKpZOHli4azy8N7cFJda2Xs/fHz8OK6J n98eL/vbj+fT/zq+vYcpfK3fYx6fmMjj6yX6lHl8skjj6+UQ0UZWpr3m9U/Kp9LVQMIcYpRD /ICJHs6tSJDV5nxr6JJNDhebgmLhkGBRbHAp3gPIG0uxRJD7piBrJQvo04DZBtdFT0exn4Ep 4+dTq0Vbx30zZyCO72r2x30n2CAOGZfHxgmfZvfO3z+EbuxuUVLyrkPZyaQuk6EBuTQjbD29 NPPpvZEAWQLqStef9AckzcS3QSpORlnvtoV/9L+DmnPNq5/8ByT/ZBQ2x3ny261Gfyj4h4R/ iO4L4PA6D8YCWk/mgKh+Ddl83HI7AELPc5PQM1xdQidU8HieAY8nSIM3YrbJAhNArnpY6iYd HRsyRUch+5ZkcYI8yZ68BXmSPVG+KE+SOQhUN0+yCP849aRgj66tY8B3GQZyXsDRDD91voJk jzGK6eLCCtndF9yJABW6uw2yLbxA5l/u3U/3MQ2ZD/7jqhHuwjBmkK2RfVnJOmdCOcK5HGXm rXRqEju285RnGf8/xD75PGub3BIkcfiMv77NCdb7gluEufwJlt07oCsakbVNdsTIxjB6XpPB GUIRvVI6KLjFwlWBr3xkQu8Hbe35wynTgR2yAua5cVrvnl5QHFDJUywf2uz17kMhiBubpr/r kvUhRX+fzCl4VkY6NeBFvfvw6CcP9PWCfar2Da4lcS2RilKuzzt1StRNbkFmrhlIwpXX0vLt yZYtq23LW3+4tEKibkCpYAUNkl/GRhbxHbderfRpKbzlHiCt6PWluzypySRRuBUZPznuEhLv aY2fO5lXfla3PpvOHjeBxDTeuW9xy4GR1zNDn4XRIeuxtOjpfqKnRD/XAOsudwOI2tYCdGzX rtkw9axT4DYikc/TWR79EoXcw8y9c4uMiGfsIXfuUkb4unfGkjST76Qr30lm38mHFvdvDnyF Mc20sabcoKJ/zKNDeMmx79tokUZtrYO5YRDFKbS9lB7XLP6b9VT44DULlgW513cOPUXLHcWb 1ScsrQ++BzIc2uBP54YdPNk8yRAPkpIQwGnp70BXTHK+ME5mD3LWP8jBsNmkYHDgwtO0PDJ9 xi9p00Se0knO3aJps+ci7jeTPsZ9izkA+JLD1LHr1NMnKJ9pFboV111r4YPMOz546XkEJI55 cSVW1XPt4r6P/kq3OPxQ7kt6z6DOWkFtt4VfRuiDBQetO98rnxj4RKnt8oFtetnTjGqU63cu S0XI2MawNI3m+IpkreRA+7ufhBsZLVx37noWOJlyO8N0ffhfdgDAw6ED1Ctoye2OaNyxvvY3 qDWXW6/eanFnOTrAQRUjBJcNRyNU5a2XxHVhhPIVySB1XrE/0gjt6xFCllEYIcCcClYro7rI wAZTzIbWFIMkUAol+k+31gBMKzN3Mauj44KiuEvZuAQpqcAGhQNh/4YDUc228waHwZSF1s9k azL2RV8ijZfty+HSWND7qi/7YgHvcV+gZdFc9vv2vDi8UcI5hEwMAH7MrQsXvFM9BTnOjw+n u/fBh4DkazVssrFJkAh1tOjVd0suC9C4xW2pui2bn4pbTjRjACLFANre/Dc3baOmRxcYCnGR ohAXadL/PRzf/rB93H//lr493T0eH+6slpnjB42fY/hAPWP4ILr37yMfHnr44fj+dB4//rXE RIOQOxDSAUI6PxiY8MEG5qgysscNMhI22QabTIJtSkDdZemDMQgQQ7Nr5EaHjH+EKLSUHuiy Y1nAdH1Rx7gRMt7qdBkYAykCdjdk4Pi1Q7thJzccuAmUZ2qCXfFe6vBC8d4y2gDebDfXjYI3 F4UGXPxB5soswcgfF0oap4KZNYcs9rcQl3Lj45HxO8GGGq+m4cplyQAXcH75vhw8qYupcpdH cwZdnomzBnV0bIdCjxFgmmd0FqEDvurudSVG31p37Pbd8e0oHD7st82ArltLlA+tdvuIq7vs cUqMmAznCV5IkzfOMGDQN6OZYLrzXj/AAquuDvUVeHrLBepAc7ZWA0wWyOUPYu5tSvRLU4Jz EFITMuLwFmLwkYbutHoXarMiw/UtknNW26fsWrHVwsMB13B/xQDckLSabIOSZw33ND2Ub4/R Cd9TVnCjby9FFS23D/3iypID3hcunMtxcA9SI5s7IUuXYJsvyDLPfbR2OnxHvlh+z10ErQcX 0fDlrKgkCyZg186kJikFTw94wN2IZDlUMH3ngXJEJTyXSyKV6EC6ittnlDUn9JDnmRbEMI1V MVvTglMKxzqTTbnoLLx+ANfbzOagvz4CQJ3RlX3BScqjlYdGtagWBzoGN2BkJzshThw/27J5 eObVEku/6G7qm/sNrLQhTVSF9+0pryC2x7NDsF5y9bC4UhpQZuwK5SCflFi0nIph2RVnN1Af Yr0FVxAmqOIkIXKNbLTRF4+40eVx564mM7YQCRTv2zySLclT7Ge0Ks6YpbNWkLzsSlNvV11C dLhJLJ7Io4FkmZ9vIvHGDPnH5OCtz3H9oBnLkleAkbMHh18MucziIV/yCdQuv9rXDXBrV4uW DKWiHF4iChHsKyASUaS+JskVfW0gOTadrXMCQm8Q5xRUGAMxq/Nd8mzhZYao6ixDXcGUTwWc ZBdjDRzCSXYlnISr4Ypq5S4lLRchNQDWwI2Cf0h4HyqryiEGBP/FDYN/oF8I/AOAM7g28A8N /4At0hL+ARuuOfwDtkDDFmjYAg1boGALFGyBgi1QsAVKdP+AzVGwOYp2/4Btk6b8YwGkhIAT 7Qb618DJqdt6ExQJGf3OzRz6XUhYADltq6CZKlMg0wpdPOq3hm8KLTS9REgJ4hbQXIFbK8vm 8JBCm2zol807u9thaYgbdIriV+xcCSVpkHzF1l7BVh6kBG2Bireu5GQ6fNJ7wNkPs26aIaGy UhhBKTwhM8O4Ypu0nxUilFyY0SqUamW0HlBSzKEimD6UFZAO01kyQi2geUpJM+CjUYuaTCDK mbAa0VKPE+UWdc4xQ+daEWs94wzZxAkL6pAEMkH/7qHM6m4nf7lSRUopSkTajbvA8uQYrcXQ AqC7Hxj2/u39jNXcDJm8RDb1T3fY1Uev24GClpedSs/S3e3YRBA0DOoJKZEpvTTu/Q5pnT+T pmWgYRvc4tFULxWgoem7CYoDRaoF7FnDJiHcs/Y5omIHutj+vDu+/fHj6THvNiKiihLowiT1 TBsE6BcicnUHbs5BBmaNFIq90bHQbcplBiJcVj8esnMivhuWrIXyiaOdmou3ZVOo+Xb8zDhc 6Zm6V560hAk/XiyRP+lv4VvzLnKskywtlHgzpDKKyrxr2PmEqxzG60VrsZM7bFiZX2uAi/IC iUdtUMVkgmXknsx7An3aYPs0C2S3FEoFD5RlHg5JyRvHyo/QsEbLs09BNY8gZQeiV7/kPwiB ChsZ1ND/DWtM9UsW6E9cGhioKdX4nkpVKU9dpb+hf8V8NkHnqRbZ01Ut+6GurmU/0Ve2MP+t Lx3e1sGamlf8Au8oYeNPYqEWBlJJBjF3IHBFP9ukzmezD+RZJpVMTWr2Dyva71OePsyGPHjs jEPbhN+QmyTcEDFmcG5zRu5QWeM6+XACoU3bYxHpKYk/NjL8qucjIdgtXzs7UG3cdJT4b5R5 i1XSYmcP2Mvvbz/strfn/8qU0Om5hLrJvqmsbA422geU5rIGqSqNCOmbCYo24xpPhGTOXZ7f WJSoPoA3qmZZ4Ugyv4B+JznwG4wBpQouqVaEjyrcTFnR9OXp4FGLfc+9EeXOmdzZ6NlkyuC2 dqvuMFO4jA6nadUyKsOVjqwbKvIP24e/Hx/e7n4e1eT7D+eTCzL3FmD2mKZvIlKFQoUmTYVb w1FL+o4b8ayPEQTFhnvLXDcEnpv54zvX07Gjbx8/OLNg/OfMNANx3OxdDBIVGno9ekVe5eFS vL4a0zxM20vJPr8vAnCCD2hlAfWyt/UFJ1eNYlgyxWpZuiTcRAOPPCu83ZVTPXk0kZykA+ZQ KeUelEZ+N8fDKeWDuwP0lBalixGNN/r3s/p+yRv3k2RQp/uMrER2U5q3oDbrjNwQb9Ao3efj /aiSH9+ef7573F5CWvK7Dw8/bR8OXUu3bRf77m2mtTGgEWUFC8BsMTx2/IlNKlgVG06jQsHw HaCqZ5m1v2RWF9zPPa+5ACYJkwNJtsucAYzJXVad8QtmGa1Oo877+LDeYFCrP9IDWPhwC4Hq ziufgakZhw70HOefiBnXhs2qpiInTQj4BXRWOJWLikLnch9UUnQCgKih9nmIVwk6W+jih4e4 VgLIJGFD8i7wo+0+N6lKhlALfQktUiIKsFpJFA5SLI3ZNJU/2ygftIaqI7HrVNWUFUjeTKp4 B6BBaEispwYC9TvdU+8q1E/cQtw1jW4aGzr2ODgEM9rfLuC4jseniejJkPQK2Qp+Jl9kMYZD w8eZvYkkiYiHiFc9lrYLwmnHAvaT4id0/sHs3BO7xCHhErcUVT0ppBzYW+Ug/AoZpFwawSIR BIohrhFBIckdcH0BSoUbKjnaykBDGBvHyaIjWHGK4pfVeZqcjYJr995kR1a7My5K4+5j648m xXnnZFJcPM/BFFc9l90l4WhAlLjmWFJi6ZJQ8iqutyD6RcbsKAkSFZDukJePrSWMNUggrENt Fryg/O8ycEym2i0+12TrXWam+M2diz4OIY2v5qUNIBqiBdHQ+LIiBLRGz/3pw8Ph7e7Dx7vD 9uHnt/czNk6l/jan3jdbyfaZe4cOXXc3XuL5QI5HfQg3qE0HA+FYfuUEgsCjcdgsaaHIGnFx 8qVSiHSX5LVqbVzO8mgR2Yh+VLAO5E3aXdL5vW2e3+GGXVApQuL1Aaaw7nw7cUBHiMgLhxrg 2r1z7c6kIeFp39nQK9EVVx6xyRzkgSVADO590Dq2rtH2PrnpBm04U2AnRrRK7F+RedNXqTLM JY0AiTgYUtywWI/MSab4uE7AKIzTK+FHFVhJt8uu+VhHhhH/7X3oQT5ldhii5E8XbmkFfDvg JIPI2yKAlX1R3mxtIANaRCL1HmLPAFLIQ4wyxi2gHqjVqrjWm45uHQWA6Cvnd8dlU2ffsilx STmZ01vEMmeI3lDUQ1qMFecNACASlZJX5ue5Wz2OTVaPCzQjh4z3k37MMtvI8G0nYhgYQEfh H35vivjMB54CmB6rZgOYPuBJXodMWPBiXf5gc4DQKRE7+dO4LccHQj/drMvNVfFuGPatTwPg yFoYAAc1Z0EGGCyfeg37C8WFV1GsG4f84QLkRnZCKFPAHG8K7uZAcHVJxah2VWcuN6bQJpJO Y39M+xXJhlQvRgykOTUn3A1Va7LAMx/eRHtIogG7WHjvZUFTFTHBNPwIauR13m88oT/ZzMXK dpfsqhFk2HRRRh2eXEHKkqvnmBkgggj14CSPIDaT9c1j2BsXJjc4PyVvtB5KicyiP2RmgZhF MpHFSCbIzd9BMnW5+QVZgGTSDSDTMiLkFqP/eCI7GBMxCyn9BQjPrYQmFTmpYbnlrO6wPLz5 EE5FytPyuUHnEQXXh4b0hDWvXb9qQeEP/BKNjEp67+LcIWGMfMBYFsYQWfYVOzALNxodv+Ho B4JTZBoFrJc3FezgNadkIq5eangOkMiNmRF9gHP6KtEHvB1C8KboGb/CZEOYRRdPtgknfDou ItlEVkZfi7OrBFN5gfkFaw5Y62qto7QSfPrG7tJbLn7PkEZoqT4n7+LJ5L4Mai20lwRXbLPM ZdtxcgrR9cxlw7SPn/OlTPmm4bFd5zMdhdCicPnquLgRS8PivqS9UAuQoq0w9WFBmLrJRJld 59Gjd7hFlFMJyuEHqh+wF0StCtgL2Q/YG/mZ4vVGvkS4PkxrEa7XHV/7eL8uWLBOV+rxK4Ly u8vKsB4YhV2GZhuJo+8OO7gw/L6wW08NvzetlipNayLw3hmhKh6/KvAuzOrAuxyesizKwPvi aK6RctNIbksB9t0FSFa5LMBuPL+9rwndj6+navHGseUZNR1ez7erqK03w+sTk35FeH1XwWta s/B88fVU693lnyi+6cZJ/4Z0ir4Lq4p87p4v8qkNm1YKHC+3Nmx15FMb/jKnuLbeseWnuDby yz7FtZETpzhfdYpLOnGKD8NnOsWH4QVOccnWneKS/3JP8YH+dopfc4onUMmKU1x+nlN8EItP cW3MMpgcd3UXzMwp7oIC7lh2LIeGDJOnuLs9hGekq+/ocfDPlxtq3IhwJZ9mzkr9ZHNW5xK3 15uzOldlf+aD0KLuVhyEIRXryz0IIeqvOgjJuoPQ9A9CzfTnOQh1Aoo/50GohnUHoSK/2INQ 8+G3g/Cag1DR1QchKL36KQ9Czdnyg5CpRQehdnA+MhiQy2RtqOo4DO537cCPmuvO7QDj9j68 /tduzvoh5Ep92easknJaKVAO+ZpdJsuBvLko+fOe4krqNae4ChXCv9hTXLlU184pPuhVp7gS /VNcBQH1yU9xlSTjs57icuUprn6xp7hyyQm/neLrT3G9/hQ3n+UUV65W6bJTXCm60JwVTnjn MOe0Oau09cAqzRabs+4B+5lnNWeVdkhRo6ao09KxKDD01gnN5FavQIjhwNy1D0yBDsyAnM1F Mf2FCLD28f4M00/VlAFKStKE9eH1ECQ22i2ClUWAakYbBIrrIgk5VTGHONoGw8WhU8lcuPqQ owBvM5p6khDtUK0iuThK0sjQTz7NBkraZH6O3Lhk/i1IXUiTKibAnhIUGQxWRjs6/pOM38HN wG1DjCOhLAag7GyAcfNubqptGsubxoInkRk/4wUDOkHOw9AzNvJbN4xIHHZgZFywQoU8ZCz5 A+G71p44ZDT5A2E7gABnHgHOEwJcIHowwAMWVEm/rQWIvgHl6wALrld0Nq5ASkKDDxjby10Z My50+eJ9+WKXO8KF2SCI1bf26AzlNzwmRTeBQVmX0A6VLAc4B+R1nYUVyS3BWd3YaHF4pGtc Jp29IZNtQze5Aapa64dHDn7JAADUUIOwPZgebL0g4CTfTO2emujVteJbXNXwPZaG7Tcx0kpk bIoOCCg8NLbcbKE1LkU5zg6Mu4eMs+GHLfgBYJYKxSOV8XF4NOlXCKhHn8kyvR1VnUxtjgz0 dNvcatUQjIdOlT3g0wAzun1ZAWb8pl2m9NC8AYFHhOFpd1eE4W2tjVuTZ2buVFKHPU18QUJ+ Q3lFQhe/lNoWFLfLu4fjcXHh7Sbnebu7Uca2exp2psq1ojwibbYI+KFJn1CxrqTbFAPHWyJv r5SDQKIPLgYiAJsS4x5xI51/979t0I5I71Iu9HDOZnQBB+wnWHAVYHux4GqdCUFwJkQqpRqw 8AlK+Eq08jIyXHAmhSJg9RH9eDjdz05U4sYVb6vKcUQJW/epgWSs2tKB4iPaXUDzThhGCqc/ nXCShpZs/T9sL2/fbU+3Hx+O5yZdv//EoSToK4iZK6rfynzCBPiJITNK2fE/vKDGp8VZDLwL LqNJCumPN72But8hvml3KZSemA79Hl1paI2Ajz+TXDrUvTRsmmf/cEKhr0nifavhIuJ9ZxBK hwYBnPnV2Ceqix+OP+zvfy43Flk+x+0pOOApOFwayiMex0JvA/ImLsk9XpJ7YGeoqaVQLbrZ tRHeOneWSCGzHkCTiT2KY3zERAXkvgF/BzWPwz9dhZfwT5b/mesjuzIxRR3kqRLLX6vXsTCy 42vuFD+e4qcASXLTSXR9fgJtevwEFedA5rskMxwGWCU5wEymb0HaGEq1cjN8zmFnmclDQj3E bCY7Iu3l+Zs6IUfAmbK/9NS4VyVP6f5S5SsUGaxOBMuERZdythKFMCBniBfGRoc1y8tGB0aT zlApym9AptLCdIkyb0B6mYxQqZb1Ej9EixRrDV6f15EZyqTIUgvQrDEL2n1C43KBQBOo9YPm vAEasAXzlKpxSjVvlRty5Tw57KN0gYBl8wTiDn6eUtkIqWizpMQd+JBaOE8kqTs+ghEoeZKq 4/+GWY6Jh88lpGUGFMzStDDXUcPcCN7KQqUNlaf94qYiJMR6RWhoq2BYHcJqzu6yXs3J/cVq jmFIzRlv498V4UFCSzUnX5lWc3a47JAUaomas7s8Qc0RuuxPlaD8adQdezqDqUhVcuLo+Qtw PKGuy9GhF5fjAas7wK1q6DOoO2CNhLeyJK3myVi1eOHdlZCBv6DdxT/h7rKhphfeXXr4h9xd A3+R3cXX7K5hs47RodZ2Zj0UQS/TIEty0l3gPiEWVsW5xrGg2TM4FvpRV+Rv0M1yArxdCjIv qedyN2QeBuxueBFJofnLSwrxxbobCC3dDfnKte6GkBLzzO6GTDm5QELEyibPxfmS1XbV84BO Ktuk63gtRRMgQOa6XbRkGXRiodOUXOUzBVwrzhn9uowYJX8sZnVJ3t1wuax8R2WreCsQRX6X NGsjP7HyihNAmoLWN4h0SmqhYunsLonjSnjiH/pdwJgVFbzTtV2mqTkWtWIp8NHYpn5vJ/hb yANUZfTjVWfm8ZFihgfRkclJwRMohnjfERm+a0UbjuHr0Cnkqpu1yJ+mmtZ4iaGbyVXbr3cz tEu9VEWPEiJoJW0Qayn7HRr9RYe9eJEoQq37Dc26P081ANrHemldv+ip7vTJlz3VhfkHO9XN 85/q64xq5wGcqHBCaL9U+RwfV2t1AbRXlh3N6s1MzlA6ee94YOmjLc6fHG8uz0RWmey7S5tH aldw7AD4e0liWUXtAKtlje7bYl7MdvEToqfh7sTXxCIOXlVV1e0/aHUu+1+D8R43tINa3F3m odhl8TNakTLa7XDDaJPGlVHdKhnHAKOtHEAaoqANFE+saFsSrsphaAI+QYlqGOVh3XK3YV8N c7Ut5SA2hWEOaJqYLivQshqB7D4DXsLQS8YPNIcCCszKB8ZalFCdSg67SwGoYe1qyzmLAJeC D3Ly9tgqQORrnFeMk9tLiQgs4M5ykFlgAi0PdvtclrvelxXbvVY8NIshA2UZiVc38Hc7P32m Wbs7/4gQBvuCqpRVlbbD2SWKit27qmBT9ufYr8yw2UV6wDkWuKC2YdCNO5ohLBFyxWWe+fF9 dp1SvpAsTlJdVsXBZHGHJlncFpLFhUwUdnBfBnFUmtnznBOCGhDY0YeoCldSskphcLpJphqM lk0RR3T9mSdglpkq0KtNlyLeLBJASeZkZEYxViqnD51PZaQwr0FAAl+yCgIaNsnoJ1gY1HWI LV0YTD3TwtBuXQCSt1g0XAOWtyCAKxZBIDW2EB5U0cHVNwok7hGl+i58VKHSlohVPd/iNjfi wiNBpWeHPmlq7idwtA66Rj+zSJcnB9OkGx1/iYyf8fsC8ljexs2EuPi0e7tO9RXkwDpMf34/ oC3reub3LJEwGMteZtNSMr9pxeJNm+tmv9CmDRuKu4+xTTNY7vsllrw+nCCU+6rf5Jmrfou5 qt9cPUfVb9Gv+s3VFVW/uV5V9duVshBcb5aVnfRSSYgOle7u0rU3HGVm+4ATQlQHXHtr0AbB 7pw2b+r64CXpOqx5IORUiXCxuES4+DQlwsUChtycDFmUCA9noOm7S8KWFa5HBZNuo/R3bFTJ pLvoDNyncvAue46QqPjd4jNRCI4xZ34l4YIUAVzYPO/a3lF8CiaUGHGq+rSUJZpsinrZZQJT Ox8xldtmpR+uXbsQuOf8wq1M0KRxu3LACkcWdpcWpDtcXRLoAJ79wj094Q6dqmyR1OhKOrcd z0FHyvUKWvaY1i1PrK2OPDtLncH2FlVlaOkqKJEt4fOpmGPdmOJgeuoGontqbiFjeKqFgFxz iZ+ZDIBExdnNDc8ILRtc2vK6dD2dGm6Rpd7oGokeSwUrPm8MJtTSMwDAkwyMvtuDr+mnCqgX rN3Q99kmMf4SPlve8UVUYI39pTGNyBXS9eLKQRVrLdQ4VAmcUzcZe3Mhcp+lUyQ5+vGgZoAK 7uUJeKY5/gjrpwfswlml8a4t88UfjntbV+nyw/jHh33XeVTNbFqjztvMxmXoK8pvGqK8KobR ALmGkDH1FUllWeZSNIRKJa9qSRHqXyaKhqLUj5gsdDRbVwnaiM+fz511SpTZaED+c6ah4Jw2 Xfv7dsAv1eRCUB07PkY24ug3DOZpzqbFcQbyUUPeaY33Chm1+zLSmEoNdx85n/IjIOtrW3gt MhRhbFE6/HwR0lRko1snpzj8PC5abuaK2MRYdlnExru9URUa14xh0wuwtorcRDGS8jRfscaJ 36qCMxn9tlkvG6yv1MPR09h4Iw7jxJhL8NqgsjW7VtmaHYr0t8Z2WTWbyTJCrtwPqu3QH+Nd q15Qt8JQqBfkO7JstGF4ZtniK84w2hptYUAYpRnfq4VAY8C3ZShvXA+9nVgt87g70TOdlUzh aG5BvaYDHP/tpQtBKCuHHrdX4Bj6LwmZP1DaPCcUgoD5WiGDhLhaBr0qJVA8xcWwoN4ghyQD tLFi8kZA7/ZHevKRYGDVZJk/OVfIz+W2M76ZIB3zdfziwLN521WZothXaT4tqeA2qo7t6mz7 PjRqSvomPb5d3xKc34gZhOXLRQmYyP51KugpDqcid/xwSj4cazttZo8DEU717xpHFt6bbpXk hL3dpSNktmA1DY64lg+pzOgrNo5EdAL1NVroyOjz4Pz4FS8y6MO6IZ65QpA1OhkhRH45Shkz G0jIM61hHU61UnaeUeT0WqWMufo44yAVG44S2dhxrmTkppf36Vkg9NBY5VVxpE4pyRmfiYvg qGHTw5CtAJ+RJlNCleXSTSuQruKbzGRsT0w4aSWaPC1bveHYqFhsQP4JK9wVFWYoi8MpX8eE ayOFOKNrwzHwSMVn01L2l3l42v7ycmkpmc4Aj/4T0lIkKfNezzl+pIQX9cNmztgufLV1yeW2 C7fjz+s6G7ObD58BhHYP6gnPhtbNNvpllrsY5b7XfUST3toFjKiaixTlcmn29hLX4EOBbisK 5qCfjD61YprXUNol0xDW7dbbNKFxtpBaO451PpWF6gH/bau24/mEaTVokyGm40b2GtB85Ufm C+Fyvbi6Yz4D1wehchnzHHzpBKH4gnIdyddaBqHmolcVAhgEpjzWlhMUmAINZUUZSgDOyIHl 2RKPueZnrswXYpj5XBnXEo0rnY99J0okEMNt+nhglB1/H6Dm5Qr3uR0oPHJCh4VpMfU8Jwss sbVzSbqKH69iMV5WXaDx3M4VneNde2Ubf++d+LuCfmCc7t/5UgifqPXaFoOfaL1mZHnrNfNO NqM2bV6kHgy/BOtW55lfMNnWPu5ybHhXwP9aZ5/Uer2+RnFcqeeKaep1VUDsGXKGaTMTUJIi TEN7EQWUM8CvzAR8xpzhjnJmhrI/n0k5e444VB1OLNX9BHYuQ5aSLMnRz4rc7KoJb0XpBJ7H tW3eJvzFKzagFDnvkgUNHyC/3/sjKh3cDg4mwzzGiS53SGFrUMrC7yIXQ/FSHf0Qrfdi+78O cV2mGCL9LEd1A7UCXEqsuufTElbdm8QXb/UqjynBj8SXOQVd6xk6TMiIWFDdglyWm6Z3qmCw BDpC2eWCTLIC1i9jibTL5a67XLBHkQtPHQMSyZ4tspkBb9LVG7CmdhnRDJbj4lCQ87UEN2zb E76/FAZSDBW5Rw+TDvBVMaGp92HNaSYLItew1ll77RAL3QXdlJf01H5OE3y8S0griXDfJOVM ZAedtMrmnEs2GzcihSmGMG0usi8ZnUBhMr4ChcnmXMQy+9OXD6GcGEKrTk8MoQcgDxNDyIKf nrV9vPsCNRepaBNgVhC96WJzR+NlDtSXR08Qh8Kkw6YWRx1a6dhNXY7QNo2Qq8g4Mbjum6Uz EmYHucLMc4uMTC+ytF4DezbfFEp0m3LacUtvCmXMddxFSoRu6e4JQOh+rzAvUZo6XyJNDvWI Aq8YNQ8ndAdCWll5a0s1hII1D8d34V4c/chQ8xgCQjvGDiDtYtRd1PdVsBUTvLzle+mA14Mc gVNc9Sxg7c8v21eH0fbYrQZSv4/tt8MzheCfH4c7PxBOGjgsfDWqOtne/jYxAH+Utyh9cnZp Y7Z6UgX5t9GGyzY/IJawasA5pwK1vuJ7QKSLKoohV6x5xSgydkU4T70q1fTMAaRnjf/ctkDH HoggMdxXMlz3hxjN4x3QRRb05LGpN+4RG5dMY+HjEEBTTOkv+eEohgbX9Q7Av/Kzg/xESnpR jgb4fwfA/57xkHRS92dNq2ai/TImHwkSAw8XmAo/x9ZVG9qrKLh8/senouCS7MWJdSR/EgXX 8inOKfvtiXsGCq7FTFCYgqu/gFZScDl9c2kuPvHsB9NAj0l0VQvv0wq6uG2q2Qo6ny8HdKWv wFyx5Y5gKVRpL+Y5mLIXOZ+wF3OZPSncVyB65CW+4godCcPLr1QMR4fL8o8L2vg4blNze4fz yDi1ypT2eB3YWdEmtKzXt0maYL2zrn7gbIUJ/YAk/QqkgkgcTwknPbjidYHDJZ78OVQET/5t ffJrpAThvFekj8kJnUcWOg9v9Ym3+uR0adwpcKndK5C42u0WYb1++eTQ0DEHryFMbyY5DZKn Y2jDnUQT7pRlJUOU3yRfLjBTCHViOSbamlZRUKNmp+AmZVsz1nLdYC9b4CUv7yzfFYPVVUED OpEDBNsWqC6os3fFpksEAVk88GaOLg/YiAm7CAqYI+BsQ3gB0nbbt+wn7x+Q2rysB9AMrmS7 aMX+vdNgMD7GSFbXnfOx80xLfVhQWX1ayzCEPj3/dvxMN//WENpIpc1GzaKkXOwvu6RX55jl +WQHefxvsHlN0A9jjcFQCZDmSr5uLkxyMKVbXL2EXOfVzZfKeZChFd2an1Vq+pKQfkI7hH1t 14ehqu8YM5QuTEg3lLUS0rcIvRCiogCs4DfPHldqzcmphvK1GbOA+T1kzKbsKGzegK9kJKSI QSyd0cOuGf00Y0N9MDwKK9ytuEGkW7+8OBz9QgqNUPgkHIqiOYVdD+340tJ/Trverf/NzCL3 TkrnNjTZMZrudCsCh67RKLkBSrAQ1lgS+1Z1pBtWIGowNgRjgoJRBmNXAemUkB9bjELoVwhR MxVC1HSFEEl5Dynaqf6Rcchl7TxYTWQLSpchOYpTCHa1lwv4mlrBr+T18tlfhslFlVUNp1X9 jwUFVol0O8pwulkiW8fzW84IV4xp26W5HgYOBO4uFgScoP04wAKYk/LW7cvMDOJErUNo90Qt l0tFLVeLRe1hRtRmXJjh+kpRC8gJzqe+JykoJQObkbVcT8hax4AxylrTl7XuE67++ZRq5CHz g35p1chW6Z1WjZSWT1eNlOZd1Uhp2deCsL506CfnR9ElJxGl1S4tnDuhxPsuC5pDoh4MrnPl ugOKvWNiX+UMepUN+hWnjDLPf8oUJYNLKNv0ETF/yEwcIvozHiIOBFkcIqY8QwDyF8dOjGUG 0WRZfW5N9JWniHFf0UuUF03M+uWknaqzcDmpJy0nFc8wKkTCoLozjBiCf/Pn2w4yrBBDNlOk 4xGfiEKLHshdmtqQfWd8iSNEsurpT9aW3X34eHfYPvz8DBzed82qZBa8yabEuvdoOzuxltTj 05EGqr+t2PC5dbM5UVpqaEFwOoSEFl3BqSV3N4grBKd2dYA/qeDsE52raaJz6eC9WonN0lMv qRfaUjE0qbe0Ugs5tzI6XCuv9Mn+giWDh7U4drrWgjVqmF2w7HMuWJB8MbdgS98JsaClsYua 9pbseIezBHIZ9zUmpTJfoEl59aJ2DoTIlIXX7+4ySdEYRHtWoo3qCxHlPqMWncyjpk1QdDTN jsyn621ov2d1GsgiV8IweIg+vWbirQHw7OfytTNfnl9Sl9GxmpNqTSRK8idForQn8mZig7J7 PWTOqDbYLluBZg7aEXhlrMirErLq7PodJicPTDT7CxpjRHHmkbmYYWzXz9iIMUGHpmuH38Jy Neknh1IAyJ0hnQSsgyY6nL6DxmH06B1OhUcvEpgfkIsvrraf/GHwUy4g6VYwHxht+PnQ1yj+ 2oR70D8WhsWRfXrlqdN3wlDf+6glcCwUqCXQ9RK0BHvuffDZudnpNvxQQZo35xSFeCWS2GcB 0CPXnlUu9TE5yuN6yQe5oGYOzhXmo4BzHU5tONceu333lzk4177o4f5Su31DWtwAcXVEyZz/ yXJuXsbcAdeKzwGVRHdXSIQA9lYIiFuX+yDgBP261z/FS8X66KwGQA4Mq94CfGYePfc33ANl EJsIXUSrcsZJPNE47zpmQmZH5kJ78DKxYK08XJrpLNsup339ZPIXMZR6UrHxn08pzeThuDB/ pfmSVv5KfhHodPNrz5a+Eh192isVMSf5iU4p28HKKeUBnQPjXRt14HOxvQrGegxUfXzaLG/V AusFslfY2l2/qaO8kBPyXxbyfwLBUZ1yDG5vwn5KFxducMAzDnc4YCmHW9xdQOdcBegYBN9U ieOnSeTwAHgeoOcLyHYcLgmBXSGfMM/7cUW9//Dw89tRM8pIcE/GB7halk9+3oiZfdoRB+Ip UPkceijSdtxck+S+BxNuR3x/WxxR8U+nAeY//fHk5tlaIGP3ctWauAezSsZz1cCgSovImDtr lEN/c2HxiIF2SQU6uTb+mRRL3+XUj3nOAYOc95jL2pAJLmstltIIZGMZ0gjsUXRoX9EI7KFk zlp3n8taq7U0AvvlNAI6nYG6IBHgDmLo0guXsFuD+YXn9CyLwCGZcPEFVUS9ySsghuT4z7wC iHiAsR6xwLGgWAJ6l/J+TU43qyKdiQvBHjUVtMT+uijUmZZ6WMT+1OUTuJHx16XAkfHWl0CO jK/lC4O0aYFuEQfI5AIFIc4ML4lfZmY6xGnbtpnI9srpaEuT79wTreS7OBbKf9ZsGkIqHv88 8P51YqK7dhUGcKjsWtxUUvh0osyOxZrOiS7ybVdn0f9w78cC9yNQ4I5Hxvg9Tjb9qEKqhIXb Uqjo8DhGmvvugnGKUrKXxVVLjxdmvNsno+V1SqjR+gvSQY1yMTslq6Quc7hKMzOd7C0fgVR6 WQRS06VuTu6CMJouijmmOuBrIjGaf6aYI8DNkODQLuKRRcyRzcUcQ4gRCPXdZTrmmGk7hd8R pJEkCLW9YptoIWZxmFrKTTsq+kVsES2FL5phNtfizJsknB34eTtrhfikOwsH2XSQHErrJxnl WHmPYBrjEIar8/tFKpTVOh8NLb30RDC5WaDfXhBN1gmeaKX6IKlWo8A3slE6MmhGyQDCfgnI dxrNtnhme39Vqt3VS61Y638sndLQAd3xQPpbKtfyDPQUpH9h6GnDMe2ywMM3JZZ1ItAfTDim D6gY1rRPvnS/Qsf0vtA7e47p/eUKdzzU+UMdFJVYqm6cqDpcSqpeXlG0RYPOK2rbzDLz7uF4 9G9N6tj+48PD8e7x7eP3D8ftoVUBhPKhQbSQ3o0oeT1vIrA5QQoK4nwY++UbktQPT/YHU+OG wJEmNxPVT1bI4/Pjw+nu/dvdz4/Ht48f3lrx/CT3SWI+gsH0LK2M9CBDJb7g9gfBqny8VdIv vqnaeAgoqg/0C1oV2oXYIfFfK7WpyXTx6XQPb3hTgCO+4BKaUMuU19bQjDHy7NgjTtITwfmC 03eLTl9E9r7u8N2mw3d724r042JjedN4kMKQFd1ZWbp4Dr2IdfbhthDtSoEk/IQyh5vALYDd x3duTd9/OMdlPf7zSSs7eQBm+4lanryUSmq8I1JpAlAyEO6ScSEEFmnrLvsWuppDgELhsL31 OkXHQD6o/UpVg3y5NQVY9w6F8hm/Oz1s2e9WsDFUiyB2NWruTJn0lMk6sEFk75JzWIgMp1AO 7cpoRWZlqJP08PfjgxeW43I6PZ4+3BUWVe5Xp5wASJAtcyzzKGRnsR3BVEfMI9To69JZt7Yf k7ujN0/ZVzWdHJoIEeoh2c4MiZ/tQ4nLE3NKVZhkgdYEWDSdyubjI/Ip66BYAkvneZxSQjYF W0hRl6QoXhLoWQl160Es8tso4tnCy7KtFXA8EGcoR6itiOzcDtw978PrvfBNdxjZmOp6FQB+ 6oxzmZ6FipiyOS0f7w/jh96ef7573F7C8f/uw8NP24fD2q0Yzjg/hCTz+fx2xj3XGRfsg8EM /yBjm3b4c4xtqgL7ijRtmSHHMX4b1mcY1mB3+Rr3bYIPYzRym+wurYzmw6Xwru6bYLaS2wOF pXeY7AMgoLtcHyDFFXN9AP+iRUY7vIbo9nH8Uc1B/UJH95deQjfqC+Y6AZZWD+p3aHFTQifS oUj53tejceimfMPymZFrjF0Rdt6FjBz1BUWXXBa+AImhFS2fGhZO7qE5uRVt6PbSAThJ1l76 2SGIYM/Ih4q6h7K5/eSCUnHF5OalLqSvJT9BUSjIU8YCUkwuGYuauKjCKut5f7LuuZMzxlMI f+yyEv59AJuciSetgy+QnnEu7JJAgC5LTPWlvFbmF7ZHcLLqzB6pE7i4WR9uMlPhJkFAuCn4 OVg2h/aVn8lD1DMBVdPeSJrIFfbGvFRG2kwCYyywN9q6Sy3KU/K+o4OkqbpCWmCzHRGoacGt m9y5fbg3KE1xU5Y97H6ML/xYjTuVGfX77PPYKFdE8PRW8whC8dUpvMScbJbVKmadJK4tOOtg o2lH96VmfeKfOR6PfdyVkxz4JVmGqPRKst4UNVljSiiVTwMs2hc4k73iIwqoc10ke+0vhf62 TQnkHnjoicAvUOTmZ0D5pHMqHy9C0bwKcDSJb/TQ80mKxcTuPq5/yO7u6pH32N05XVItKzSF +ypVtMHu3sEEhzxcribY3SH/fc3u7pB3gul2uh3gePdFKeWQNwpavbuaBX+HWfDFFAu+nGXB B3lTjpl9fGQ1Cz437XHySqek+Qs+FsTYpuoVrLZjl89Ur/SaXjn82fjI6l6JYapXmk4UyWiw L+QN0hYVaddMU8s0QudgMQmPHeHDZhqCGfzxcNP5dDENEcBgSHyXzRJseWiKS+QR2jSG/XCZ qhwhyNSwGwKKSM/W4BCSbPpFwwJnK1iNFaVlm36HEMsqEOxhYmRRwSEFehq54dv4iEVGyg2i QTmcOuie5HAMvqgqYOAljysKp0Qj7zAU/JG8yCMc+xuTHp0aq3y7RA8BZpRaxI04D12t8rSc Z8FsmpD252dLBLB3Y/gEhVda87MUXtnn+5xsiYZ8CrZENQNvN1OJLMZ4pAnRmxkUsDF0vd2l p+yucQtjmJ+BJK0GV5wxJlhdw/oNLxXY8HT9hncEJoI9/4bXgl6/4ccWuXbR3obXYoYMtSYB Ww7LHTc82VRsfS9Mjwro31Gulla0Lwa0VAvFgM4FNJ9RDGhpFmVYrZICGgsBi0KeVxq2SGnY +i6bvnDQyiPmCN3M4J+1GtYLBzohHMYZLZmmpOoKh3HiPLSP9zUGJUMuOZsshQfz+Q6XIrfZ UNoXUI5uVShZ3AE0PBWcS3K9CLNFmaII03q1CHOtV5Q8vwhTdLhehClXmEfRoYtaD3WBl4kw 78LwKB/KloiwVOUEyqtgkDi55nMiANUklmEpcxR4elqszmrKIFZMLBRQiskXEFCKqc+TmqfY DPmoYmoyMS9BuRYLnUFOCB3FfWmBaEUHBqeSzv5VAQkJ8sV5KlSESj6N/ACVsyrYD5TFCNX1 zdr1r1y3xDzbuRJ8U2azV97MusKCA73ooZFHdE0VNHNop9CQdgpNP7KovGrESpxagf0dBYDH JgwrE3lnKYufTQdClMU5zcSHzDJd7pMjIUcQ/RjIMJVKPIjFqcSDfJFU4kF9ArtqnhrZNqSv PNnpmSNFtoPZVSjs8LkMw3Xh/sxFqgNJwexBVq1WQtvHmDYTjNlaL2XM1lq9hJ6t9ec5xrTm 0wtF6wkOba0DhzabULK1iwLrKyKfbErJNmXkU+vKQwm0bB3EQ5NBMxBo0i8B5KVfGuOlnxHi pYG+rb8rJD11hVacJ3TqICMuJq0lv+Ici8ggkq0pjzNisl80cpp5YNtiHjAmvFY8Ab5k0ts8 2RQHURqqWzWNeum4i/JuU5yAENpK3iXwJbt+GaXw7jKMBO8GWmacfOnZaPO2X24vWn6RZC+q 9faiC8TzF/BxR1D8Vfaihce7V2xK59X20lOXbTSvgyuSgTSuyD7d9wAwEPBSQmLmADBtvMse 4l32BQWIj0MSyeiz7kOtfIGc7E/5ReFXOuK6XS6ig3ZpC4qJalrjf4erh2vfdR6EHNuJ4Wvh Q7qAisbwzeRlrDsCY2WkIWsNai6MZ6T+jOO2u3xB46ZIjqgMs9FPPfy2PZdsT+V0Y3X9cP3K tqfSoCilmKt2MypQmVWaybY249F1+0uB7XOBXzmoDa5sCRSZTAEFM3yh7yzcYU9IOAXwEPRK UCxjNkGVaVnOJqxp7nxCXPwmjrzxx5OZoS1Wahq54qzTSqi0EaEVUVgH+9iEanbBil2u6GHg XzJBUHT1CKDGiSJEl0278wkaHrhHKRTlKy6JK32WKuSAlHHbddyD0CuUmNtbwQ2jlwY3MoXS c3qFhuEzBTfMTBVLPQwTXqFQiWSYqKymnEGtcy7o8ijIFB5eD2VVY2V0V66qwP/h6CerqITp ByUWBOgUA0EJ045JqObOxgm7OSZR5Od2YhIQ62o6mbo5JqGWyQEb7LLJA6QV6wzTIlY6z+az w186Q7Kded/Jan6xDMkleeope0M4bKPoh+m19CvaPKvZrZz+YbjsIwg8Laikah2LnjILtpJR X/Ih6UUZ0EWjq4qIRn6d14VIsXkIrrojcIk/93tYnBD4YT8Q+K189HeglcHaoNAATMjVudnn IEh7r6MxzueLNAFQz6g26iklrJVfkjL0CHBGzzkFlFgXcA3sc057sSbNNGQjVOyax2zks6OJ 2ZBTmA2xGLMhXgSzIT4XZkPMYTbERFB0XHxerVGbmeC9EuuD24OaAneEdIooIMoqRMp52xUk AoMnO9B4XBq20rqbr6rMrz9teVn+amAIVWrCYV+OnrEZIjXbY7PGEGlROX6qUuwLx8C4bDrO SOtsS+kQXt2HB6D+gkj0yoikRsU65mZUW2E1G1GpxMEkL2omnpia4t18JGb3DMtcC28EDXIz p/8z0c6pA/KF+YRB2uQ9jjqqc3py0ZdBXD1ryvyXQkG7UO64QKFgoVpn9oLscy4lkzmPb05h 0TlJs2uJLtHduqm9bUu0ys9dp5tNokmUW6wVqAByDxjP6s2nWEj1E9jrJqTU1XZllaAHFoUz /RRhi/T7zPD1nAr+EndFCxLwJA0fDWaP8q7v0AgChUjIQja9XzjhTyU0xpd3T+Y5DjTH2rXO PDeJ81J/RtnOiT5FD/oEbTMnJu9W1zWvWa8kT3gOv3yDIFxMVK4Us5UrMW1N43QqixX2anbm 2oXTFTs1LtgJvjRVsLMkstHEXAvXpOS54Zp0oiaQpktLAmm6vCLQYcaCzRWrNOVrK1Ztl1es qhn9wYeHGcc85ROOeV/qQpCJeKT2OvI1dRGm6gZpVBfBwTUpnYBrUh/gpXzTlPhbHOCt4Gpe MDwVBNeDtSlGr9gnEQbIs7LsapabfglUMoQI0LQISdq+lRm7FhPcRDVEYKbXEuTQYM9rPHXb YAULBHgkJ5WhEs/pZEJVm4HlqbwlkZFeqx73CaaWYW9icIVZJsjh4BTsg3AWtjX7XpyUXFkK z8LhZWahIt4TauifZ4quGIayw7iHfXts4WKsXkMnmNCWWNCQoo4I/nK8V/MZRpN8SWXK0RK+ JK2b9LuN/KNWtlK0Nn0akbPtYUUUWGCDqYUrpHBvddbN89fqXqbwrCevMw6a1R4WY8FK09uh aOXCwi19H+GqTbTWy6edrGz3VcthxdZf0deFNcx3azu/1v9lSL/zhpilqxov47YYa6z+ui9w zDJ/Yxb37Qr0hvh6aTSTX5UyApe9ZXw1NGqhw2iNIdby/1QsYrW+ml1hFX2Ym9737meywlOm TPeU1Jr8ck7JBTvuFtYvRCSVKirmi/zjarQpns0/PlfOasb9ur80Pe2uhw1mzoXuWBqQDfwK tiYGyFvEevIWa64Zxl+ArYmxJ7A1+aMx0lcVNCztTBbD5IooGvvFxlyCHA5hEJNtH9VOn8pL AZs9mdhzldnjk4zGxaqvYBriYLEO6xer9yANL8A0NJgnMA05oK2OWMSCcKO9WHVwGywLEBL2 +QRgJeb6ErFPTewKoViqqLWL1RvZyvR1ZGV+zbblGhyBzUtcO75pN5tPhvsHit10fsiy0GAz 6vOcbL/EM9T0lXfFFzp5UIh2wl1fxJKxv57Qn4r4cs9jD7+2wmW/Oo48rh7xy8wuuobz2zhv huSmux5kKEVQ2KmHWfGzXeaEK4R6tyLHlAcQptDqaMv9KqL3NJQxTQJNSdYMd6tAipZkplJA WYA3hoRgOfNGM4Qb+cwbjS/FSDKGb5UG5mnBCGAz7jXIMRUYF3Kbcix24vjTGFu/G9vAqgXW ON5dQzeLKfgbRGbQ88B8U3rjHTxZ0b6PUVH9qR1M12oNUyxYLas6GJAkr7x1kQyfKSayRdBZ UGSgAfwPll4RvSvuZGZmM4x3hgQwPT3D8UbCTJsCelsm11Vwlbys5OAChG4LVQv/idnB3Z1w TRLAapSd5IX40RXOx/MmcLZppbo0bpwTfMpRABCZk0c7qyLcSHJy3mKj1TkElKGbxi0rK288 UZ41BNdsVuZaVV5r8ovsaOXpG08pNr2t42Go9do14c9B6XA0X9oeRhQlQrGZHaR5OOX03A6K WoucHtWktMxtyaC0DML8MndWXQBucCjxeX1nOgTxGbpyReiwmXbeVeQ+w/G1NkIoBPtlCr4S 6Kb4c20oHPXP0Xw9tPpXBvkb/Wun5OKgvjm08IstUABZ6SwQis6IpCQMyYzq6HV+IoSaOWKk f6Ewc8LQU7sJoecsOP9GkgsjLHZoOl3bsIlYMDO/vEA4DEqAGf7laWkIzEPywb0OWebEs4XW bZYY2i81BtdY3iW6Trt8gA5kg4hfgkXdjEO7iIRh5pdg/8HNNY75F97kRtyHlhUSwD222Jgv SbXpV1xSfjsy1sr5qkq94TJt3Ey8ONjMsL7LvtArLSm0u6fKXgNhFOa/JbInta7WpYM5DZJ7 Pfga13ObyQ13cdd1878u3+jKPKPbJwAfCJ8YWuoLq+WceCSKc1JKmY4cuuootUxBNUpkq15f YujCMMsb3UrACW8utDAcCwdvdjerIqma26ShN/t3p7fHu8P9w4f9+Nf5uH88fbj76s3j8fL4 5uPd7envx9ufw23jYD48hhsff74/fvVwfPvD9nH//Vv69nT3eHy4296+2X+4HRXEf3r38c69 6Xe9ezbjuP7LX/7ArC4ytsUxEbqvHI7v3u7fbb+WFmQfrn149+58fPzaBrhEcU1aWVJcs+fB jaXQQhft03woLlpwvcNNwYvCzgMPC3O7+/DwWAzU2PQ/uZb7gbIDd/rP5ni8/vrNTePy1FD3 XhWGtvk+99vYrD/+25//259IatebP//rv/3V/50+9/DhsH3cvhn3G3lDXn+z/R9/+eb1P429 er87PZ5fW6fGH6l7wG3Ir77Z3t59/OEbe5nhy/ffb91lDi+f77f7o7ss4OXD6f3p0V2W8PLu dnv3d3dZwcsf7++PD+6yhpdvP/wULht4+d4uNXfZgTNyC8/708lfJ/D6+4ft/ff+Ouro/fi/ 8B7U0/3d48Otv466esmdIqizH+9ONm3S/4L6+8PH28fwW3cB+En8A1F4FsOFJJ3Hf9ukwlu7 Un7a2+349n77cD6CvQkvF1sS/uR24h+Y70Oxz31g2QVDj7mYKkvubFfBlKhE0VzhXXZfvTLj 0x6qkQDXKlCfj78KPe7z1s/3H8/fO2/6PRYMaZd2BEFKtvLYEPe81/5prs1Y8eHdF+5+Oc/O KB0dRaTiKAoMSAsM8QUiSC5KIF1qfu44rsFo35gGjflhqX4uc8lSUhjshAco8cIatG30ExQn UqRGb32jA7vYf3FfU9++drEL/V0tP8Yrfih0+pcv+ujM4Tc/ftwe3BttjVLwF0F/DfAvm6wC /tLoL5kl7eSc+ATi1nKJp8HD8fz44eH49fjGh+Ps+6Tz+a9ZfsWOca2377j/cI9W88Pxh+MP u+ODV1G6bbZt9OOxwR2Iz6VkOyWMUISI0brnfJCaS4oKp75yxKBOXwMIORq33pXtS0V3Mgjr iGL9qQOm04EAhB6110FJRQVok99KygfzpAae1QRZcL+rp4+vi8VNNE8xbuRALd0XLaSV1J7a 5qevXlGjh3HmMb/dK5LEZ5ANtrJg2ZEoeKJW6soKhI8bNRA1GKUaY+PVehfniE0VlBhNOWnc 7Y0JKfLdUirGBmJN4fJu5qs6SgXeLTXTXEvduNuH4VzNunC3FkQrzU3rbmebSQV6OXZSSyVZ o5fBwFGwlwNlVBLKG3d7SaRQLzXRjA+tlngiBYV7SaigujGCHvgqFeylFpxxrlp3+7nUyTB7 JZBr4JVTQgqryYvxROw8LuPxQw2HL3hhRG+6lOpDsuryaqte3W1NyshAH79yd4URSv6T3Q6v ee9BMVBWzB66ck4Qamao5kpoIbkwmg1aNKDBvV1sMyPsHtbFHubX7GHakFhpSWpBKaHMPF0I j/8LTM4OHhsTp8f/ZL6WIOgUlX1B5yUYUUCCdUZHFqOj1o+O9yXEd5paaqbHQhMke6qUV3Ti ELJKl6paQatWiCe3gg2TrSCtI4RV7VBPbweZbof1uJbtGKp2mKe3g86MRz0tpJoXS+D/1Haw mfHgVTtU1YynL1KXD7OuGbJqxjOsUrF6deiqGc+wSNXM4qhHg5fN0M+wNuRMM0S9RutZaeyV 9ief7JeDBn7LJ1f9Hv1x1g3gTcGVhk9P3LuzoPaeeXdD4T3DHgvn6Sp8G7Nes0bHq/dgb5kq 3WVqM++d0aV3Rne9M6ez/zaYnXipmJR4OXpkZMMjE90i1kWyZHqc29NeTA/S9oPW4Vk5Ue3F OUdM6T6VwaWanru0nyt9sdE/650XnmGx80medcvMvbr1KrfB8Y2oWXtGfc+YansS3RyKk29j 5e3lbg7l0KrJQaFt9l/6y/G/gr/wbwL9xdFfDP1F0V8E/QVdJy4FBPyl0V+oLRy1haO2cNQW jtrCUVvczC1yx+S4SY9+a4fpxHcFcTjRPPPf1XUT7tO8S1Tr9T6GjCqpVBE0LShMSYZ5UiNY f4GQVLhuZnwUmShSqqRoFD7fYhao4AORmMgYOAczDdQBERlnr2VFaXs49cq72kLtgJ/pUJVu JSXDk0m+YvcCSzfq3qN9HmVUsfMnGaaiGheAQ6Q8xFK7LsZ69ruOh/WQ0l/v03fYrP9WuzO9 5VByYHDvvMViaInSYDdHPOQvfYk5owc4wetv6QlsJ9TDLWxGm5jZpWra+QU223svfrKQdVsN +BAItu1vWEom8rMtoRfSzn76O+TmjqPvJWxeIYFk/z4+Y+KfYx93wfKNxiXTs93l2XnDCHjV 7RWvkpv+KFnfd/gMBZ/JRZeKrkzWWlrWnMypSoV44ijxzru261/FWqM0vur9+lfRzquumTzV 6qE/TzTI5//+6EN9KbTupuXuw6MXHOPnv3/YeVm5sgVicvmQYhO5noJNlDcEfeJcx0hWJCst cBNJqCZeuXSLO20wkyZKjHNPibSTWYN2cJ8tpDjqtt5ZceLlAyDzpdMw4nlTrekz78++sr4m f3CO84LnPezo5JDJO6Kx19/7Le16e+WeFmyinVrMtZN220meuZ1kc3XlGKDqAR7JjqqnQx1r qOqZJVScSzQ9Mq/p2b575YCGT8/oGYPpM30SnSrZz1F9jrfyFtfnHil5e8T1iekmKhxak/xz /I6ASt4+z0hU8khRiALgjOMrJH7Fa6sJ6the/xEwKvukiMZRUUvaH5an+9rc8hwmRK2WcQgZ y7sIQNtK771JWk00O3VDI3qKCrRA9bniIF4m55UhV8h5nx+3TM7ngj/Tcr4sqnSVpJewBuE9 im+VyeF+EVDAmXvBdgk8q0TV3GiXiGSXbLNdko84f89CcYlbPSU/DS3kZ7ckVLQ1w1YUrAVS nTNdCwvujC04YDS6U72w4CqzDZQjbQgFR1vjJzvueSbnBS9dOvFuFMSmkT809wl57ShsKzr7 S2PVNIYFnCBXDcso7WakQH/rg3PLVwtSOtC13/qtfLjgKjmlPVhKgig4f4SPL9L47q4QBPSJ dj2W8KcvytC34+DwlPezi5bwfgx9ccnSrI8F2BNyvQ0NhQwqNKd5XczMq2IaaWJktnC35+Tu qmJELVbFiH6BwmHjaw2mPy/da6bwrmlcAIxoIir+9FE5AwTqxJPg93yOgcFEi4lqOf4rcyM9 rCVY10JOEKwTx4m/Qso5ANWvebM7BPbu+Hja38+L/F4w99c8QA7QbY/4+fGR7B9wfBwQfsnq MeQ5z4tYEvUXcF74ste980IZvvS8ABXBn/O8qOpYrz0vIn/hxHmhHMlnN0blqyCkmnPN88J9 ZW6k1frzgk+dF7b49az2noGZ5BqXl/lHOGLuPv5wfFggJvSgpsTE8mkVk2rAYFbZgDk9P0Qs 7QpnYYWHzSnV1C6XZkm8NC4bucAMMXCpg4JTLcM3jElVFB4mhijlsNc6sz54X0AIm2uvkIkW GBVIqucLhEMZS+Z1k8kYuFoeA1fLY+CH2Rh43z2qVCsGfihj4IciBo7eoOs1SfCaVJNrUpkl 7Y9rUi1Yk6IobgpFoVzgamHF8wdgLgx83pt0xZ5gk3tCk1XmguG5Ax4ldIAH2LzBQ9TECyyP 6+wQTE2Bp81Whi12ZU4dxt5qf/KrrB3oXUGz5aIWfwj7w2KbPcWwZmmSEFqo7QIFTjEa2mn6 ifZBcj8RdhkRfC3IJfotwS3lxkNOzKYPdWuh5FqIuyZ8rwkGnM5s9sDDApuZMYsOTwlQjbOY zGJU0PMYi6lLLGYPVnl/+9bqF8fH8X/vT+fH48M5TUPjNzQVjd8D4jLnB4DJ7bqLZGYfErLF L3KjIDHIK8hSEoIa8bkyR/MMLtmVqotrOkg8d20BxEd7b8jdYedbVXzXSlD0hSRS8SWNP1kt HD9+ftqbszBOfXvmJqZ4+2BT3avZ9ZebE+t/CnOasxxaKFqxEEUrcnpnFvD26fQmvhBWy8O+ RMc34fPI3mqHswJo29P3K9IDGmTIHLK3lD0y0CrMIXtFh7ch1E0IVSB7ed1KIkv5VJJaWViv X5spVhEKwt+nhG9wkLi35Ft9TdkTNL992rorNdkqKuviIu4F8V7zusX1YT8mOfhYEgxEQLKr sH9dQ86ZWA1z1sVFpuNNHmNkUwrOp9vEiQSe2NmqTFakpCZEwWWCWh6ikzIvPhMRuJWieotv JbkbSCsDMtG+nBKhgRp3vi/H0+8bVyHK56yXDorDJevOnm/unCDbDVXwNkhimfkHQisPoJXe x5ShLvtbVLQjR3pjagsqgDG+XqdI9P4WFt/IP6Fxjo/xZHB5vWc3b0NLuQFabV678XMmlenQ EW529APvNaRsW+ahSOsuEYd82P1tPLMrDc2T5pSVqvHgmMxaAOYUc+uHOL0Q5Uo85HKvvj9q QMZZTQp3AtHEzK1cGGfJXKTEcgrURU/Cb9ZKpgOVDd5K1xiKvUGu01ZR+suf/vo//8+3f/n/ /B9//ef/++1f//kPf/7T23/5t39/+29/+N//9Me/zk6pHoAl59u/A2vX2ikpGJuH7G/o11gI Njz63v+GigSfUQWcnc/VC8XWXztVGYZN3fNsUyMs4uJ1deiJpwJurEcQgHW/gu3uWxjeIhpf KH+yox3lZG6AYa2ee7mkFVBKBD4L4hjb0zAIGf88iYwcUaDHi7WYSHMD3S5ZtoceuIpA1BeA zTPIy9bcR2MkdixOqSgOrfhVw1BXtEZvjHMQMwwiqdaooSh81EmOJwUUFNZDo5XpFM2G06zj lgLa90moVpDmRBy8vmN1/tFcY0vhE4aqGrzSQJVYBUMqpSgpyE3cCzy+wn4+mbJH+OOPqaRx Pl6o5bsNUspWHhq4LisPFdX59oEJ430mMBWhv8FJ4OuIx8EQYP3YiRk1O7QZxkGm/vGcmEDQ Gvd/BphYnM+8MaJw9ALJgPp32UtomwgXU+LN9PWWfK/DiWKnL+7r8drOP7+LKoYrKIkKRLuX O7E1jiadBGvGDCCC/Ii2LT1DzNBhfpUm3+BsrMbk6pJzMMvIw7AYZul5GeKKpvMeVw1rrO8v fRxrjVFF2Mwkf8bxZxU083BC2EyDYBKl542SpBYu9OmPT3R8+nnztdBN4Vnp2wTpTEnhIBrn bHYJQP+awf41Ogx6fgmpTddHHMq0BUU2l2lzunoceFf1wX4Kl5ADhXUw7hAVsnNK0y6MSHiR wvrK+dTQfbxaLrV/whRDAMyXfdJMwqmJUGk/Jk0cQiD1gHpiimdNKpNkSh2+PGtHtYzOK8fp qAn1mQKixUXvg1gsjMslkTghZwNvzuqdDryBvK+eIQ7Cdz0jH4bv+Hz4Tjwh78sqxJ2AXcAe 90C8YRWaRDoDs77D0lALhFvwlGGUftgOpXiTVCvCuZHFojxU8UNFFwBrW8kB7o0IW6tTZ1Vk cWbK5IdMw/gL95Nio2Eyznw0e5qd7cPfxzVqmQHf3n84n5w7q1e1LFcwFt8mLrtodkOdMpo1 YhMfSNZAeAo4GzRCDe8+vnOtGRvz9vGDY2Ud/zkzrocS0ZqyeOtOFLkgBxSrw3CGqnLmIa/B NNd+WgD4uWNyUlezFg56Gm83Vkk2V32YNJ5Ttc+gTMHkBLVAhw5n2+RuSbAOuGzPp/ndomv4 h8fRu9Mp1gF1zqNwpnmhnW3t6lQJIlumA5TI+QM4M+BDG6aZZeHGU+PoaivemVzXhwv0U1Ou 4zU3Yq9u0vIOk+uXhRNuh4PLwZBRvJ2/f4AZDA/H+69H4Xj+senTS+0AnqdTw2kWa5x7jpR9 CgLsb6Ht6518IriYwjRknxlw+u2jb2J7t739+T+Pb9+dHs6PLYHccUQGAz5lfb26KVjMUdU/ GK7whklY3HIeZCMzzxMbSs+a7HvW5FJxU4mQUGVhyFdD6mSqNlVcTX6Z+wSqd99PvZxPJtdA uww0az5J1K9ZN7c/Bsr5fH4VbhO/Lfe3eMeBQbGugY4/xRW8H0UGLPGOZiw5Jf3dm+jH90FT dxg11Q3NkesA86ZeMvIOG47L3p3gZ/Dc0tBVfy6Yr6HoSHHkJsNy0JEOl4l+hXv2l4lYRMuq cVr1wGm0am5oAaMOprbmm6bOmx3EweljjGk6kYKkHaL6AX1X20vh4QIUd9ll5v3opYsQGhyv U9Hvw6VrQSheuRowcM420yUWBLG1zZ7OsIv0rJk+AI596CrKZt4spYYxBvtIglOkHNisEO2y mhFGm3v7ishNoXlYlTx4MVKOJJwRcMDkCUgRplMa6AfjP0A2jdDLzo+3aI13snz8Cyjd9O03 c8X4D0V5c/tZOJZr3mYd1JvOICHx0VvH0IftBm+Lfdi5KWx+YdH2wppZTMSAx3hZnXZ3mUu1 axUVXbCK7RJszeyancQLrEty8C32PQbnjPYqKt3ULm3vBNINN7OCXmoxGabVQMwTnpaCRusv Sc8LtlgilZObLDXvA0qjktEYVdn7IHIZqKuN7nTEbsWdlQbrlSqdsOx51fr9xJP/wr6gtDqy ImKF6jpFRG06YaEoiIDEXxD/qI7++Jrd5XWz+ul9EeLdXQqe8sOlCPoSjpmqEZ30+2NyPWUG +qEItceRAy7v4D30wDlthnaQJvliTYMLflmUpjC5azUFIOYMm5Wahjf8g4XPH3kGz9m2Ff4N bGg4+EEMdwiE/K+xG5b7nS6aq7HahTHQcAEghejpFKyvNgUV1N60KfwFYDO74Z07rERrpSdz vDpyk7N3HpSstWnGSNhhKtRHWBGYsKRtKUzCfJiE5TCJoP3w4jgPDtRt8jBJXulwQZazQ2FJ 53JEiZQs2DxkaLhYTJ+JwSww7HMhOjcR+6xQgeBKCC3kc4SBIg3nEwyunE8lSDvv/6p2URuk bWvkzXpUDsijEqtCnBaEV0BUnpT+JeX7yVFkEzSVlXEgGbRBvWkgYEGE89CNcFo5uUu8+26Z uqVjNmUczi7g4HG3CywyUIz6Rv7ZoQuMGrLm49bXMTQn8s0enKtgF4Mfh1vIs3gB8TTZ9Pts C3G0zeLoDhu7Xdup0PLbKn3c8/MYdpPU8QWR+UYUHe5PEJkvQuvVmUF4rdIABbOAN8AhhEF9 FP5PGpGc3bt6ievxyiikwdYN8Ka7lBQziMXRf1+7W5vn2yMhIk+GTTNWHfaIMtUeEXmPuApz 4xhWVqsTRXCvnPBeOd1WpKSHk28P2eB9sfMBWqCrONT9+FWesQRk0E2/QHV+Z6c2AApEwxa8 3q6dKZQA7OplCgugQ5Kk9xSkdvrZFA00RLNIZT6xCMPHGMCIEjKBERjmvfDZXJ3HCOR8lxfC CPjlpwf/NT7BlWQGuYIryZbcntNAB7lZG+BPOLVmgL8zM/FZD24Z6sKtQHEe2LxxpzcVsiGl VUElfD4fSRu+wZZhWNPxaJKoRmjQsPeoRijYK1Y25aUf/fhG83QbLEi6Tz54YLgHWIG7w9me nnvDqBjB8PgjWUF5GE7Bibv2aRRIYRR0WzgG2annnXUk0zlKIZioBCzrC1ZCsWT1BnxbsvYk amgon2+o6Lk/kK7wGdwf3vPRdjOfSyQlttaC2WdWWF126XdL8o47a2jti8MFVeqFG4OhjRHL 9453/JRuBFV3D1XV3UPcK/A0AjV/4bEF9pi/AE6ZqA9oo9r6wC4sedHaSNVee46dlZS4eZcB ARyRg1GjZl9tJD6xkTTeSN6/1dlIqVWzNrQRZDNh/o7bTnQM204y8KjEm6Y9E3CFJgezw+dg hd6WMpHNXwA1nGf9MiisU6kaKbt3Xo1Q5hnViEMfaqiHl4MalrYwgBryoTqQzwXUEKHjK9VG 0yWdRmbquOW9Zu+g64soxo1W11oVAVusAbaYHvBmjj9mbPEBYIs5aQCI8w3+6RJ8HH05wc7X uuUiqkZmgv1u7BFtVUGei7XReohbXqnmsPvtXDPieYmTMd5+6Gzn2cBKay5DgvwLP42nAUbI VoVliNAFAtO+7u74PiILk6NfzmvpQ8R1IetvsiA3RQdUWXP7FuHVs1Kg5g8gEFfh6Tgp1zVU D/0JMms0A8jLMht6+QFlUbE4GpShTnU0yKBoELizigaZxvi3o0E+ky+Hg7KZ5l8zo4mpYTMJ zbqCjDm5XANOJoPMKkzYM+AE5/LRGtAeD+KRuuJQ8vA7wIC0Bn6XjHlRwyS6evuSsGflhmmq /D0Vv4qKzIc4bSSrtFQIW+HWpGWI/r4LvyG0iISnDpY20VzEC7ua6jTA7aVwNGXwk4+kMNJx Mo0S1zn4bh9/9J8q3WtjhzFxiOFioVvNjityq0FGbIZT1sY++u9XduSuguBnVFp4y4QVmO9Y sUQYKZwbIPHPhPSQaMKFyXDx3GyI5VjthGcDxMFlkppQMuaDufRrGMZrv0Yoz2IcdTI4J/Jn SIYwpnPCpSja6U8jxOdNF4dD6hm5gbK2GKHCyAVD1LZxAQfTIgMXbAJg31acE5J1YJyu5WVA yEP2YzxoKNw54NfxWVV6avzP3r605aKgWyZPQlpg6yeBz7TWN6teDE+bfWuYbpqB2TIZLrii 6QEaqM6sU3MKOT0sZ9yBWo1eYHbTynXpjO7g65L9hS10y3uzLb037AA9NeyndLEQEHghb7On xlsj27anhpWeGnZAOyBHN9VmIjvXiLavYBd+ZU+ymJb7cmxcN0+fMPPIL/rkZKYKXfcPmN1k RdJkVavsKENyjGOvWBYnbrtk1KEXl3PWHtm0DeK4Hmbh8zbNaoPNNZclFJTtxYo0AgtlzdhL hM30tpfFvkyBi2KrglMn79TqgE9C1KvVXogeUYQWPJ02jkdVgKJUwF0C5o+Jwg4FJGpLzpwc A1we+lJTfJXGEymYnB/weWA8en6lZTfSPIwnQ37mYDzQcdmG8Uw5Lg1Z6bg8n57uuLSOLei4 PJ8gLa5PqzMG0laeT7jMoQEm1USn48Kc58c1hsGFuV+yMBG8LE4p8qX3U7y1R2joMmEYhlHN vABUmH21OZCSTQ1kqoE5CQJL8nQ+kpeZLhcPpDb9gfQyvD+QxqupkkwMpJyffqUbmdvxebVA qxg2LT/5cr3SeqqL/Pfsf1YTODMr+sB39Lzar1f7NQ+nBg2MnQuAu2p6PAvnTnJziAJQmuC7 Zn6mhkZIG+LqSB9XRygG1iUvZA2sgyqEf20zBAjxfoaUPtpLy0cLp06aBSBA6KNdggnETbft 2kwMicbvTe7W+feqtOeUIjjBPKlAHuvkvPJVnPDpXvRKg7FRyumN6OCjNks5tV0WJbJS2z1c W9F8Z6GzlHcOG+Td1e3hsKC3Di4L+Na9XCxiRqUs9upRK7A0LYo8omgzkUIz+JbKZs2muQSy irfSc0Ri3srILwkoKxMT5QxbZZOrsstUGXkqhwZPZQg0ySnCRFij/TBFHB/uMZN89PkUM8XB u29tifhS3bcsUd62buwzn8JZDnKIi0xyReouE6kfzXpGq/mcms2QU1pMZ7jamM/wS5xQ+ZzE o0/lGd0/nWcUM5ayJxCPonVF6PVMpIhW0j78NGrS6dWWim08jUfRvcK0UGNk4A3YWJthsctv YcRKSkUzyahICekyKlKPf6aDbjIqjm1RNaNi/iopNTYNwGlLiBcB9j0NXZGwtr80snOAf8wU RLJgWkxx4J/LoFhyrmiUu94UXP+wPET24G2m509bG9QhQ6/lJqKE9bmJ7LL8PNxE6csruYkS mxuK1dursbu8xU4EUdfew2GvxEdEyaZ2gnuT8npvVvv1fCo37ASREUwBN43tprtcQWkPa5xo mcdpn0bEiaNhCeFRrtKxRiJNAh503ZuWQFnMn5Ra+1L8STRRmi/mT6JEPd86uXKJ6ILjapzy Kmc1jd3kYQ1wXQB8Q2YRT/ZYfEnKpoq/cTFpk5nmbKJDika543s2tVNsJl+1DGMEmjWxTAxY JW1okutjBU1atTGn1tWXAFhatvjYZp3Y6oeOFsqsayJMy7oiZpw0Vp7Pv0XNuEusiJh/C8cO EjJc1RY545AJbaltVlnarMnUTEZrNklT1ZWHD4ft4/bNOMXkjXWd/JH4Khxuyr/65n/euWeO h6//n68/PHz9//x/v7H30AHe8+/H9x9vtw9fHy/3o7Z1Hl/79eOHD1/vTu/9zaT9wm/tC//j P771N1F403+/+1/jmBy+3m33f//64fjuOG6s/dHfyFo3PlRN+KbXSf36m+3/+Ms3r/9pHLr3 u9Pj+bV1Xvsp0O4LHH7h/xx17+3jx4fj1+Nof/3h3ZpPufF0ldOqBu8/jKrs3aN94X/8x//v P/7j/+87J+G9f33Ynm7Hf7lhON9uz9/7m1R7PMf3+N91+/fv/Hh/528yzVaNO3u7H3Xsr/fj 585f321/8KPO0IT/j+MPHx5+Hkfg++3H8+Px8E2/jI8vzfMH7yLLpXnCha7vZP/hh/vT7agF bh+txl/4UIpfG76U4o7oUzHP6VOpCPaudrI81aein+xS+Ty1XJSc9s8RiQkIdVkIxdU4GTB8 MJdNAjcp0qjjguq1QI5CjcgUt7cVQBB+XqNCLK/IQDl2UztfJRmGVoCpaFah7IJmCXQgX34Y /2sXb6jJREXk6mPfgWCjjlfAEasobogDeSmKVSf7sGKyukYkeqO9xNNHooYfD/0hg9y2l3ZR HXs/HVpZFynjLH0DjPFQeV7S/CJksesGbXp2kgHr3j9UPS0sk1zRKrYakK/ZXYTTIhmnrF+X Y3xaNBh2tj2A8ni/9B8V0CGmMCoUvWt3aRDsUXdyVKn83t3nBn93KXeY7RvYPCEymSB5Dm9L KQtJoP/F/UG/daDo13YblQcjOGrjv1yghzqKtTc/ftwe/Bs1+sss/ktd+dzUX2Lir6nn5Au0 5cv9S/xD9fbL/Yujv9jEnSTXaZw2SqjsQv7HHzVA808JJQA+L5CCqC7CDoPadw1wOk4U2BUg 910vMYBqZkMOox4oNrjOMG3kC+y6UnBmtJjpMYv13GKK00YKC/DoZV9wsv0dOxlwFSCvsT3e wvyowDPrhiNO3S6cUk72Kp5AAODMRvGJcG1/Kbl6S4bS/aUilxWYfC+x0nmUyNgI4RuRiOYJ NnvBB4tiehDRSJGGgXwaRfHMn3z2REBauk/zRv+ThlD0P3Z3bE+zuxR3N5ET+jxzxVMqYMrV rSpmhMQPqqRGlbZhGjMu75HeTxM0HVE93TdIkas5gjWvRFlyo8ymV2LoTvFQzRQYwzN2+WTd K2pOssEHnXWZCAiFA5SWJarNxaOyfB+UZcxg2XRADVGZxQPDG2oTsAFaRSLPhZsYZnmBR1P3 rXRyRjlqJeGtGohpcN08sKa0KSf3cMkW66Whk0PtVnGzaaqvsQ7zJdYjjGuBN9IaJwWeEEVy zi5pkyokIXh81q4AfhQs/2Wga86njskaZsv2KAQvrfeAWlhefrxVLy4vf54tL48hz4DqbPyO WYZdrkrQn3MJ+rKsJiEIVjvuUeUHZ1jIkTDeWmJJFnEk7POi8HgwPZhNQ13AF+79gIsy/8st 2N0RvE7Fgpkga83dFb6piyVfJsrtLuiAidl2sX5TUGUeirzH0cDbjQZe0IHiI5LXFRPiHfgQ c01TQFS4LNR4ECa4LFVqzt1s7dQ4nhBTYg4pAD7+O17xczk+06LYh7HRJDQ7uGyqNCnuTv1+ ZZ1bsVB0kGAZuu0XG6tPcxIe8S+HqV3Aj5E6ANnyS89MoQKFFc8G/2pQrjDzDqOqIC25ml0m ii4jq1E1qUiMVV3ePRyPvjU5bkGLMwfcWUlO56XJtQBLL9xvRa8mzgPBJ9PCysNsXDiQ2k7r cik6g2TcqUEDD6Ih7vuyMBARDbeOUkPP3hgnOEuSg9sejOkcYSq9ZjHCNFsPz2rtm0r2fUZF FoseWuzJ6sKkZstlWYmKt9VY/A0g70IzRBYfbIkOO6GuhgVwuKxTY4PGhyjSO1orNB3b+nk4 VbiYXRxs2EwbTz1bkU/IxWAuMn9yx4w4X6jmW6cqY6Zz3hHooRuztH3WpbVpmjTBi8tMG1kE dmhGPYcCEB5PXtX1jhtPzSbSUJnTZXhSQkCBAOQJuU8u25lbQ03d8fUaO7bDse3VJipNx3Ed OKZoVYPSz4/3wfiXGJZqVrtWQV+Sz73wFBMFa33bFRMac0OQ79sP5abufPqOSr723b11to// Tb9qJgHzHPfMczwlwVNfQFMzUAk8p1rGmZR6fnmpqRjCKAGTmmJoPhNiF+zqK8+HQp7mF+7Q im144Px3OEFl4UELCOXFVM0mM9nHV/iVFruRJkSD8EuYZNEQaFpEIRvEk09AG6KA0gGE8rB4 wJq1Bpq1PuB81bZEgWWZcJ0oSgEaflvkMY0/0nk5LTe96hCEFmA/7uGRvFX+GSyh7B4OcyIn 1zgfVskON0Kl7Ch/MWUTlG95VpNImwZ9d2lUGILRrwCGuj3e1fN0wCleJWc7LCyP2LC2MFRn yofsQQ3KoFUEUMXBr1uPa95oiS7P9UVLPuXE6aFRHYZMwEbd5gpznjmCbigOD3ifDq0kmg3F a4wftFwLUDbBn1JZIj4UOQfM+LUgWh3ZXxrbCcrTPGY7/6FcFmSRPCS4Nkvlts8YdB1kGfDE 2WV9QxA3tn2lf/OwKQrkwIpD1Ubxs/CJhbP2LU2WzivzgrKZTYfnCZ8Iz3NJlobnfZEl90An PMYl/yWEx3xAiBkBjTqY/Dh2ZBYCySW5DqAQtU+ea3HHEyjYXhahYNoIBd5AKGgxgVDgUl+B UOBOM07RU64l+kugv/gnjflyzT7jX9Mto+gvgv4aruutwn/pX3U8nyt15XPyE7cT7QDFJ+5E a0nRX/n8kSufu3J3SPyXWorxiHx5vSMzlSx9TnXBm0+MVcqCacf9x4Yy0vZfIi20LKYdNOEM cwwqFQ+Uzt/F/JhQYjHmCNbhGPFd7+P1K2EYIMMug2LALAgw6T2kgGUS2nZwbpFF4l+zFryR hgGlwvWnK4dfGtrde98XWWXqvowzmA+N0ldlVSvkl80euRm8gGg40YHj6XyqKxdDdqpOOGjX ig8lPzFPSIXxLceviKDdWU+/NSJn/Q+IXKbVfUD2l1X6rchcnv4AbaBvYvDYf1E3g4R2ONNv bfc6dof7uYEDVGErds2hbfnLC0sv+cvRvQFWkCvFy6Fbh5gBBdR2G5Y8rScDQsCpbrjhs9e9 16L0GYzuQMPdnqj0JC2DApdGRmaJDWE0iV8kRxxR5OXDw1e/v/zwg7W67f9qv0DofTCUgKD8 eH+OjxIkP1vQbnhzKlE/f3bd1qVf/SXCh0YxTp+NB/wuGlfomz5QGUOca6W4Rd2Clb9pWZv+ p73NfXl7v304Hwu6muzfvyE4TZ3x5BtEX9JpnHTljNNST1jFDPC7olyMNmadCedmYELPmoS6 BVl3Be0ocxCTsMl140ivLD9T+vqZxE7N6iQeh4r4b9GsAR2KPIyIAQElgnfh9TI5m0SKs8aF x6l/s9y0IsRB2eGswUq5i4ff+LuzPz1otTc9411xjQOGyCNgiOQabyNnVAMokob1vb1r2nGJ b28jRiestrxKE1Rm/LrLUOC5CpuqT7JbSIwGqJbcwN5oIKIRR98NL3+ByLC0BSJGx4Wrbp03 Q2vski1YPhRtltH0TB9B0mQ/fSQujl8iAFcSPCTUzHrcuVlbMPPwtFo6YXE4FzgnQ7Nk5s5D alxueNgTbL6Css6F/qIK53neH2AtpAlQl/uIwz1mekHA7Y75Li8tMm+/BbUXNZzIzWQ1nPEO 5SbBgTjaVXFC9JDnkiQ19ks1xNU5FR9hRft3KTTomcSd7+73+9tMab8LmfgRVLz1sGROdOxP Wmu5Qz6SSn1/EtRNlPe9z/eNLzSbqhhN3Dv3SLbd+lXjXLacAsyd564xB3zhuGtqGuFYEboF xHN+OW6rT04gOyPuBdbr3NXw0hLCwQc1uxML3OwUeJMPi8Gb0CLogDd79TqtcPBfM/36YOMk ksb7qi/O1MX1EzNInw3ByrUOwojOVT7nOpDX5Q8UIPGnxRfEkDTLl4orWOjjpsX8mWN4QyOG h232AloULacU5GtYZgWvheb9O6+J6pGJMP1tiGhkLvvLwxFaZO7nVqIpa3U4GVqpefOMCG7M YbkkhEIYQJ2MBQGH6eoEZXAlFhmwtQp2FxxuqSoTgPBKVZhgosTGFqOY8/mRhmhelrm4bFFf IkRKsokAlcv7lI+iaBufeIS/tjHUxnRQ/+ho6JeNGyWP7LN0jh9f0PF0NL1i/BPCEC/T+TQB ESgavqDekcWIalRuqhxS6XiEJUT4CnQjswUlWoDlJfk10atxPjXEWMNd00h66btbgs+2kGid M2J3mUwsL25uykqcekOXIBYBKKGZbDZ5jFEstl2Qn2z6TlXN9SdyqsKWNRG2yRiaXyLNbULh FyomREgmR5fvpAU+Se/qouUGqos12hvvsjutWN+0yUlGC18Z/Erh6Jxxop5PZQYFx05UyvrK AWUYn4R3IC0h4c2mVl5UnO0mZvy9y9ynaBHMu09p6T7Ns3WVozSwbsbOVUNaT0Z88nxa7SiN ZxgjctaMZnRTpamuOPvFsPmSYi8oNpGjJUhQVIdVb/+8UJiF6p6TXDQQ8NVypxor5HQYykhg kCZ+zZUbtqKCWSUimpES362y3iD6qG5LiXqMmpkkOIhyqY7HMkmhHphdJ+RSx0uSJRWo3Sfj J/WRD5vYi//EiNhd/nICZvaGEYubOrMVsUkfLg1rNH0RbcwoVrNEWWS1glZVYmeJKcv4M8kN tFWSt+OVo4kD2OCCQdTLFquMdhLEZ5SNKvemq36WyTA5pyelgoj5PGAC9UMAcu3VbhkFMynr voBCoTaz2L+YNzO/cJZXOU+x4VLNJ6wl30zPSrs8vVRd7JJ8UiF0/4LQNz3MO9OZ3nyxsAMi JqgPmgp3A3fwUucf76MAaBUKzYdY9wNYkbYfmDiJuH42mME+6XdUyCaO284xFQUbyETSXZie YUI/RupwB2Vw+W6x2Xsu1WTeBkzglL0+ymCNmnyeV5OFfEE8QTqvxIJcFfHbZr9qs8u+u5hK /gybXU0YpzX93nNs9k7Shtvseli52WXLLEWdWmki8yKgvNxEXo4leuZdXqbzvMwulwsCLLwJ 7iwyZUo3NcgoypHczBfBKc5REylHw6kdJtAxhuC6GJgwRlLDpZK+EJpdOrtHvBT/tk/sWjMq mMu0aTFbTaRqujah5M/D5btGmnsi+QLZUMxDqA5Q2+RA3Z1vMs0J3LBgmQcuzZbV69TKa1kw VQDEQjtUaYCt8IZQgElYQx91PVPUSxNDpWkT8xTkmchMFxrMZBabBEmj85zrXOMstupMBRFm Fh4BRYJvCLAlUsVXD8E4Fdmfpsj+9ICEsZGb4pPe7to1UkRvSGF4gd9tdmA0bfDvvnu0XIBL qA/Y5nnW23lRzCR7XHpUD+dTJxZ7BbODxXIUWBAEdbnvQ3U83INI/5Ymi9NyxAEnV5jjtG2O Z7hTr4SrxYp4YIbaFAVgwOLgg55Hf+GCtgevA4SCthB0MWv8WuTMphFprWQ2uEPhQEFp6bs7 odpjUT7Lzf9xDEkDBT4LB4NALjr4sDDZdNdUiezyEEnhU/RI4sYAZGAJOFPAkDyn1e6Y1lyJ CDPfgXTJXgA9ppK2QFrvw+qZ3VbGxQDyWIOy5gnumAVdov3iLsr4msOM6xr/6bFijrVrZknR VHAtVUU6Bp4biHNDA+yEvR8JGjNdeX48qQ35WuDgA0Bf/EZH0hKHzsNKnVYIIE0ZpaWnu/7e z67nq/PoHf9pCiGdqIB6gIAk0Gs83VB5PUDwJMK7GRZpDs/qZmh3+a5C3cEbObqxjceL/TBe jGjMQoaMLFAYFVqSocOeASoLcQduLazAHkCKCTkv4YZNs3ZamE49wW9RJVSViWczhYI8LjoW u/qvziZxxQ4j286llXhMD62H3Yie2qWEtjiPattEIqQ3uVP2BEOCC3wdckl5KNNACZsrUMIm T4+H7DttDey2PRb5oD4546RR5hWI/H3T4+tkxja9AMG3MwVC/O3HJLD3Ge7HQlV1LJbzDf7p YP55iR5u8A/nzbq/YC3GLgl80KXygAXAFyJ5Dwnf6/C8hxrOy3hBarTLY+PYIr1Q8TMhB588 QTtnPIBqgkyR09nnijRyMtB0YVBzhVOux6HoeDEsNa45FtyuxiE7FljMogFNmwICs4iCzzjg 7GSdycQRwwSJK+NsKQ6YZftqFgdsShzw+VSovLj+pNdGwuz7fBQuJnDAjKslH4hCh8/iEBgH ZcF0odwyzuefVw2d/HxqsoAGvVrSqRAZs5De2Q0T710gVYechVPg0JlgPbPmj3/5v/76x399 Q8ZZCawR/LsawYkzyCwDBR1S9HP3iN/7t7u9k2FpClOmGTpJqnPY1bC3EFiRhmpu5cteUncY NsZmh20Qm5XkpQykb/fIS1lmyZ8kL03BZGJKcAyZN7gyA9m0wcUWWPa0Ybzp/CpPvjyxY5Uk S3idU2x3nryX00wOFJ1+p5zOZ9c0KBfw3TSTXp+kayYvUGqErAY1ozuZgZ7kj8mZzEDSKECd TQbgPBQwPVWBhMFM/tnsssMwkw1SQCqd2+b3+b26eQb1WMhNy34K0pC1LKFAI5Qy7P2Pzjz1 hkd6Zc/6IQakqM1TnospL4cSCzadSmaWJbVG8d4yE3FbQouLulmqnTZROMdAZl+do4CcGsdD U25VdK9p2IOzJXv1XDW81aLI5sP2a6gwSeZIonSLI0p/+goqAqZiaejK7lZPKfJ043aR82EI mcQ3LYzvIK12F0S064FPQew4VXSfec9sLsMEq6diDR5AH8r4++n+7Ye7IwxmIOA79ESDtlgO nIofNFw4XIoKLxXwuGjE9m57+/N/Ht++Oz2cH1smdkUKkdhM9bLkLIC74hVT7QUyq4pNAXUP EcZ9GZLP5l/O/PTBdpXKoMgimL/vBfP3JSPJfgJY1kzbqDibu0D++eSOAuGdPew9pYjqobGW 961A+OKSKQ1vd/gWKV67v/QwBvsyfrsgZt4ElXeqAVRYx370DMTEDpcG/AVMGKNNLPkZRc7Q uw4dKI3dIi7b10fCOQ5utoLcfv22ntjFyWO1BdSkGqaaoryvXIzSi6io5ruXShzq8MUPHK/R t8nLMG73TbFNdqi0AivIifaXqhxi3gag3MIufdHKAj5N0bEChioLv6l3EwOFZV6pomazuroC W1Bdga0zUCi5wkDhqfswdRvouzntroqpWUjG7bEmA0EFepzznymFzNuSCQHW7EAsCMlXLRFT 0qHFoMBqbobLrFZk6GbGJYUx4Bn3Eo0c3i0kxOwhM+FTiljw4SqnkpZTTqUk7OedSpq8cHJ5 0DGDqPnEzBO+0A7TDAW4zqWR+Kpggmeg/kmG7gHP8namYJB9gQspkjLFdJpKQsxPvCmiSOIw ZdqE4JI4ZPf4beUeRzgGH1eSwm+Qoc9Vse1FRas4FHsdxGoVeEq/WGnyPpcDoAffWZXjOcEj 7Deka5Jq8dRCx7HLeDjna9vsTE4gzsLDd/7e/kwNoIS+LYoctZzxbZ+0Pb+gO7TEj075rHn0 WQOhCgRn9A8YimRmZbCGHMfoX4RhxGMOBfoFUsExU7FiL8RrfhMBc0+9Ubi7/w4zDFFA65sL U7nr3dOnipxAZ7CZx2FJPu148wJpyr+tuccCAG/EhMyLTdPzvFx6mPBvME3mX8Abjm7oVwB9 idAINeno1hI0QM2DcHiLsKODubGRMi/ZCsyN38fLP8uU2TSyRtAyP5z64BJsDFTAku5ZMI7e 0CiEOnsWHCCwhPjFNEwwnbiQ4tyyFstdWxCOwwoLZH+po/ZuVuSkIwt6+JJ1ApWw/QLvFsvr zg5sghzNRwI433SIvCpxAVgwPLlR57TK8JFABuU3fBJmAChYsC0hVTfhXHxQZU7pNJvlcVBA QAVQK7tnjYpGr++p5K5LFBvXO51tpdbN4sqsUWv7JRdhjRlks3Rs1u/a55Zhks1xy5TMhdCG r320L0s0oxfzzCQH7DCf9qhzESUhmCgLZJrePsroQL9LCOrCqxtGZ6pdTpXcLEpqViU3ywHI 6ZUU19wMz+BmEJyDWfLxzCddWi7GTctu5ocae9SOPd3i+HA8QUwtfkeD69D6FmvZ6PMQwIFs +rUMpapLANuHWHWswnPIQJARtRUPu2xwDPkQ7pF17vRIkyyryo8Oy7njskiiZO8giAV2ZkT4 MMXGxlDCPCjHDux8r+6mBLZg5x9QEn2w8/fouKvyrHMoAdv5KFLI5LydfzhBQ3+P0hWnLf0h W/pDUSNVerpAV9as4J+rFkdJSHeXF8dTMojjC7DVBzCVQeMLcW1elw7GiDNIHglenfux1jJH VraHo9k3A9DkHr9b5VVRLQJoYQMcW2lglxa1U2Pg+FxvShcosSW6DkA5c6jI+k2f9fuoKGgA unlI4xoxroAN09JVzm5miHCuklAA4qBaNjl2Zfl4M855m2HSCee8vRRx0Uppvc+6b9g7nvqR F0DnAwY6d7of4vyB5JWXKGe+xD/lq1MesH/q0EyX9YeBGvzXGIYoOn+Tfp3z1dIPHP4wM0+x ACRUt2PHyaFwb4yHFgSuFR6YHnGGQW6ZMAL5VFgB6pDqCva9KFSGvPOz4pd2/q7a+bt65+8W 7/zoS9tdnsuXdoUAiAYnWxAcSkD3ZhJzOLxiLadwnPozcNOPjnKmlxyvqZ1qfrlq6BECGZ79 lCJVsYPAfE3uqy1qyVuaVWoZnW9Z8lVBnRGmGrF55Js0m5Y0DB2hLbEWuyGRDEhVqO0vmylZ ZhdHbOECuc7YRDKUKWxM3cqYIC33q4HKY9+vBYfWtJRx0lHGe9SXC9accgPYMuG7RajVMxah nojlN0mvJopNr6grzeVy91sS9Yq2eG9c4ksjDorLLxT+N5QDpA8zvra8yOJ2GOgqf1vEMq70 Nuqip25tV3EJ01jvh0u14Au631KKVMLZdAYFpxbmHRFv00BosBWjZGGum16JhujomCfhAyx6 tEDisgVIXFaFsb1prIxp0S+hxD6/X3QbGjabAZStXg0N5VhuZZjAIys+vwLFZql9q9SnsW+V kssC0lBF+A4ZveBIQFFrYMsqX2Veqc0sl/pdpkp+EvlVdZDCqaJ9w9RQ81Q7FHgF3afmVgUO 7u0hEn4fFsOUAqbUGgVsngfavnCtAsaMbCtgecC74Txb69BvoDKSCMnZ1HzaL53Kg5+fCYtp 3bxYVT6J6YipSVA19enoiNMpXvIvtTSfipNpAUc3XcHRTS1LwPXc2RhiOgOrPJ/WcYpVdETo QpdHrIWbdOx7oizE2+XlnsBUG+5fxjad2ND18OicLbAMHh1btLCK5aHcL4erilIol79OjWwN QLNiJcxlBvUmU84aBAxfQIuA/e70jmFTxjScePOWvkZgOJZFZirP5qz4b7EXZwtN//BiGu/p Q1yN8Tm3ST3AGNOn1vrmEfFqDzldUAlFDGGSOxzMcZZtKvmdFZOtTDw6NCDbmf4m1AFXDLAs Lcisi9pFxaTjy7lBwKon0lEMnDhQy7gFupg/8CmPJ3MubJTPL+XfRlcDZ5mYB84ysRI4S9en 03iAUSdyG8PXi6uChM2TXKVfcpWQ5eXYTS4NiyjDor09n9Irp3KW1HTOEsGETqCzZVIfDkWk Yd3Ppi3ti+HZYy0SWLLNXCamaCNxKcMEaZFruK9yDVkr17BZyu98fLRQbfvxKrrazsccn9j6 esQwjfKQ8pmUIRNowICpERlY5u6fM2MVZKoD1S6aTHWBk2uomOdc9DyKf54xRpZayxelfjmt lWLJLlCBoM9eH2aR1rpYHxWMtGvGrOHOdiGKCYjOdWpn5QQ8zNKQ+dnaTOn7Epf2TtpLuFal C+k+xf7uAn0m7FvEap/1KTeEnWRDwWb9SiKehY75jmMareLk90pVCJdEWBhehGFPjW/1L5et 0cp7YYDJUCEFCJcn/8m6C38CJXdjz3hjAe8uc8O5RalG3wZKI6ydhs86Yyjc4b/YkAlmWiSY mXLlHYmgXl4ihJtNsSrNSigdTOFaWCF7ii1wd8GmJfs2k8Oe/CwAtDXOpUP7ar4qQb3bMfaw YQgAld8dEgZQV/C6pjMZJkgJRKh+HLU9PsNJIHwJYMGH2WrFGLVQUS7GiLX3gwlH0RBkYl46 Mav2HiQBNCoFQmrM0p9nMMpbcFlgxdIi0k3W1SDMWFZ44xgWiqaYzfgfb6Gzw4ZVQVDbwD3P N41U0Hb3J4s/o0EZ7RztX2+9g1UimH9E5LJxR+sysGsihFyEoOheROHiK6QS2WQrjo0fXDqG A7oC1hjULx+8pt8h+BFUJ8Fyjza2M7GTIigEbQx0c617M9U90NHqhRBzTAThA+fTJFMHxE0D pf4wq9QfCqX+UHAR+CrFnoxACRQBgTEvllAilYZ/uJTZr6yzrNyAyEb1W/uDzOk4hhZcmG5h hOi2OSCUY2/RTKrZjKcaAwREd6bIXJxCLvJpX7SsFMgx7mFyupdreOaloloPyXpJXfLLxjDW lOn5bvCeIOENoMplKNGz+LhftDZBxe9hlIdWfGHcxL6mD90VqWPjf/h3ILVN6Be0QhxZEVQ6 dKrl54vifKJifq10+bSSnu4937UK8XStFW2u9Z7HBTHDM7+MqeAWDVEguQUgBz5JvzztZz+c pnmXD4WfXRngZ99dpvzsfhVtIGYvbgMAIbsvNqYwQ2ddpM0hErLjeG4YVQULAnA4wyyw0ooC sdXKbPJRARGTD0vTaN8zjfa1aZTXUeqv10gM73ncg30iSzvojIkUhAGg3FIaMY5Fof/Ft0Am NOISP3cPDbPI8T1slgcz5stuXxfh0E6WS53iDa/oE+pvu26RL6Fb1HVrSNW5XrHhad1Sn262 whlU9cktGymzsi74kDytIH1CxD1hjx0P1RbfLZ29XMCDyUVBBeaY05sFEuoie0GEUNogPEKe B0eEV502k64I98j6pvv2bFpCqz3Xwc5jmWYlx2+2cSpQ6GR7aSccu2sNfRCSTiSXIAUyNjkU AuY9Lyh4gh8udUnG46FTFDnWobzDBWsysn5X2XD4iGyVbIYevUvDHeHq8HKsbVJv0mUzkGnx xABvb0P5gyzWHNk5ZASWERRHVa3pdkOmN9S8a0SRKdfIDF+jDNiopa4RSbwoJGSpawQ7oYON LwlbIf+qUo1NgQgp0Al9NjEpfHtVPtF0mla3nNSmgu/ZPtczbsfl/PPd4/by9nx/3L/dfzgc M0MDTjucWxalnKVfwinp4A1S5VOS0ieekvQpSzu4dhcvbeakt2TqaUs7U9l+6Uvbxf1lzNnZ +VyRaYl1f8XalJtPirLRbhoVkMPkqctQfnZlzXhlTQNljbRyXZOydrhCWRMo3stL080qTmVl MruIQH0l/1zSh4zPCsu+lRJwU+tXhybKxtTurh0ukxff3AReCwIEiSeSLT1qxrv8yeRUM9qs NHgoTfUMr2hyIbY0vBAOqpwqRUHDgq8PlFlo8jv6A4kmgj6w+vfNeuJAtauL3u87eEmYlwc8 kJnZBnRAfwtZLqJ6lmnaBNEvo54Z6ifYJLEgrxF2xVr1LcalHAopwOhiox9YAUnvK7TctYEz xT+t9PUel3HzZulLnih9xVOUAL1SCfCnh9RqZeivUAK02Uwc7rwRrZIDQvmPI5m4DCUta2sP w+dX94yHvQ8kq3vqiTOtnzLTYl2QVwrvqxLD09Q9QX8h6p7x6rnIehGjL6DuKfWUSQxVwxZP IvXmGeVPm0QqfymT6HV2BhysJk+inwoW2C65Yp9Y9nvNe9C5cfyJEsF84h44PVsRYMKK63sw i/guCjp9W+TELyjTQ9SmTFxqsnm5Kgauj2IYFlcd78CQvD+vjhLSCQxSHzSI423iu8n0EuwW bBZba1B/zaZO6YxSh7VyQQIXFcM8QLqsmfTMZZJ1uyhyUQBlJa2XpXfbrJl8geH711St7TG3 NaKkMGB37lG7ryiKLFDtDnpF7Q6V61DADHFcoRQxX/pprap3HtbQiI1bPRv/dUS8IvLPe7Sx JQs4w2fepi1Xf3Fz5erfX7rSPe76BYwi6pryzGAfVM1aU5t5hhkBECF4V8q8WtUGw3UAfSXq 0Dlq9KaHK7MuqIW4MqeZJd+PWQoGrMs6udekOokVqG4K+ycy762nabKpfiE/Qpc/SWxYNeAT +cfTDx9d6s/gf0t3fHDOi8HHgAagA2OvWUhJ0rNSRgNfnxVUfL2g0rkyLMq0zLgCRuR8UjH7 ZOkZNOOi2D9qUrE2jfpTK5M45nhWp5M4WoIeoJIPzTAtBEsVexMhnKBfBGUSgw0HM1F399+h kS4PmgA9QoWqsHAN8pFTn3xMJnNvb0hVVQXlX8b8hvt4w8zmibXLraRL8F+Q9IGyPDIpVisL FBUFiMm0xH9lmEimRTVsTkXmRwQ5BHlPikvfh5Te0zNk5tIEoarSw0NpqoFh/vtiKQAEmpt1 yvGBVuqn7pV08XQn5bKe7pxuPqOiDQDEBiYUJ0qnXOolsw04Rca3+480+5RgdxKUdxR1l/Bk n+vJPp++6+Wb3JCcInI+QYhNehdKRj+fUNAF1DQeezFv2w4CjWYcsHo0ZTxx1g2nr6MwyAls oKW30JC3NEADQWDDO7Iott09ymTO5mQtmxOe8XwBuXASaITqRhgNFZMN0PY0oBO5AYH0GugK ks8TapoNxPj0l349TbF8qC8QI8UGeAnRbgnqKDc1+ta/oEG2nFKnCTipQSl6V3JhqY5TvRyS c5SKjyeCdLvDVcYLuR2Hlk5U0J4Cus0cYIyMeIK8lGrUzPFDqtF9Ww1aRP++0PGEAdBVhmqF 5EsFoS65JKSNXFIjm9VFnRJhZLO+yvYy8YFYDDF+gA28+wHW4ZOb/gAtfCLbC8TTjV8ktOsR YYWjeT5BEA0QqLiXEe310LY8PfvLAmUyHEtJNqHBK1jAGDDofAx6dykrq+TJaKICe9+OL8yw RNdpRjq0F3lK0pMlB87hMpeO4Dft5FGD6nlABmGQ0OyKfnumegIOIcs2Ucm2jGdF1DGxskSi iC2xZ3T69pxXlx9h8ZFoO/tnMoWaGEhHLDerllRnSJFKAXQ4lTz+Qbi6smXBwhDLeO6FBkTQ +6yee4c/Q0CNVxys96C838A6iiF/YV9p+d8HRE7/xlAdQdbmwQ0pch10kerABcxexwPSryEf t8j59DrjhsWqIIbQ6wvCqwUF4dVK2phWQXjPlfMSIaRmeI4q04kGOkdeDpTrZwAGr7G8xITc ATbTBZX8hX6F3PECM5/oRGbDDGIYNsuCSoU6sNB/XdKlfWandovQsA5cXO+8trm5fc4jIdQc 51HNxlMk7kKOo0Of4wjU3JjkOOrT/kxxHB0uvcorQszaI1QnuY5cCmjVB32y9icA4Q9Eoh7m 99tizFVlOQTjuhu1bnKqaWY6taRxR0tzYFeaA4BFX/OhrD2+zhlb8G5MM2MUUMeSv6Sar4mS 2Pvpyt37ReZEl9mwWV7bMpKuKK+NgkYLQk2Uz5TXrkN4S5RxEGhbVBk7L9TL67JITMvVq4ch unqJXFhGu+mKKRDIQU6GUn6cNAylijayqtU+t4E19jydcIGEIgE1VrEoIKDIdgeOJ6qygnrG mc+x8kZmAVkgQMCR7SnromYwTznL1FTFM8Unz5Ca56GQ7YfiENnW5A/xENkW1b3iIZLpHw6X 4kOsRSOSSq7BM6XzknjI1AzhoZiJlGWc/5nxHMHKrwAdhPcBHZbpz5OpTtqSy1zoBf9goZBD uZ0TttlAG1iQdDpS3zqzTOOMDgdPL1wfMSekcE62agD9LF36yIMWJnn2HB81VtrNSfdv2CzP TT8Xuen27f4tw8xQ5WzwdognZ7mC/PXDCTsIZqF21FyDhXgSOdxkuUbvnddKYCb+QgF02o/e rBaWMgnLCIMo9xn1rN7UZdalwAoODdo3aZQFCzgPTGEDHE4FPVp/cZNkDgaHUyzRyw+FFwSc M7sqkqzm9WNZLHBQWR4s7OyKeNC77MEPHzaYD92+1b88pUyGcF9kgMMrdAcQj1R7n4KmeC2a QyEYzJTqeWg7u820rzu5EZvUjVD7RPRtLX2yZ4+uQVfOs6tMuaUl6aSs5zIwGGSA/c2y0KBZ mX6eUrs7IKZWZvaM4zvnIDVd1973TXXf255TuhpKNCudSM05QiKqcnUDCFfTAx0SpyITUelk rqeg5aAG3mwkPYtkeui8g+p84qDpDdWuV34nmyXNrLBS5oTWVAaHlV20VUmmylCSDixlM4a+ oM3exveAzV6z59w/D5z6aRte8H4cKv1WlGef3I45kT18QND+BwR9gUCXkEM30JV+WxzoQgN0 aO31buSrCjMtj3ChUQOK0a4Z4aplRZ6FqyJc/vEUyUAj+uwRruQLpoM/xOWv9RBfDL9+4iHO hycd4gU6mZdVE6cPcV7VA3umQ5yrviThuTAZ3sOdvVgSurXskf1lpnAdGpjdpX/+4j1anvjd 2dlfuojJ3QWT8DVO88bBP8WBczihLc97QblMovQsZ7kKZ7n+7Sx/8r7nE6AVXoFWrjnLJ0Ar 4kVAK2ICtCJWg1b4JGjlxc7yDlrlM53lL4pWSWe5YzRjvqpOdsP8dpavPstL597Ks7yYLl5T /E+e5c0SX89xlvOhL6ry2v6EZ3lnsfwqzvKePvjMZ7mkfs+b3/b80/Y8o0/a88Wm5Vyv2vOo QPBz7nkxoZ4I+Rn2PByYX9ueF/LT7PlwzpPfbPYn2uz6aTY73rRcr3K8p9uffc/rvuM9/fZJ 97wefr17XutPsud18NP9ZrM/g/9d9jdI+u1JNrvqn7rpt+e12XWfeiP9ttz/LvXnsNmV/JJs ds0/if9d/s7XiFkLzBeazgLzhaYrgfmyCcy3XEu/yZ2nyx3aN8BFFYa/Ru5MhNwF1S8hd5js yx0m18qdcpF+GrlD9Zckd3oFDJ5X7hAfA9DiS/UbgEWH9zXjxVFXEXh8UiOCsVn0TtYwaSPh hTHZsANYgQMg/X32HFidCcAAEy8T5vOTCUevZxosVvPba2R3WYbwgfYGP7RtGgiF7O9y0Jw0 94dEEOMhP50Rz+bFKkOCLzYkiPIHuvzFbXxe7oHPu/H5oJ+28fnQcvrxAs73shuf0350kYPy LM++8dHoPd/GR2vki9z4vRF/8Y0vvKVh1C/vxIfm6Bdw4svhiSe+bHn+WOF5eOETf8JFwZR8 wRNfDi9y4kv9pZ/4nRF/8Y3PguvwF7jxDf2iNr7mT9z4ugXTS738NCf+MIECGIYX3Piav8jG N/RLP/E7I/7iG58HZtFh0yi5mFKnpE8uTdXufRZ9n7M1sUgQXwaXfyli5X6pWJHD8NJi5X6N W9DQp4kVYVqIITkMn1CsyKHvepTDVLYP6v7+cqWwqRLWW2Ll0Bcr+0KsoDWy/+RiZT8vVnoj /tJiRXHi+bg/UcoAa5VgmibxFY0t3SXxNSXB0SI64V1zocZX6hWRhTZCYoYWOIbYn5S+O5MQ XJFEuPoVka2LT/JvxNPFhPCWXB/e4gvCW3xleEt0wltkWN0+tSD8ptaG31Qv/MY/f8lQ4Slt pQH1VuSTKsYIoTaLORqAZljg1maIG9IwQXTW/lKwNhwubXqHKofd1tL6DXf1NNyVehrWUmF1 R5awu2nclRTyZXBXUvZ9qVLyT4+7QgPzK8NdVYP9MrgrNRBvHvHPRC9T1Atq8N8Edgjzwowg qyoNxNHzpXCpHmDhKzoJR4oUpHyS6HtxeYWuhtLkHWjiAKZ5uqrtupykC90FCQVdcN7Wy8uE T45iCRA+SaqA2b2g5mVkgQJl+iJlbCy+CwmfXFX0guvP/02M5vEOyP7nYSiWBfzG1cA8jI09 7wBxEWCMIoYTlbBG4zjg17Q5ZKTDSlHBSX9YBGcLh2U/Nyz7S4NM8XCZG5ZDgxQRDsv+FvXP Ldj1o3RoIZOinuLLZ0hCJ5ZPpsH4h1k+JPDVfAaHVdNE7ZoWVDXKyswXuOFNGRvlqbjGJP2k Fuh8RRo96M10Sa7KAhVeaEimJzZD4M/8R9oMzBep11PDYoZfgCy9Xni2hsUrLFJMHDFSsH+4 1SJ8lqHBGUfwFDJIWfWDlu3GUNMmWSyKFhH9hjZWVm+H21zRVjE/L4bDvicB7kBfXNp3CG6f JGqXligEZMeCGB/uoRuEIW445QavlZNrCyq+oKJc6cQhhNYmpT3N8mOlMJcbHMHI9UUkp8+3 eCpdlhSKFD4mLwb2myvpaa4k8zTuvIKhQ65L4ZMvlcInJ1L45OdI4ZO/4hQ++YlS+Az3fNXq WhFE+RVi92k84onhNcirVBSn5bzKq7soS+LDbOt9QLJfmOpLj60lV45yh7JeWvWxHjnpqmB3 eL+lEHO1I4LaGeR1QxmFtN+FLgprR+T6udO1I8CHKP7QVO2IrHyypvJpPTsTJTT40mEo6Mf7 lsvLVtRYOCqL3Dx8YnkQ+atfHsSHJamaGAZqfvXDEPwcDuzVGwZOf/XDEPwaZmoYDF0nLL5w 6dAaBh1sQbJ5qWoVvk77JtVwz4XaQXX2QP+Q37q7tAARpmfyd6q7j6qBAiU4s25e06v7CjmC sIIGA1iluJp1sqap13isWLk7vve88/n+tA7R/Rb6s3lW67+f01rpIS0lpmuIxpvHye3Vx6qN aIfmsTO7Fi2jhvkqcmpYW0WOtdEyYuCfVMNuOjZaHuyOcwN5Uy4dsGLhxyBs0yiXUZbpvTv7 pclzqWPD5ytp6E27MDOoTB1K8XqTRhAQHc+Fz0eZOD4jMoDyPu40N8zGwxxBjQ0NDISM8ShX kKL9tZGi9srLJws7O/3w0cnqwe/YtG8/uLGxcWZf2IHrrlf0b3fhZvfatL5WoMUGPY8WG/TK 9T+0qygKeoWpZb7E8FCyPj0KTsEKcaysEOcrd3htUHCZTiaeQgmp3p7s4cRA6SqNA2jcbpRU 5FoIvDqFJI1yfc1i3X5LSm/TSOSOnCn95x4I+76JUwODqhBPqy0YonERcatHhP1sDnGoclnO rW+lQuZHBp94iIv16STXDjwYU/ETe5OBExUlAOKrtj2NI4pUFDudo7VcsNxqXCM9HsBBMiq2 YkhhMGPrR9gVsUHLMzjNGoPYTpBojSUTZPCvNxug1qRCNtbBdE4j6i5doKq3vSRFKy3n89G+ xC4qJ7BeSSEouhdVpHrvV3F36bseuhIvTiF4nVVQ1HdXejYURgc1CYNjhaHt0iiCGLCzbOlu CSeYfaCH+FByLhwXPhA02nY5tIzYevYo5fn03GFKEfXvoR+m5NnKmRmXfbOqaPF1gEPbXxoF 4kpb5VAN07ZR2a0TzK3MpjxKhzxK+TWx3JpPSRIuM6HnKVL6V19s1a2O8bg0GyS+6xwu6qxl Cw7ZfObjv5dV0IzwNY0TEZi0htUlrgVl88oZZSuVM91WzqQQm8Kn99xI0qog4f0stD34WKWh XUB+1eTnadwC3L13ZthwwOZlAuvd1Ujnq0ZP8Wd07GdJzZe4BKIDkX6JjfOCiuVk067Lxvq8 v8QeRMNErE55yX1oNq76ai+3pehFHUoQplneMoWqhcv1ydI9RY3Ft72C7Eh2nE9FbcXzCZR5 hiEZn0wkCrMMxBa94DZe5TegAvCNzCp6gkiWlRFHjayqjJiDwlFTMN6abpdHTSdbc6TIgAu4 hsqfxn/1lOoqugLY+JJd1ixewuW4T7nj3hFhYElIgmqe9mudiqLY6baseSy8mBJGTRQ7BS2N ZUtv/YzF3fCTLXU6EFTs1FvPNF6Jy89Qr87Svt7GDV+ot2276uzL1TemT6pvjNRXxmOsuHRu u03RmIpcU9at51TbNGT5dYrRVhgisAXzHG/jAl1YmtZ6kr6sUxqrhyJmemZfhYkNBBlFOcKU 4ybxAwSWlklxBZhqlf2tzoXi/T0TOQuSL7TU2ibJvgSUzphm+wnTbN80zQ5rTbN87qRx8FHa DCBpCNNywXvHg+2pgQa8TTwd8nr3C9URqaAt4GQw2APR+V4htFbsgHTaHS7t067KP9pfulJc hoRaVLkaSPFDT4ofOlIcID1DpNOXrZYDW4g+yRKFkrJKdTyrtvWgLy5cLZwL9xlVsSI9blke b/Se8Ce2pZmsV/gi5AQ6Q0j56/FF4I0u9OJjIPqIieym5t2i8Jo5zCaOXB9rUMbXMmemRZpT BcSnK5IzLnIAPiZB5DWipGfmknRT+CD3+U3jz96bA97kR/0MVhvzrJ6Clp+DNwUXtJRPXPfd if/qzf7d6e3x7nD/YGfuzfm4fzx9uPvqzePx8vjm493t6e/H25/DbefH7cNjuPHx5/vjVw/3 t28fjm/3H364P90e395vHx+PD3dv9h9ux9XxT+8+3rmX/W7its3Yv3/5yx+YnTw7dA455z52 OL57u3+3ffvh3bvz8fFrbf3g7odwYVzWN6K4Nm6iG67xNbvRbmy6ELpon2a0uDgukhvKi4vj Srqx33bjut19eHgsBm3swJ9c+/2g2UE8/WdvbF5//eam/cvU4E+8MAx2763u57GJf/y3P/+3 PzkovW/kmz//67/9NVxIn334cNg+bscrIbZM4zz/8S//11//+K9vCJejZPinD7u/jU/EZqHf FP0d+Nu+/PbD3fuvhvgPQnX8p1WhwsX4D+rm0/3Tegbi1XRf+pVXL67/QQaabksfZbT+F3r0 /e2HUZAef9juz3Y0f9he3r7bnm4/PhzP469oeHQcnebd1Th17tK/a/5gh+7Hj9uDpSIbGg07 b98d3zpxO9UgcFe/Pegm0BxwPbWGSGZZXt6cDse7x6+++d/++MfN19/+b//H//zua/OGvCFf 04GYQQzs62///Xj4+l+3j/76DfnuG7jQ7j48Ht+Mj92MEmX/99fffPP6n8at9H53ejz/7v8F SpkWabYSBAA= --------------6EB409978CA90BAF8AD1F800-- From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 07:07:00 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 11:07:00 +0000 Received: from localhost ([127.0.0.1]:40430 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgoia-0001Ua-Eo for submit@debbugs.gnu.org; Fri, 28 Jun 2019 07:07:00 -0400 Received: from mail-ot1-f41.google.com ([209.85.210.41]:46917) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgoiX-0001UK-Ll for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 07:06:58 -0400 Received: by mail-ot1-f41.google.com with SMTP id z23so5527392ote.13 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 04:06:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=L1AUz6qMyj8pe+GdE5yXyzrhcez2ctK3qa5IFH+lBR0=; b=D/oTevX7Hb44nkZVLYfWmk0LbEGA3gP0Zz6BN2yQfxFYh9jNm2kflW+gq8bTmJVHZV 86f5UqkGu4ijJtFZn5B/7821qd4l7GHKtk/g1JGG0RiCY9ZdEqZao/JxsBY464tQPbrP R75GYEnlbSbklN/jNc6YYGDhnbugcj990+mj59eAAXf/aWRtLl89EFp7+k0Hlmjf9WxC qQbI7AyLttIeUoVplTvenxsIepMait1iE0aZb2w2B2gtFm/b3V86jFS3cQMG5SZ1jYMT ebbml+fzVAlGUiWFYx4A2UNsheLlXja4bW7OtJQMZn5hr5uTsoPliz+mbvKl4KUJWFki q5dQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=L1AUz6qMyj8pe+GdE5yXyzrhcez2ctK3qa5IFH+lBR0=; b=HMN6TiheTrSi/2DqH4vnwyymMDZFnWqJcjz6KtljkLoFRnaynfmvWIBBeKOk0dRJIl sRVt6CMAWwaC28/RDA9JJfqW10Aiv/3huOodPwIW6wGCcxf0cfM//ld3w4nYRKKsKtj3 iWNrVZ/dMHL4Fa0XA+UMAbWKCIk/Oylh9m4YYzAZ3i1Aw3jsvpPqYvgbKJUFE1CbK7RM H8hR0TpzZOE37yp3Odlijm7Wes1+7oVN5CfKSF75Lbc8psohnfVCuarGC1NiB+762r/N eldAoI6AyCf9aTaRaalW/VREHCw0zspowpjaI2NhCDa/8c4jYHDurp2+pV8BlgpudEKO YmQg== X-Gm-Message-State: APjAAAXd1TxAeKBeC1N/HoV+DmLZWzNtJiTavmtoeBmtCVbSDlePqRWJ tsrvR1fYN05jKkbpN+7uVU/Za2pbvdvVH3ps07M= X-Google-Smtp-Source: APXvYqyjcxCDM8hMl9kUTZTLZ1SkJ6SrwuSHb4c0xF/ORDe83Q/EY0nO8EqRHrR0NdPWIHVkPot7rjfTJZ0qm2eUSII= X-Received: by 2002:a9d:664c:: with SMTP id q12mr6891215otm.175.1561720011882; Fri, 28 Jun 2019 04:06:51 -0700 (PDT) MIME-Version: 1.0 References: <5284eb58-3560-da42-d1d1-3bdb930eae49@cs.ucla.edu> <2715311.ceefYqj39C@omega> In-Reply-To: <2715311.ceefYqj39C@omega> From: Pip Cet Date: Fri, 28 Jun 2019 11:06:15 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Thu, Jun 27, 2019 at 11:45 PM Bruno Haible wrote: > Can you please show an example code on which the change makes a difference? int main(void) { eassume (printf("hi\n")); return 0; } Or, more realistically: extern int potentially_inlined_function(int i); int main(void) { ... eassume(potentially_inlined_function(i)); return i >= 0; } With the old gnulib eassume, the programmer has to know whether potentially_inlined_function is inlined (in which case the eassume appears to be treated as a nop) or not (in which case a potentially expensive external function call is generated). With the new eassume, these cases are distinguished by the compiler. This makes it safe to use function expressions in eassume, whether the function is inlined or not. (That GCC doesn't actually do very much with this information is a separate issue). This approach does fail for certain compound expressions passed as arguments to eassume: eassume(i >= 0 && i < complicated_function ()); will not "split" the && expression, so it'll behave differently from eassume(i >= 0); eassume(i < complicated_function ()); But even in those cases, this approach is better than the old approach of actually evaluating complicated_function. At first, I thought it would be better to have a __builtin_assume expression at the GCC level, but even that would have to have "either evaluate the entire condition expression, or evaluate none of it" semantics. We'll just have to get used to splitting our eassumes, I think. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 08:14:25 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 12:14:25 +0000 Received: from localhost ([127.0.0.1]:40479 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgplo-0005D4-V2 for submit@debbugs.gnu.org; Fri, 28 Jun 2019 08:14:25 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.20]:21337) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgpll-0005Cu-No for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 08:14:23 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561724059; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=cVrvP86fVI4HbdtgdDoi57Pb+3PlWDZrJVaoYWNwDeg=; b=kTgnW6BqLehyaiTn4ExYwM83tTnM6EH1QByCtpUA2r/0oZJmcZ5R2hkri2OjpQ2xzs 5E/WUJvNONri+h1PeLl6nEWHV6GEe9vAlFIna6YUNgvfyRMAVWtganIb/saAHkHK9521 XjzhMO/o+rsya70RyCWgmmA1l2zKw4oHfLwmvlYZLOG2mhFaHzIU9Y+Di+LW6TNuuTJ/ 5GkQ6vFpkGg2V5PtzpNgJzJ4dNwD5vES2rfgIwzefVaxKz7pT0v9hBr+iY0j1Rk0htk2 /QeDnTWrB9h6CP2qd19txqokBLsDQBO5+XKKoO5sJzpm9c+cLDsJpAAlFnDhI804bC/F H8lQ== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5SCEFhnF (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Fri, 28 Jun 2019 14:14:15 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Fri, 28 Jun 2019 14:14:14 +0200 Message-ID: <8979488.cRkkfcT1mV@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: <2715311.ceefYqj39C@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet wrote: > Or, more realistically: > > extern int potentially_inlined_function(int i); > > int main(void) > { > ... > eassume(potentially_inlined_function(i)); > return i >= 0; > } OK, I see... > This makes it safe to use function expressions in eassume, whether the > function is inlined or not. By "safe" you mean that you want the function call to not be evaluated. You are mentioning a limitation: > eassume(i >= 0 && i < complicated_function ()); > > will not "split" the && expression, so it'll behave differently from > > eassume(i >= 0); > eassume(i < complicated_function ()); And I would mention a regression: When -flto is in use and the expression invokes an external potentially-inlined function, the old 'assume' would work fine, i.e. do optimizations across compilation-unit boundaries. Whereas the new 'assume' does not. Test case: ================================ foo.c ================================= #include #define assume(R) ((R) ? (void) 0 : __builtin_unreachable ()) //#define assume(R) (!__builtin_constant_p (!(R) == !(R)) || (R) ? (void) 0 : __builtin_unreachable ()) extern int complicated (int i); extern int nonnegative (int i); int f_generic (int i) { printf("%d\n", i & 0x80000000); return 0; } int f_condition (int i) { if (complicated (i) && i >= 0) printf("%d\n", i & 0x80000000); return 0; } int f_assume (int i) { assume (complicated (i) && i >= 0); printf("%d\n", i & 0x80000000); return 0; } ================================= bar.c ================================ int complicated (int i) { return (i & 7) == 3; } int nonnegative (int i) { return i >= 0; } ======================================================================== $ gcc -O2 -m32 -flto foo.c bar.c -shared -o libfoo.so && objdump --disassemble libfoo.so With the old 'assume': 000005f0 : 5f0: 83 ec 10 sub $0x10,%esp 5f3: 6a 00 push $0x0 5f5: 68 74 06 00 00 push $0x674 5fa: 6a 01 push $0x1 5fc: e8 fc ff ff ff call 5fd 601: 31 c0 xor %eax,%eax 603: 83 c4 1c add $0x1c,%esp 606: c3 ret 607: 89 f6 mov %esi,%esi 609: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi With the new 'assume': 00000610 : 610: 83 ec 10 sub $0x10,%esp 613: 8b 44 24 14 mov 0x14(%esp),%eax 617: 25 00 00 00 80 and $0x80000000,%eax 61c: 50 push %eax 61d: 68 48 06 00 00 push $0x648 622: 6a 01 push $0x1 624: e8 fc ff ff ff call 625 629: 31 c0 xor %eax,%eax 62b: 83 c4 1c add $0x1c,%esp 62e: c3 ret 62f: 90 nop 00000630 : 630: eb de jmp 610 > But even in those cases, this approach is better than the old approach > of actually evaluating complicated_function. I disagree that it is better: 1. The new 'assume' is worse when -flto is in use. 2. You recommend to users to split assume(A && B) into assume(A); assume(B); which is unnatural. > At first, I thought it would be better to have a __builtin_assume > expression at the GCC level, but even that would have to have "either > evaluate the entire condition expression, or evaluate none of it" > semantics. No. At GCC level, it could have a "make the maximum of inferences - across all optimization phases -, but evaluate none of it" semantics. Bruno From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 08:29:07 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 12:29:07 +0000 Received: from localhost ([127.0.0.1]:40495 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgq02-0007gm-W6 for submit@debbugs.gnu.org; Fri, 28 Jun 2019 08:29:07 -0400 Received: from mo4-p01-ob.smtp.rzone.de ([85.215.255.52]:33294) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgq00-0007gd-7D for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 08:29:05 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561724942; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=AXDdAkmWVg0AqsLsFlhtJqEIBdpIaBDF57n3RWIYw4I=; b=th12ECQ+Z81Y/r1Nv87CAWPKOYBXMLcb6huqm8IjURRFA9L+BAEu5OS7m/HAn1M2Jr JXt2WDyJby+28PQ7FiPYf7PMbadb7gUke3QeY4l6ySU805fREviGITV0O7gY7YlaJ6oa OhzZCuuBQHRDLomVG6Rm5jGJOVbJwHRa5/qs/A04hvY4RYpRidvMcTMqIM9exLwTUSJi kJ/eeC2NGHHWHBIb0P8IiMIhfwsCs8az0V/LY3+e1PSsl4cHgSaHnYu63TigIVs+l9ay bbZEJGYtdj6idAa6W+jwDI4V+OBjzJ7IHvk4rGpe1QWodw/YUEUqdWW+v4akxvFYILxN RXWQ== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5SCT1htS (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Fri, 28 Jun 2019 14:29:01 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Fri, 28 Jun 2019 14:29:00 +0200 Message-ID: <8538079.qoQZQqKKBW@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: <8979488.cRkkfcT1mV@omega> References: <8979488.cRkkfcT1mV@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Oops, the test case that I meant to show is this one: ================================ foo.c ================================= #include #define assume(R) ((R) ? (void) 0 : __builtin_unreachable ()) //#define assume(R) (!__builtin_constant_p (!(R) == !(R)) || (R) ? (void) 0 : __builtin_unreachable ()) extern int complicated (int i); extern int nonnegative (int i); int f_generic (int i) { printf("%d\n", i & 0x80000000); return 0; } int f_condition (int i) { if (complicated (i) && nonnegative (i)) printf("%d\n", i & 0x80000000); return 0; } int f_assume (int i) { assume (complicated (i) && nonnegative (i)); printf("%d\n", i & 0x80000000); return 0; } ================================ bar.c ================================= int complicated (int i) { return (i & 7) == 3; } int nonnegative (int i) { return i >= 0; } ======================================================================== The results are as shown: the optimization in f_assume is performed with the old 'assume' definition, but not with the new one. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 09:52:09 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 13:52:09 +0000 Received: from localhost ([127.0.0.1]:40617 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgrIP-0003Pg-DB for submit@debbugs.gnu.org; Fri, 28 Jun 2019 09:52:09 -0400 Received: from mail-ot1-f49.google.com ([209.85.210.49]:46211) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgrIM-0003PC-Je for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 09:52:07 -0400 Received: by mail-ot1-f49.google.com with SMTP id z23so5990667ote.13 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 06:52:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=RGXOFred0FBkYFBeYkzA77sP/BTIEjMaTq55XuhOUq8=; b=V+nEYL16H0PhdnDTgOLZnd093IS7KH6SPZ6rO8YskJDdBhOfpqyo1U846+iQ0e9pf+ vdRpQXcuyzOyS983UyQbN8389xa/V2tbs8ul+MIbTPcZn6raAToluSUz8XY9PJFc0QGQ K6blUh1mYo5sAC/hB/JXKj7tMLUIsWwtfH7SsVAP2gd3ADGLxEYVuNMxpIH4r9jwJM87 M9MbV+bEWzeoMGGYoglAy7KB5lF10mUbre5apPqafzHYY8fYq0pDbBGQkoPfja7lKXt7 C2sKII7QmApKeivTxa/xrB9HC8tz1gcaI6qMDavGXBYbnnszscYlXsPuOfnFLG8EWSRD Cj/g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=RGXOFred0FBkYFBeYkzA77sP/BTIEjMaTq55XuhOUq8=; b=pWl3TyVqNWRi/D+U9JeR5OYOdhfE14HhxFSOpZwh4WhnLlsWbNmzziBrZlYZAxHowO l7TU+GbMOcy9VQFD7sU/c5N38nOmll3+V2yLwg1CRd5EraHv7+QYpccEhJIzV9+//xvK wmDdBfPyAOQ/J0h0OD2PG0YR1wakc7Kzk61R/N8EO+F8MPkh3ewe5RH/9weZh8P7JdgK Z02BRhNooC4h5cmsob7LYQKFT0JXBZCrRuYLvGPoGvluMUBMx7kcgDnOqxlIBufVDpfK Y1p5rdRugObO4QC/gOQQZHoAYqrInn4J01NSmphNkfvj5+xPd3yd3mkp7b3bPs8HaGls u+sg== X-Gm-Message-State: APjAAAUez8BCuzvtti4WNd/9tBJSdBKPSwe56Op3cElzsWpB0+p6RBlI 6N8gHLLFbBbE1RUuphpvXBmZR05Bb8YmDzoqXB4kVgX57sk= X-Google-Smtp-Source: APXvYqy/LQdJGQ/wMU01PQZFjx3bGbeU759EiH9qbC/uUK5Crcb8ojRtGNXRzUMGfcmTMIbyj6lzpHksgws5JMaILco= X-Received: by 2002:a9d:7352:: with SMTP id l18mr8485713otk.292.1561729920817; Fri, 28 Jun 2019 06:52:00 -0700 (PDT) MIME-Version: 1.0 References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> In-Reply-To: <8979488.cRkkfcT1mV@omega> From: Pip Cet Date: Fri, 28 Jun 2019 13:51:24 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Fri, Jun 28, 2019 at 12:14 PM Bruno Haible wrote: > Pip Cet wrote: > > This makes it safe to use function expressions in eassume, whether the > > function is inlined or not. > > By "safe" you mean that you want the function call to not be evaluated. Sorry, sloppy wording there. You're right. > You are mentioning a limitation: > > > eassume(i >= 0 && i < complicated_function ()); > > > > will not "split" the && expression, so it'll behave differently from > > > > eassume(i >= 0); > > eassume(i < complicated_function ()); > > And I would mention a regression: When -flto is in use and the expression > invokes an external potentially-inlined function, the old 'assume' would > work fine, i.e. do optimizations across compilation-unit boundaries. Sorry, can't reproduce that here. I'm sure the changes I need to make are obvious once I've found them, but can you let me know your gcc version? > > But even in those cases, this approach is better than the old approach > > of actually evaluating complicated_function. > > I disagree that it is better: Sorry to be pedantic, but do you disagree that it is better in these cases, or in general? The latter is a question that I'm trying to find the answer to, but in these specific cases, it clearly is better. (Just in the interest of full disclosure, I described the idea in a different context; I think it's a neat hack, and I'm trying to figure out whether it has practical applications, but if it doesn't then I won't feel there's continuing disagreement). > 1. The new 'assume' is worse when -flto is in use. Maybe. Even if it is, though, that's a GCC limitation which I consider likely to be fixable; your estimation of that may vary, of course. > 2. You recommend to users to split assume(A && B) into assume(A); assume(B); > which is unnatural. I make that recommendation independently of which assume is in use. In practice, combining a complicated expression with a simple one in an eassume is almost always not what you want to do. It's way too easy to do something like eassume(ptr->field >= 0 && f(ptr)); when what you mean is eassume(ptr->field >= 0); eassume(f(ptr)); (As an unusual special case, consider: { printf("%d\n", i & 0x80000000); assume(i >= 0 && complicated_function()); } which would generate different code from { printf("%d\n", i & 0x80000000); assume(i >= 0); assume(complicated_function()); }) Combining two simple expressions and not getting the right result appears, at this point, to run into a GCC limitation, but I'm not sure where. > > At first, I thought it would be better to have a __builtin_assume > > expression at the GCC level, but even that would have to have "either > > evaluate the entire condition expression, or evaluate none of it" > > semantics. > > No. At GCC level, it could have a "make the maximum of inferences - across > all optimization phases -, but evaluate none of it" semantics. There's no contradiction there: I'm saying that the programmer is allowed to assume that the expression passed to assume either has been evaluated, or hasn't been, with no in-between interpretations allowed to the compiler. That means assume (A && B) isn't equivalent, in general, to assume (A); assume (B); My suspicion is that the latter is almost always what is intended. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 13:47:02 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 17:47:02 +0000 Received: from localhost ([127.0.0.1]:42922 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hguxh-0008I2-Is for submit@debbugs.gnu.org; Fri, 28 Jun 2019 13:47:01 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:37882) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hguxf-0008Hi-BJ for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 13:47:00 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id A473A161C3F; Fri, 28 Jun 2019 10:46:53 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id 02YE2pDQwSmy; Fri, 28 Jun 2019 10:46:52 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id CD3F0161CCD; Fri, 28 Jun 2019 10:46:52 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id jskSkVipUJ65; Fri, 28 Jun 2019 10:46:52 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 9FEC5161C3F; Fri, 28 Jun 2019 10:46:52 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet , Bruno Haible References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: Date: Fri, 28 Jun 2019 10:46:52 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Pip Cet wrote: > It's way too easy > to do something like > > eassume(ptr->field >= 0 && f(ptr)); > > when what you mean is > > eassume(ptr->field >= 0); > eassume(f(ptr)); These mean the same thing. Both tell the compiler that a certain condition (A && B) is known to be true, and that behavior is undefined if (A && B) is false. The fact that Gnulib+GCC implements them differently is a quality-of-implementation issue, not a semantics issue. > I'm saying that the programmer is > allowed to assume that the expression passed to assume either has been > evaluated, or hasn't been, with no in-between interpretations allowed > to the compiler. I don't see why that assumption is valid. It's OK if GCC partially evaluates the expression. As a silly example, eassume (0 * dump_core () + getchar ()) is not required to call dump_core, even if the compiler generates a call to getchar. Perhaps we should change the comments in verify.h to make this point clearer. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 15:11:22 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 19:11:22 +0000 Received: from localhost ([127.0.0.1]:43013 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwHJ-00052a-UM for submit@debbugs.gnu.org; Fri, 28 Jun 2019 15:11:22 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([81.169.146.160]:34580) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwHG-00052N-2u for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 15:11:20 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561749076; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=mtWVzqbnP43E/Sg/vARE9UyxgC96tN57kEw1cX+jNOQ=; b=sRcbbjjkXxbyhbcj5rKHjSTnZJ7SwJvIwxx0wPjV2+WJ5riF/vr/P0i8lMz1S/71Ts jW7S4bMwso+iuABN4RXfwttMjIXmygi+31FvqrlclOBlRb3bsJ5VtU0uRhuJSLCkdeyB ZsmkfHujCSJ5z71iDT15wrUsW382E3xXmOy5fau9dFFcoiW84IoTswmHLTC7cl6hYSlW qHEYhYpkcUs1Z84w3yoHkoN5WXPSuqanoCOgMvmShWlP9K6CroOu4Iiross1zCCZfqWt 49aMtLDAhkxFpMefXeCnma1UuwZzYtKO9G7858js9+11Evrk5KSuvYHfOoeMaiM8owTP tB3Q== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5SJBBjvh (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Fri, 28 Jun 2019 21:11:11 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Fri, 28 Jun 2019 21:11:11 +0200 Message-ID: <11002295.LrvMqknVDZ@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: <8979488.cRkkfcT1mV@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet wrote: > Sorry, can't reproduce that here. I'm sure the changes I need to make > are obvious once I've found them, but can you let me know your gcc > version? I reproduce this with GCC versions 5.4.0, 6.5.0, 7.4.0, 8.3.0, and 9.1.0. 1. Take the files foo.c and bar.c from 2. Compile and disassemble: gcc -O2 -m32 -flto foo.c bar.c -shared -o libfoo.so && objdump --disassemble libfoo.so Observe that f_assume pushes an immediate $0 argument on the stack for the function call. 3. Enable the second 'assume' definition instead of the first one. 4. Compile and disassemble: gcc -O2 -m32 -flto foo.c bar.c -shared -o libfoo.so && objdump --disassemble libfoo.so Observe that f_assume is now an alias of f_generic, that pushes a computed value as argument on the stack for the function call (push %eax). > Sorry to be pedantic, but do you disagree that it is better in these > cases, or in general? I disagree that it is better in general. You're apparently setting out a high goal for the 'assume' macro: (1) that the programmer may call it with an expression that involves function calls, (2) that the generated code will never include these function calls, because the generated code with the 'assume' invocation should be optimized at least as well as the generated code without the 'assume' invocation. I'm adding certain quality criteria: - It is not "good" if a construct behaves unpredictably, that is, if it hard to document precisely how it will behave. (*) - It is not "good" if the behaviour with no LTO is different from the behaviour with LTO. The implementation with the __builtin_constant, while attaining the goals (1) and (2), does not satisfy the two quality criteria. I believe the only way to attain the goals and the quality criteria is, as you suggested, to ask the GCC people to add a __builtin_assume built-in. > > 1. The new 'assume' is worse when -flto is in use. > > Maybe. Even if it is, though, that's a GCC limitation which I consider > likely to be fixable Yes, *maybe* the GCC people can change the semantics of __builtin_constant_p so that it is effectively computed at link-time, rather than when a single compilation unit gets compiled. Or maybe not. I don't know... > It's way too easy to do something like > > eassume(ptr->field >= 0 && f(ptr)); > > when what you mean is > > eassume(ptr->field >= 0); > eassume(f(ptr)); I argue that it's unnatural if the two don't behave exactly the same. Like everyone expects that x = foo ? yes : no; is equivalent to if (foo) x = yes; else x = no; And everyone expects that if (A && B) { ... } is equivalent to if (A) if (B) { ... } Bruno (*) My favourite example of this principle is tail-recursion elimination. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 15:15:53 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 19:15:53 +0000 Received: from localhost ([127.0.0.1]:43017 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwLg-0005vV-K1 for submit@debbugs.gnu.org; Fri, 28 Jun 2019 15:15:53 -0400 Received: from mail-oi1-f169.google.com ([209.85.167.169]:41920) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwLc-0005lv-Ik for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 15:15:49 -0400 Received: by mail-oi1-f169.google.com with SMTP id g7so5049005oia.8 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 12:15:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=iRNuL0n5Vl2Y0LzIlmkphK3bo/ZzekQWktdItiI9OHo=; b=TINWKQmxFGFpr/w8NeJKqdHz1v/tpD1ZbSiUQ4HHsNDTrsGiyVKsa865IJW5l1m7Di xKqL7YKzaE20O6qtYTLmUXRomYRO2eNZLHBfXQj3EU5/Xltl5SixiptPIp/DTHVDI66q tQ9Y9whHwgSYgjmY+lsk2CwY2eWKJO1tMdJZgZCZwEhTRMkDb6FwZLF2mzp6o07m/J8p tbqkE4ZcEpzYr1ekSNcX0S9zyep4H1He+WB9xnl10ZXfj6EX3hQAL+Iytq6Zo1w1OhGK nITC+4HmJc4NuS4gp2Ymu+6g8cO84GI4XMCqG+ZMeET28nQQVhVJpWMBsVqO8LADoA4t Q8BA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=iRNuL0n5Vl2Y0LzIlmkphK3bo/ZzekQWktdItiI9OHo=; b=hhi2XoWPuH8HaDs3uKyMox/C54loOybG82/iS0u9k13bDFUMQxF39Vb2K0rzQ0zHV0 sz6xwrf9mANtmpuavxOkNjIbum8Jq5yKc+9XnNhjL5r9fio41g7qcxnMFq1UlLwHOSyD 6MXw8r5RWBDFXm075NVFjOftaHJ4+Qxepx3YIwttnIsP0JtYjj03wUwXDBBNc6cXniJ5 HbXhZy1tzEcgtKuNBcDR1WI5aMulvIX6a6ORyhdojKDxJU0sqy/Hm2cTqxqn4IkwFieo sbpeWCYPjb9nfrz1GEo2jZBSnN57Cvm4AQ4x/pwdWY08UVtKlMJo8qma4P8LrlX5NOva MNhg== X-Gm-Message-State: APjAAAWue6qLpO60n/wPi3Pi/syrqtOec0jU64SmK84yjPHhBH5w3pFj GO1Mz+LgrnST+c/fJgXhYfe5pOQ3QqXg68wpq3Q= X-Google-Smtp-Source: APXvYqyit9XlgDW+7sEC8RjfCVfZxjYQXiogdaUm9hkYQLSZeciIr2pmRJxRjq8BuNiHuRFXcdC3HlkdIldpqCwuRRU= X-Received: by 2002:aca:2303:: with SMTP id e3mr2418739oie.112.1561749342475; Fri, 28 Jun 2019 12:15:42 -0700 (PDT) MIME-Version: 1.0 References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> In-Reply-To: From: Pip Cet Date: Fri, 28 Jun 2019 19:15:06 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Fri, Jun 28, 2019 at 5:46 PM Paul Eggert wrote: > Pip Cet wrote: > > It's way too easy > > to do something like > > > > eassume(ptr->field >= 0 && f(ptr)); > > > > when what you mean is > > > > eassume(ptr->field >= 0); > > eassume(f(ptr)); > > These mean the same thing. I'm really convinced they don't. Can you humor me and explain why they're equivalent? I'm considering this test case: ==== int global; extern int f(void); #define eassume0(cond) ((cond) ? (void) 0 : __builtin_unreachable ()) #ifdef ASSUME_GNULIB #define eassume eassume0 #else #define eassume(cond) (__builtin_constant_p (!(cond) == !(cond)) ? eassume0(cond) : (void) 0) #endif int main(void) { #ifdef TWO_ASSUMES eassume (global == 0); eassume (f ()); #else eassume (global == 0 && f ()); #endif global++; } ==== with this external function: ==== extern int global; int f(void) { return ++global; } ==== I believe, and that is what my patch is based on, that the compiler should be free to "use" the first eassume and ignore the second one, resulting in this machine code: movl $1, global(%rip) xorl %eax, %eax ret No call to f, it just sets global. Without -DTWO_ASSUMES, the compiler cannot split the assumption. > Both tell the compiler that a certain condition (A && > B) is known to be true, and that behavior is undefined if (A && B) is false. Again, no. The split eassumes tell the compiler that A, B, and A && B would all evaluate to true or fail to evaluate. The single eassume() only covers the last of those three cases. > The > fact that Gnulib+GCC implements them differently is a quality-of-implementation > issue, not a semantics issue. Are you really saying that the single-assume case is equivalent to the single-instruction program? > > I'm saying that the programmer is > > allowed to assume that the expression passed to assume either has been > > evaluated, or hasn't been, with no in-between interpretations allowed > > to the compiler. > > I don't see why that assumption is valid. It's OK if GCC partially evaluates the > expression. As a silly example, eassume (0 * dump_core () + getchar ()) is not > required to call dump_core, even if the compiler generates a call to getchar. That's because && implies a sequence point, and * doesn't. > Perhaps we should change the comments in verify.h to make this point clearer. I'm sorry to be selfish, but I'd really rather understand where I've gone wrong, first. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 15:56:12 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 19:56:12 +0000 Received: from localhost ([127.0.0.1]:43066 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwyi-0008Kz-9W for submit@debbugs.gnu.org; Fri, 28 Jun 2019 15:56:12 -0400 Received: from mo4-p01-ob.smtp.rzone.de ([85.215.255.51]:20615) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgwyf-0008Ko-Aj for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 15:56:10 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561751767; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=q5B96l2kKcE0Gw8DRtavVqjHjH1eCunMAcpqoYqWY8U=; b=hG2YcdNr247BXxZSquAnCpTeYEknMSqGe6VGwoHAzUdjb7h0/IYwlnOUp7TK7Sqy1t ptSj/LfH8MjwOgsQDy9MKkXJUjktWr044irk+dRRqKdew5X76f7IJSzdTWMfUi7kZPVA hwn0oXyAmruPPIvZt38kVCpv4RG18ibDCif/YPaQlVMjO01d2kd3VrjLLV9Pvfxj5ew2 8kxdnjW6gUxtY+23Cpp5yADV0vm2dd07P7KaXiZyPDR/Pr+d5FZX697HWEK0lUeksJpl h6mKNh/vLreOGfHCVJeSuhOQbsxT/5TorHefHqM/zB3QJOtoxSff9Zzc09hMFFmxracf Utng== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5SJu5k0z (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Fri, 28 Jun 2019 21:56:05 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Fri, 28 Jun 2019 21:56:05 +0200 Message-ID: <2490928.QNlPtjyuh0@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Freitag, 28. Juni 2019 19:15:06 CEST Pip Cet wrote: > On Fri, Jun 28, 2019 at 5:46 PM Paul Eggert wrote: > > Pip Cet wrote: > > > It's way too easy > > > to do something like > > > > > > eassume(ptr->field >= 0 && f(ptr)); > > > > > > when what you mean is > > > > > > eassume(ptr->field >= 0); > > > eassume(f(ptr)); > > > > These mean the same thing. > > I'm really convinced they don't. Can you humor me and explain why > they're equivalent? > > I'm considering this test case: > ==== > int global; > > extern int f(void); > > #define eassume0(cond) ((cond) ? (void) 0 : __builtin_unreachable ()) > #ifdef ASSUME_GNULIB > #define eassume eassume0 > #else > #define eassume(cond) (__builtin_constant_p (!(cond) == !(cond)) ? > eassume0(cond) : (void) 0) > #endif > > int main(void) > { > #ifdef TWO_ASSUMES > eassume (global == 0); > eassume (f ()); > #else > eassume (global == 0 && f ()); > #endif > > global++; > } > ==== > with this external function: > ==== > extern int global; > > int f(void) > { > return ++global; > } > ==== > > I believe, and that is what my patch is based on, that the compiler > should be free to "use" the first eassume and ignore the second one, > resulting in this machine code: > > movl $1, global(%rip) > xorl %eax, %eax > ret For reference: This test case produces: Options Result none increment -DASSUME_GNULIB increment -DTWO_ASSUMES single-store -DASSUME_GNULIB -DTWO_ASSUMES increment Bruno From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 17:08:24 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 21:08:24 +0000 Received: from localhost ([127.0.0.1]:43111 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgy6Z-0003vZ-Hy for submit@debbugs.gnu.org; Fri, 28 Jun 2019 17:08:24 -0400 Received: from mail-ot1-f41.google.com ([209.85.210.41]:41157) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgy6U-0003vF-Np for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 17:08:20 -0400 Received: by mail-ot1-f41.google.com with SMTP id o101so7059010ota.8 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 14:08:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=HOrMmQEm9jWBfwD7c7FjdOiWInhNHTe8lvhrU/9EVgU=; b=KybW0/5QBUmutANtQyM5zPaNaH3Rr8Z/4/occ2wvvdABlo98fR6A7Aw+tJn3LlFgMo yG41dVCZ7kUjLZkXbEFRjjPdp5Trxb5RgwExQydRacHrRUem7LBJWLY30cSi5joy7Cb9 TalCe+CMjsEdWsmcCkioCjhsDr8NDQ5Dz/C2/gvGq4egCfrOnMrPawdFmWsNZILzdYki RCbTmye2YgglBa1wbm/Ki1/L9tkrSUbUQPn9/Wvp9vdAsFVRcZ2p3hmmOalfhvfGmmRK H+7Li0vIXJ3JhJAtLnH4e5w8kh083MILBYTVUH6zlrEh90Ob9ZxDd3AKBDWOPlmA6/Vu 4fJA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=HOrMmQEm9jWBfwD7c7FjdOiWInhNHTe8lvhrU/9EVgU=; b=GpXFBZLgsH86/ICalhtDDo0gEPHqndwJMjy0xKML3KCE9F2nH37xlwGE+9oES7LvTV F88px1fS14WBRmGJ5cZgXP09rUr4ugSxAGRx7QR/P8Dw+J7+Azhq6/GSw1fjVXbsZK/8 /ihTn2uB28m1nMDpRnzArO3AuSvU3ycz7IhF1vqapomoHCppzE4tK8S9hp9+onnOqlg9 hXTusef5SWEGsLYd8qFIl4gbSO3dr315Ueq6VkGXPBQ2/wQ7kktFTPFS3sP+S1PsrZ44 bqhIOTBk5SpJbTM0pmVZ6JINlKdBTNlnYULDZc46XufvmhTsK3i2Rg9IE1HS2vI/mQWk 8F9w== X-Gm-Message-State: APjAAAVUmB9JqjtPD42JYbxUHHzHhgDRRLlakqHM97lCLXzrYPKkI5Ew jBDnK417Pa74SrIVe8LW89waZBbBCJxBXEsEE/c= X-Google-Smtp-Source: APXvYqyAsHNltupA2PFc2hVGyp0OfMUHOxYyMdj5P+nqnA9UmTBE3JfLzJSehtkHVXazT5i8b7aTeZJNA/9ZHLAemvo= X-Received: by 2002:a9d:3c5:: with SMTP id f63mr9475512otf.210.1561756093089; Fri, 28 Jun 2019 14:08:13 -0700 (PDT) MIME-Version: 1.0 References: <8979488.cRkkfcT1mV@omega> <11002295.LrvMqknVDZ@omega> In-Reply-To: <11002295.LrvMqknVDZ@omega> From: Pip Cet Date: Fri, 28 Jun 2019 21:07:37 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Fri, Jun 28, 2019 at 7:11 PM Bruno Haible wrote: > Pip Cet wrote: > > Sorry, can't reproduce that here. I'm sure the changes I need to make > > are obvious once I've found them, but can you let me know your gcc > > version? > > I reproduce this with GCC versions 5.4.0, 6.5.0, 7.4.0, 8.3.0, and 9.1.0. > 1. Take the files foo.c and bar.c from > > 2. Compile and disassemble: > gcc -O2 -m32 -flto foo.c bar.c -shared -o libfoo.so && objdump --disassemble > libfoo.so > Observe that f_assume pushes an immediate $0 argument on the stack for the > function call. > 3. Enable the second 'assume' definition instead of the first one. > 4. Compile and disassemble: > gcc -O2 -m32 -flto foo.c bar.c -shared -o libfoo.so && objdump --disassemble > libfoo.so > Observe that f_assume is now an alias of f_generic, that pushes a > computed value as argument on the stack for the function call (push %eax). Thanks. I have no idea what I was doing wrong, but I can confirm that this case indeed demonstrates a GCC weakness when there is a non-split eassume (A && B), where A and B are both assumable (in the sense that __builtin_constant_p(!A == !A). > > Sorry to be pedantic, but do you disagree that it is better in these > > cases, or in general? > > I disagree that it is better in general. > You're apparently setting out a high goal for the 'assume' macro: > (1) that the programmer may call it with an expression that involves > function calls, That's the status quo in Emacs and many other projects that have started believing the "an inline function is as fast as a macro" mantra*, assuming you include inline functions with "function calls". (* - as have I) > (2) that the generated code will never include these function calls, > because the generated code with the 'assume' invocation should be > optimized at least as well as the generated code without the > 'assume' invocation. I think it should be the rarest of exceptions for an assume() to result in slower code, yes. I believe that includes the case where functions marked inline aren't inlined, because of compiler options, for example. > I'm adding certain quality criteria: > - It is not "good" if a construct behaves unpredictably, that is, > if it hard to document precisely how it will behave. (*) Uhm, isn't the whole point of assume() to make the program behavior undefined in a certain case? int i = 1; assume(i == 0); will behave unpredictably. That's why we use the assume(), to speed up execution by providing the compiler with an expression which "may or may not be evaluated", and allowing it to do just anything if the expression evaluates to false. That's the documented API. If you want your program to behave predictably, in the strict sense, you cannot ever use the current assume() API. If you want it to behave predictably in some looser sense, the sense I suggest is that assume(C) may or may not evaluate C. Again, that's what the documentation says. > - It is not "good" if the behaviour with no LTO is different from > the behaviour with LTO. I agree I should investigate the LTO example further, but please let's keep in mind that I observed problematic behavior of assume(A && B) in other contexts, so I'm not convinced LTO is the decisive factor here. However, optimization can and will influence program behavior in many ways. One of these ways is whether the argument to assume, which the programmer knows "may or may not be evaluated", is evaluated or not. > The implementation with the __builtin_constant, while attaining the > goals (1) and (2), does not satisfy the two quality criteria. For the record, my quality criteria are: (1) implement the documented API, and don't change it (2) when optimizing for speed, do not produce slower code with eassume() than we would without it. Even when the programmer wrongly guessed that a function would be inlined. (3) when optimizing for size, do not produce larger code with eassume() than we would without it. Even when inline functions are not inlined. (4) be at least as fast as gnulib assume() > I believe the only way to attain the goals and the quality criteria > is, as you suggested, to ask the GCC people to add a __builtin_assume > built-in. I think there's a significant probability that the GCC people would agree to add such a built-in, but insist on its having "may or may not evaluate its argument" semantics. > > > 1. The new 'assume' is worse when -flto is in use. > > > > Maybe. Even if it is, though, that's a GCC limitation which I consider > > likely to be fixable > > Yes, *maybe* the GCC people can change the semantics of __builtin_constant_p > so that it is effectively computed at link-time, rather than when a single > compilation unit gets compiled. Or maybe not. I don't know... Hmm. My observations suggest that __builtin_constant_p is effectively computed at link-time; all I have to do is to split the assume() in your example. > > It's way too easy to do something like > > > > eassume(ptr->field >= 0 && f(ptr)); > > > > when what you mean is > > > > eassume(ptr->field >= 0); > > eassume(f(ptr)); > > I argue that it's unnatural if the two don't behave exactly the same. But you're arguing for a __builtin_assume which doesn't evaluate its argument, still? Because { i++; __builtin_assume(i == 0); __builtin_assume(infloop()); i++; } could validly be optimized to i = 1, while { i++; __builtin_assume(i == 0 && infloop()); i++; } could not be. Or did I misunderstand the semantics you suggested for __builtin_assume? > Like everyone expects that > x = foo ? yes : no; > is equivalent to > if (foo) x = yes; else x = no; It is. > And everyone expects that > if (A && B) { ... } > is equivalent to > if (A) if (B) { ... } It is. Sorry if I'm being a bit dense here. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 17:09:02 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 21:09:02 +0000 Received: from localhost ([127.0.0.1]:43115 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgy7C-0003wn-6L for submit@debbugs.gnu.org; Fri, 28 Jun 2019 17:09:02 -0400 Received: from mail-ot1-f43.google.com ([209.85.210.43]:38701) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hgy79-0003wI-7F for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 17:08:59 -0400 Received: by mail-ot1-f43.google.com with SMTP id d17so7381496oth.5 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 14:08:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=QW6GJ17RcApLJ0bedi3bJIJcQTUOF7Dj6Fs1p6O1CZk=; b=Efw8jNrqi7IsFhX1nVwHkq5k18FZ5yL/h6jJIJ04bhnnkI/Sq+g6LCT25EqWhvNRrD CG8yTjMbKh7GqU6gE4JfueHFl8Jjj0rM8bF1OijfMLUIp7CW8Sh9wi9mIGYUPiXSg2zb FsTt3gMva54PNRv2DonEjqGnwF8Q6Yu0Vy5Jbr1IcM2EFS0Dsxo+ghPp4eaYd+hIypMb teOXzKa4pRXtyl03MER/makzNFIcqolsm7Hi+ZqjiFr8aW/+HyE/TYLbvUruT4QZKXWQ +N6t9PycFsv3n7o9wZZ3jJI+cNPF9wAbZ1AoCz1OlkcTtwtXL8vdi3kanxz8yURLC2bq RHUg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=QW6GJ17RcApLJ0bedi3bJIJcQTUOF7Dj6Fs1p6O1CZk=; b=e3ec4ZMOjR0kOjWYUwMM+7nM04luAsWcqgY4NRFZ9JSptHrJ8cpJc08XVomnGM+2nK UrbMdtTu4lOAHaFz9L0OX+xX8+KOqXNyY7jdB8wOafKYk+8CRR0UrPir1R6EjneKSsgm gadHJxReYjlMdGYienNbFy3YEsMu/lnR3IMqr6Mxtr4SwSwObckIgQZceSxkayAyXQqV rLiEnWuUPh7IDClN10MWQsraj4nWi8CDIy2ZBof9b/gpBxPxB/JX1D/Qb5SYwFYiFguX zi6sbhokr3e+woaK7SbSk01H/tyjwoEB0ZEv4IH4pMp1LSrXbBmNdTl0gr+JDuNbt9KK 1/Qg== X-Gm-Message-State: APjAAAWlaQ62Nr/Dr8DgHIYrHWRJ3aj6hFh+4Znr0HyVWN/hAkzES6jC dUntrLnHvJLiqPxYd461uCobaq1SkbpIJisQGz0= X-Google-Smtp-Source: APXvYqx6K+Y1ma3t9zIbof8mDv7MHaYvluyTjbpybk9Q8Lp2epXUYWFXm5mgd9n/8RI2yfhSoLj1/e5/dyxaU0MfQlA= X-Received: by 2002:a9d:7284:: with SMTP id t4mr10571608otj.154.1561756133792; Fri, 28 Jun 2019 14:08:53 -0700 (PDT) MIME-Version: 1.0 References: <2490928.QNlPtjyuh0@omega> In-Reply-To: <2490928.QNlPtjyuh0@omega> From: Pip Cet Date: Fri, 28 Jun 2019 21:08:18 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) > Options Result > none increment > -DASSUME_GNULIB increment > -DTWO_ASSUMES single-store > -DASSUME_GNULIB -DTWO_ASSUMES increment Thanks, I should have included that. However, please note that in the -DASSUME_GNULIB cases, global will have a final value of 2, as it's incremented by f as well as by main; in the "none" case, it will have a final value of 1. From debbugs-submit-bounces@debbugs.gnu.org Fri Jun 28 19:30:18 2019 Received: (at 36370) by debbugs.gnu.org; 28 Jun 2019 23:30:18 +0000 Received: from localhost ([127.0.0.1]:43170 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh0Ju-00082r-3B for submit@debbugs.gnu.org; Fri, 28 Jun 2019 19:30:18 -0400 Received: from mo4-p01-ob.smtp.rzone.de ([85.215.255.53]:24819) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh0Jq-00082T-R7 for 36370@debbugs.gnu.org; Fri, 28 Jun 2019 19:30:16 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561764612; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=cYsmjqwtpXxnTJoa7z+/gsFh01ttYXSjKaz0dq8zJIs=; b=bCAN5XBVD4CX7y4aBjp8qScakbQtuUwt0r+GLNwNLYrRNrVdmIV32dArFINWNxmb3X B0wkIycA2MDfU+ywmMZqJc82qnd1hEgY0vRVz72fxVsSP/CoCsiFuBgPU9KAfZ1YdlGN fcD3tkwxKzApXLI3d2ByVCM+GzNTjVDEbhSyY20UVJRiPgoYuKUI/0PW7YZX+ztxyzRS mqdLOJM4Zo/GAnLYPjvM19iiR/jMeE6K5vRYh+zyfJsdrF/6B5NAZ3Cw1VbObOa+DNMh 72k28WG4JRCONOziB+Ic5GGASTX6XQM2HYraOQRcfVEm+7f9y9ABBFdtPtVqOruxW9dW 5U5w== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5SNU7kUW (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Sat, 29 Jun 2019 01:30:07 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Sat, 29 Jun 2019 01:30:06 +0200 Message-ID: <2067160.1HRgjLhtDS@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: <11002295.LrvMqknVDZ@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet wrote: > have started believing the "an inline function is as fast as a macro" > mantra*, assuming you include inline functions with "function calls". Ah, that's where the entire topic with the function calls inside assume() comes from! I agree it's an important case (more important than the functions defined in other compilation units). So let's test this: ==================================== foo.c ==================================== #include #define assume(R) ((R) ? (void) 0 : __builtin_unreachable ()) //#define assume(R) (!__builtin_constant_p (!(R) == !(R)) || (R) ? (void) 0 : __builtin_unreachable ()) #if USE_MACROS # define complicated(i) (((i) & 7) == 3) # define nonnegative(i) ((i) >= 0) #else static inline int complicated (int i) { return (i & 7) == 3; } static inline int nonnegative (int i) { return i >= 0; } #endif #if COMPLEX_CONDITION # define CONDITION complicated (i) && nonnegative (i) #else # define CONDITION nonnegative (i) #endif int f_generic (int i) { printf("%d\n", i & 0x80000000); return 0; } int f_condition (int i) { if (CONDITION) printf("%d\n", i & 0x80000000); return 0; } int f_assume (int i) { assume (CONDITION); printf("%d\n", i & 0x80000000); return 0; } =============================================================================== $ gcc -O2 -m32 -S foo.c && fgrep -v .cfi foo.s Results: // old 'assume', !COMPLEX_CONDITION, USE_MACROS -> f_assume optimized // old 'assume', COMPLEX_CONDITION, USE_MACROS -> f_assume optimized // old 'assume', !COMPLEX_CONDITION, !USE_MACROS -> f_assume optimized // old 'assume', COMPLEX_CONDITION, !USE_MACROS -> f_assume optimized // new 'assume', !COMPLEX_CONDITION, USE_MACROS -> f_assume optimized // new 'assume', COMPLEX_CONDITION, USE_MACROS -> f_assume optimized // new 'assume', !COMPLEX_CONDITION, !USE_MACROS -> f_assume not optimized // new 'assume', COMPLEX_CONDITION, !USE_MACROS -> f_assume not optimized So, the main effect of the proposed new 'assume' is that it de-optimizes the case where the CONDITION is defined using inline functions! The other case - that the CONDITION calls functions defined in other compilation units - is a fringe case. And the topic regarding the COMPLEX_CONDITION versus simple condition is also less important. Based on these results, I formally object against the proposed patch. > > (2) that the generated code will never include these function calls, > > because the generated code with the 'assume' invocation should be > > optimized at least as well as the generated code without the > > 'assume' invocation. > > I think it should be the rarest of exceptions for an assume() to > result in slower code, yes. I believe that includes the case where > functions marked inline aren't inlined, because of compiler options, > for example. Then, I think we should change the documentation of 'assume' to say that when it invokes functions, these functions should be marked '__attribute__ ((__always_inline__))', otherwise performance will be worse than without the 'assume', not better. > (1) implement the documented API, and don't change it > (2) when optimizing for speed, do not produce slower code with > eassume() than we would without it. Even when the programmer wrongly > guessed that a function would be inlined. > (3) when optimizing for size, do not produce larger code with > eassume() than we would without it. Even when inline functions are not > inlined. > (4) be at least as fast as gnulib assume() You evidently have slightly different quality criteria than I do. :) > > I believe the only way to attain the goals and the quality criteria > > is, as you suggested, to ask the GCC people to add a __builtin_assume > > built-in. > > I think there's a significant probability that the GCC people would > agree to add such a built-in, but insist on its having "may or may not > evaluate its argument" semantics. We can tell them that it would be important for us that is does not evaluate its argument. Like sizeof (EXPRESSION) does not evaluate EXPRESSION. > Sorry if I'm being a bit dense here. No problem. I'm also often being dense. Bruno From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 01:40:23 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 05:40:23 +0000 Received: from localhost ([127.0.0.1]:43284 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh662-0000by-Qr for submit@debbugs.gnu.org; Sat, 29 Jun 2019 01:40:23 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:33100) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh65z-0000bi-QY for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 01:40:20 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 41254161D2F; Fri, 28 Jun 2019 22:40:13 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id Ob7PtY4CQjmP; Fri, 28 Jun 2019 22:40:12 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 888DB161D50; Fri, 28 Jun 2019 22:40:12 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id NHV0lOJ12gs5; Fri, 28 Jun 2019 22:40:12 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 59AA3161D2F; Fri, 28 Jun 2019 22:40:12 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible , Pip Cet References: <11002295.LrvMqknVDZ@omega> <2067160.1HRgjLhtDS@omega> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: Date: Fri, 28 Jun 2019 22:40:12 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: <2067160.1HRgjLhtDS@omega> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Bruno Haible wrote: > I think we should change the documentation of 'assume' to say > that when it invokes functions, these functions should be marked > '__attribute__ ((__always_inline__))', otherwise performance will > be worse than without the 'assume', not better. I suggest something simpler and a little more general. The Emacs documentation for 'eassume' says this: This can improve performance in some cases, though it can degrade performance in others. It's often suboptimal for COND to call external functions or access volatile storage. and we could migrate that into the documentation for 'assume'. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 01:41:10 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 05:41:10 +0000 Received: from localhost ([127.0.0.1]:43288 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh66o-0000dU-6J for submit@debbugs.gnu.org; Sat, 29 Jun 2019 01:41:10 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:33198) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh66m-0000dF-Ly for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 01:41:08 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 59C4C161D2F; Fri, 28 Jun 2019 22:41:03 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id 0Yrq8wcTs_dY; Fri, 28 Jun 2019 22:41:02 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 918ED161D50; Fri, 28 Jun 2019 22:41:02 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id eFmXQ182X_fy; Fri, 28 Jun 2019 22:41:02 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 636D1161D2F; Fri, 28 Jun 2019 22:41:02 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: <87168b28-192b-6666-e9b6-9cdc2ed3917a@cs.ucla.edu> Date: Fri, 28 Jun 2019 22:41:02 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Pip Cet wrote: > eassume (global == 0); > eassume (f ()); > #else > eassume (global == 0 && f ()); > ... > extern int global; > > int f(void) > { > return ++global; > } This is not a valid use of 'assume'. It's documented that assume's argument should be free of side effects. It would be nice if 'assume (R)' reported an error if R has side effects, and generated a warning unless the compiler can verify that R is free of side effects. However, these niceties would require better support from the compiler. > If you want your program to behave predictably, in the strict sense, > you cannot ever use the current assume() API. I'm not sure what you mean by "in the strict sense". It's true that programs can misuse 'assume' and get undefined behavior, but that's kind of the point.... From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 01:45:06 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 05:45:06 +0000 Received: from localhost ([127.0.0.1]:43292 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh6Ab-0000jC-QG for submit@debbugs.gnu.org; Sat, 29 Jun 2019 01:45:06 -0400 Received: from mail-oi1-f194.google.com ([209.85.167.194]:34745) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh6Aa-0000iQ-Dl for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 01:45:04 -0400 Received: by mail-oi1-f194.google.com with SMTP id l12so5905760oil.1 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 22:45:04 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=ZQpCeJ5oSnrBRe/lcvYLFsZuVGlB2HREI6j35y2nIgQ=; b=nEAWKNVdrzCho06gFQS89/Zy1xxjx9C9JQ+rYrzxurtuMUIIAMRJEvQkvIkwK77qXN fAUrp+0WEcwUdqACAlZ+QL3C//VjyGKlGgJhIc0eKGQ6DUQFfVQUyHhu8dRx4XmthZGq W0pYRe16k8lWw8/l74ZoIaofDMjWpKs8BsIoeD3mxLaLNYD0gWYcYIHsYRQzD/sXZHGC WeyRw2LshALDrg9vBW/xio1zzwcjGl12cvz3YrEzPyjOpPhoq9djLsmo7wlMzj5rxYFp GoSDrlClWivEoE/rSHl5Fy4fBVTGpbYWaWboD/L+4eJUlC8239PlwELkUb5+7I3cEW3X vEdQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=ZQpCeJ5oSnrBRe/lcvYLFsZuVGlB2HREI6j35y2nIgQ=; b=YPBV4z9RcwFHxSECJQC2ss4MsKe2YEOmWA6lH3SN2YbVgJcHNx4sHQ34DoxqCVm68n VDY24whPADDSNxgzmBgf7fcuVnaOVo1Ro3D8uzRZ+uGSQVc/hM58THwZQUyKOYViAObU nCkqurdQk/eterTvmS7I6UDvCKac1gedY5sv7VUc9CkQLrKVvEIf/XK1AHcDrX7sTZ15 WPIudxlKAgnGGUTkPhPl9bm2+ZKe2P6+p6lPFov84jcquP9GnPNdrSeUy7ntTjEBM0sO K9fp6aP/Sl8OqizXy6WqsdL9LZiGahoXM7xm+edwadoVdhBYIoJ7T9gB48zWkQEXOm3R 7HOg== X-Gm-Message-State: APjAAAXvhgIeRLzDd4JP6tC4fW7/R4znajsn4jJva+R904HPFzYeghDh 4gMILzeEuJIQetyjQXeDZGmyrE3tW7j3/WngVnI= X-Google-Smtp-Source: APXvYqwr4B01jYHQa5TvncWJM5QnnaWy1G+fZcmOboqRk7JIWi2jx1qt9z+ArRNTvUssVPUmQTXQCc9mO+LW+AXTesQ= X-Received: by 2002:a05:6808:313:: with SMTP id i19mr800977oie.30.1561787098322; Fri, 28 Jun 2019 22:44:58 -0700 (PDT) MIME-Version: 1.0 References: <11002295.LrvMqknVDZ@omega> <2067160.1HRgjLhtDS@omega> In-Reply-To: <2067160.1HRgjLhtDS@omega> From: Pip Cet Date: Sat, 29 Jun 2019 05:44:22 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Fri, Jun 28, 2019 at 11:30 PM Bruno Haible wrote: > Pip Cet wrote: > > have started believing the "an inline function is as fast as a macro" > > mantra*, assuming you include inline functions with "function calls". > > Ah, that's where the entire topic with the function calls inside assume() > comes from! I agree it's an important case (more important than the > functions defined in other compilation units). As I said earlier: ---- This makes it safe to use function expressions in eassume, whether the function is inlined or not. (That GCC doesn't actually do very much with this information is a separate issue). ---- So we're talking about this separate issue now? I ask not for rhetorical points, but because I genuinely think it's interesting if the objection is based on GCC limitations rather than fundamentally unfixable reasons. > So, the main effect of the proposed new 'assume' is that it de-optimizes > the case where the CONDITION is defined using inline functions! (I don't think it's the "main" effect). That certainly is something that appears to be happening in some situations. It's a GCC limitation, and let's be clear: as long as this limitation isn't lifted, an inline function is not as fast as a macro. However, passing an inline function to assume() is problematic anyway, unless it's marked as __attribute__((always_inline)), and marking it as __attribute__((always_inline)) is problematic because it might directly contradict what the programmer was trying to achieve by passing -fno-inline. > Based on these results, I formally object against the proposed patch. I won't argue against that as long as I haven't found a way around the GCC issue, but I would like to state that the current assume does behave very badly when combined with -fno-inline-small-functions -fno-inline. > > > (2) that the generated code will never include these function calls, > > > because the generated code with the 'assume' invocation should be > > > optimized at least as well as the generated code without the > > > 'assume' invocation. > > > > I think it should be the rarest of exceptions for an assume() to > > result in slower code, yes. I believe that includes the case where > > functions marked inline aren't inlined, because of compiler options, > > for example. > > Then, I think we should change the documentation of 'assume' to say > that when it invokes functions, these functions should be marked > '__attribute__ ((__always_inline__))', otherwise performance will > be worse than without the 'assume', not better. I disagree. It's tedious, and people might just change their INLINE macros (or whatever) to specify __attribute__((always_inline)), making -fno-inline worthless... > > I think there's a significant probability that the GCC people would > > agree to add such a built-in, but insist on its having "may or may not > > evaluate its argument" semantics. > > We can tell them that it would be important for us that is does not > evaluate its argument. Like sizeof (EXPRESSION) does not evaluate EXPRESSION. We can tell them that, but my suspicion is it'll be much, much harder to implement that way. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 02:49:09 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 06:49:09 +0000 Received: from localhost ([127.0.0.1]:43325 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh7Ab-0002D9-BN for submit@debbugs.gnu.org; Sat, 29 Jun 2019 02:49:09 -0400 Received: from mail-ot1-f53.google.com ([209.85.210.53]:47013) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hh7AZ-0002Cj-17 for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 02:49:07 -0400 Received: by mail-ot1-f53.google.com with SMTP id z23so8277936ote.13 for <36370@debbugs.gnu.org>; Fri, 28 Jun 2019 23:49:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=hD3ut1+pbXdOV0ycwQ29ox85TCsAAAFashPhxHw5mYA=; b=HkpJVVSFM9IOCealP27mHRdy3D279zU4R+3tDJpY1j9rivYXxkJOY660l8G4OSROON yE4aTjq/v3o8woU56u1DrS6wCFHMMz5SV1mfD5qpYQ+BkeKCENIn7v/dtonp22kupLux gkk+H1JVkSQJYomj3AVntM/xmGU6m8AEuPP22c/qscrdxa6nWXS0idQ9CrLec9vY+MoR iY32a3r9nVV47vdAkonlAtulK6MWzm1xDaSmFgo3sVQ9Fg8hY9SmPR6Y1V6cOldBo08x WwAOd2t/EzO38Py+0c01PELz/Fx0dM1EGhKsKJvMJa6OF+GgzWtaXAVB4ykVqyRfxSqn u5uQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=hD3ut1+pbXdOV0ycwQ29ox85TCsAAAFashPhxHw5mYA=; b=F3jhBjTpiyZKHu+4tjnHNmOG5J0chZHWyqD5kTSCMiGOti9Ork5m1rCrgC4eaN5Xiu SKcFah24mrLMdsSsqnXQ859QEcPL1WXDOgmHV9WfLBpyhOasrEV8XHSQNvvUTDoogCCe s6IWtQGgfzadzwJ3fpGAIxv+eTvDftpTTM5m26T4rlFiTKO1Rp0q0w/bbnC9e8EcIizK 6BPdtl/U6Y7lno2NL9sVPBdD4eMTb8NEr2/9DnkWXvnG4IIF+QEBWX3IV6YVSOoe+IzJ dMhz1leFKJNwxUZHo/rOW+xu+ayKxQ/fKNvqepM79fuVvYS3CSmoKYV5EZp2cpTd0FfQ RmTg== X-Gm-Message-State: APjAAAVuqxJhHeqVxBvXnCGGpVDHpBcoi6r++oSitLxvPwr2amqQAbjb Wposgw4LAOGZjmt/zbT1oEGhjcjhCDTd+NOd5xc= X-Google-Smtp-Source: APXvYqzp2b9dcMMY9wYKOeIgxSJCpohkv1UZa1gotXg87XDrUJDNzYVX5AWyGajjNJ3u0QAv8XfhfXFzFWzjqS67UVA= X-Received: by 2002:a9d:664c:: with SMTP id q12mr10363945otm.175.1561790941372; Fri, 28 Jun 2019 23:49:01 -0700 (PDT) MIME-Version: 1.0 References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> <87168b28-192b-6666-e9b6-9cdc2ed3917a@cs.ucla.edu> In-Reply-To: <87168b28-192b-6666-e9b6-9cdc2ed3917a@cs.ucla.edu> From: Pip Cet Date: Sat, 29 Jun 2019 06:48:24 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sat, Jun 29, 2019 at 5:41 AM Paul Eggert wrote: > Pip Cet wrote: > > eassume (global == 0); > > eassume (f ()); > > #else > > eassume (global == 0 && f ()); > > ... > > extern int global; > > > > int f(void) > > { > > return ++global; > > } > > > This is not a valid use of 'assume'. It's documented that assume's argument > should be free of side effects. But the compiler makes no such assumption, so it cannot optimize assume(i >= 0 && f()), (where i is a global or a non-const pointer to i has potentially leaked) unless f happens to be available at optimization time. I think this is an interesting point: if GCC decided to add a __builtin_assume() builtin, we could give it slightly different semantics: that the expression passed to it evaluates to true, but doesn't evaluate to false or fail to evaluate. Something like __attribute__((does_return)) might do on a function. However, if I'm not too confused, we're discussing whether assume(SIMPLE_CONDITION && COMPLICATED_CONDITION) is ever a good idea. With the old assume, it's harmful. With the new assume, it's pointless. Is assume(SIMPLE_CONDITION); assume(COMPLICATED_CONDITION); a good idea? With the old assume, it's harmful. With the new assume, it's a more verbose way of simply assuming SIMPLE_CONDITION, so it might be a good idea. Also, "should" doesn't mean "must", does it? I'd prefer rewording that sentence as "R may or may not be evaluated: it should not normally have side-effects". > It would be nice if 'assume (R)' reported an error if R has side effects, and > generated a warning unless the compiler can verify that R is free of side > effects. However, these niceties would require better support from the compiler. But if we had that support from the compiler, wouldn't it be even nicer to give up (most of) the distinction between assert and assume and just tell people to use assume? That idea was my starting point, and I'm still convinced it would result in better code overall. Except someone would have to grep a little once in a while and replace most eassume (A && B) expressions with eassume (A); eassume (B); However, there are a few tricks we can use to verify this in special debug builds. ------ Putting inner functions into sections: #define assume(C) ({ auto void inner (void) __attribute__((section("only_trivial_functions_go_here"), used)); void inner(void) { (void)(C); } (void) 0; }) Then verify that the section contains only trivial function definitions. (For the record, for Emacs, it does). Another approach for detecting when (C) has "global" side effects (such as calling an external function) is to do this: ------- #include int global; extern void dummy(void (*)(void)) __attribute__((warning ("assume might have side effects"))); #define C printf("3") int main(void) { auto void inner(void) __attribute__((used)); void inner(void) { if (global) __builtin_unreachable (); (void)(C); if (global) dummy(inner); } } ----- A third possibility is to use __builtin_constant_p(!(C)!=!(C)), as the patch does. That doesn't state precisely that C has no side effects, but it does come fairly close in practice ... except for the inline function problem. > > If you want your program to behave predictably, in the strict sense, > > you cannot ever use the current assume() API. > > I'm not sure what you mean by "in the strict sense". It's true that programs can > misuse 'assume' and get undefined behavior, but that's kind of the point.... Precisely what I meant. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 06:31:35 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 10:31:35 +0000 Received: from localhost ([127.0.0.1]:43510 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhAdq-0001Lk-WC for submit@debbugs.gnu.org; Sat, 29 Jun 2019 06:31:35 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.22]:24207) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhAdo-0001Lb-G3 for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 06:31:34 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561804290; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=ZrpzzZ86xSTJdW1fP5mHnYFwebioHLmIMtiUZo2aIWI=; b=MYFDWMDor7u4xXNEQCn61+ZXzd2Kji8qWt18Ka/XnO3F78Qjjo75Tqddsux8gje+zr sNczm+eblymURgwgQWfph8H4dU3fJwdByElFwFgZ82wZoj+FF1UhwxVkTD9LC+WhX4vH FTpSAtjIwPxRT1+JDaD4Qck0xJDjp28oqviJnygV5WNF+HpcRl+0BfQvtBrj8Dv2nRGE 8myGywvhYBGKPBLqhJwQ9iaXhG5ddXWdcVu+MtmI8oJD4nyWkzY2NsoUnyKV6Zt3vnhx JPiweuOhWEucpsaekaSo4O0iZgsvqBOE9Y8o44nYQIWckbsMSYZM3OVnq5bBNHVMFwI4 H20w== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5TAVSlqL (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Sat, 29 Jun 2019 12:31:28 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Sat, 29 Jun 2019 12:31:27 +0200 Message-ID: <2515002.Q0mBYvUW8C@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: <2067160.1HRgjLhtDS@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet wrote: > I would like to state that the current assume does > behave very badly when combined with -fno-inline-small-functions > -fno-inline. Since we can't address this limitation through an acceptable change to the 'assume' macro, we need to address it through documentation. > marking it > as __attribute__((always_inline)) is problematic because it might > directly contradict what the programmer was trying to achieve by > passing -fno-inline. __attribute__((always_inline)) exists precisely to make a distinction between functions where inlining is usually desirable vs. functions where inlining is essential. We don't need to warn against the uses of __attribute__((always_inline)) -- confusing behaviour in the debugger etc. -- becauses these drawbacks are already well-known. Paul Eggert wrote: > I suggest something simpler and a little more general. The Emacs documentation > for 'eassume' says this: > > This can improve performance in some cases, > though it can degrade performance in others. It's often suboptimal > for COND to call external functions or access volatile storage. > > and we could migrate that into the documentation for 'assume'. As a user of the 'assume' macro, I want a definitive statement about what I need to provide so that the macro works in the sense of improved performance. A statement about "often" is too vague. How about this proposed patch? diff --git a/lib/verify.h b/lib/verify.h index f8e4eff..ed1ba19 100644 --- a/lib/verify.h +++ b/lib/verify.h @@ -261,7 +261,10 @@ template /* Assume that R always holds. This lets the compiler optimize accordingly. R should not have side-effects; it may or may not be - evaluated. Behavior is undefined if R is false. */ + evaluated. The behavior is undefined if R is false. + If you want the use of this macro to improve, not deteriorate, + performance, R should not contain function calls except to functions + that are declared 'inline __attribute__((__always_inline__))'. */ #if (__has_builtin (__builtin_unreachable) \ || 4 < __GNUC__ + (5 <= __GNUC_MINOR__)) From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 13:11:56 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 17:11:56 +0000 Received: from localhost ([127.0.0.1]:44862 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhGtI-0004ix-A0 for submit@debbugs.gnu.org; Sat, 29 Jun 2019 13:11:56 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:50308) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhGtG-0004iY-8c for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 13:11:55 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 1C3D2161D51; Sat, 29 Jun 2019 10:11:48 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id lpYml8JESCC8; Sat, 29 Jun 2019 10:11:43 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 9C00B161D92; Sat, 29 Jun 2019 10:11:43 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id nWbzsneUassO; Sat, 29 Jun 2019 10:11:43 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 59286161D51; Sat, 29 Jun 2019 10:11:43 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible , Pip Cet References: <2067160.1HRgjLhtDS@omega> <2515002.Q0mBYvUW8C@omega> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: <99bacb9f-1192-1315-85d7-5ab4924dfef8@cs.ucla.edu> Date: Sat, 29 Jun 2019 10:11:40 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: <2515002.Q0mBYvUW8C@omega> Content-Type: multipart/mixed; boundary="------------5B2A11EADDDA2B68ABEB62B9" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------5B2A11EADDDA2B68ABEB62B9 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Bruno Haible wrote: > + If you want the use of this macro to improve, not deteriorate, > + performance, R should not contain function calls except to functions > + that are declared 'inline __attribute__((__always_inline__))'. */ A reader of that might incorrectly conclude that using such functions will always improve performance, compared to using functions not declared that way. And I'm leery of putting such GCC-specific info into the documentation of a generic macro. Also, given Pip Cet's misunderstanding it'd be helpful to add a word or two about the intent of 'assume (R)'. How about the attached patch? > - evaluated. Behavior is undefined if R is false. */ > + evaluated. The behavior is undefined if R is false. This is a nit, but to my ears the shorter version is better, and has a more-accurate connotation as "the behavior" connotes "the behavior of 'assume (R)'", whereas behavior is also undefined for code before or after a call to an incorrect 'assume (R)'. --------------5B2A11EADDDA2B68ABEB62B9 Content-Type: text/x-patch; name="verify.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="verify.diff" diff --git a/lib/verify.h b/lib/verify.h index f8e4eff02..168a7afdb 100644 --- a/lib/verify.h +++ b/lib/verify.h @@ -259,9 +259,11 @@ template # define __has_builtin(x) 0 #endif -/* Assume that R always holds. This lets the compiler optimize - accordingly. R should not have side-effects; it may or may not be - evaluated. Behavior is undefined if R is false. */ +/* Assume that R always holds. Behavior is undefined if R is false. + R should lack side effects, as it may be evaluated only partially. + Although 'assume (R)' is typically intended to help performance, + performance may degrade if R uses hard-to-optimize features + such as calls to non-inlined functions. */ #if (__has_builtin (__builtin_unreachable) \ || 4 < __GNUC__ + (5 <= __GNUC_MINOR__)) --------------5B2A11EADDDA2B68ABEB62B9-- From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 13:31:45 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 17:31:45 +0000 Received: from localhost ([127.0.0.1]:44874 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhHCQ-0005HK-LJ for submit@debbugs.gnu.org; Sat, 29 Jun 2019 13:31:44 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:51756) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhHCN-0005Gn-2c for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 13:31:40 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 91C66161D51; Sat, 29 Jun 2019 10:31:32 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id GLMV5O1SKavM; Sat, 29 Jun 2019 10:31:31 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 9455E161D92; Sat, 29 Jun 2019 10:31:31 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id lL41p-qcONmX; Sat, 29 Jun 2019 10:31:31 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 3C544161D51; Sat, 29 Jun 2019 10:31:31 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Pip Cet References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> <87168b28-192b-6666-e9b6-9cdc2ed3917a@cs.ucla.edu> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: <791ae316-3a6f-605a-0da5-874fe3d224c5@cs.ucla.edu> Date: Sat, 29 Jun 2019 10:31:30 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.1 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 7bit X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) Pip Cet wrote: >> This is not a valid use of 'assume'. It's documented that assume's argument >> should be free of side effects. > > But the compiler makes no such assumption Sure, but if the caller uses 'assume' contrary to its documentation, that's a problem with the caller's code, not with 'assume'. It's merely an implementation detail as to which pothole the problematic code runs into. > if GCC decided to add a > __builtin_assume() builtin, we could give it slightly different > semantics: that the expression passed to it evaluates to true, but > doesn't evaluate to false or fail to evaluate. Something like > __attribute__((does_return)) might do on a function. Yes, the expression should return true without side effects or looping. I don't see this as an significant difference in semantics. One should also not call Gnulib assume (R) with an expression that loops forever, as this defeats the intent of 'assume' which is to make code more efficient. If there's any real confusion about this issue, we can add it to the 'assume' documentation as well. > Also, "should" doesn't mean "must", does it? It's not the "should" of an Internet RFC. It's more the "should" of "you should do this, and if you don't you're on your own". > I'd prefer rewording that > sentence as "R may or may not be evaluated: it should not normally > have side-effects". Better to say that it should not have side effects at all. There's no "normally" about that. Side effects are trouble. > wouldn't it be even > nicer to give up (most of) the distinction between assert and assume > and just tell people to use assume? No, because 'assert (false)' has well-defined behavior, whereas behavior is undefined for programs that do 'assume (false)' . This is a fundamental difference between the two. From debbugs-submit-bounces@debbugs.gnu.org Sat Jun 29 13:48:46 2019 Received: (at 36370) by debbugs.gnu.org; 29 Jun 2019 17:48:46 +0000 Received: from localhost ([127.0.0.1]:44883 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhHSt-0005ig-S6 for submit@debbugs.gnu.org; Sat, 29 Jun 2019 13:48:46 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.25]:20893) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhHSr-0005iW-2h for 36370@debbugs.gnu.org; Sat, 29 Jun 2019 13:48:42 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561830518; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=tcdPX/lsQ4mdwRf039gNRd9OEZp4iTKFtb5VAL3oGyE=; b=HqKe8loo4xSBWi4RBGW7lV2XL4+EOjsANsJNkakAA7A1uKPkP9MTG2jNzjkItFU2fx XdBXQgey3b1yDNVKQU4ZrNlCmrktGleeAPi0z20ctsYhf5XVcgbh4uF+M/J41yO/Invo Hi+StF0UHofZUlBZZQ4qHjFLs9va/17sq4NBPXIWpbU0y+7MA7m0xIDLKZOlekFm48Vb F48sa4qT/xzzL3evTA/6x+ltTep0LNi7THLPbde2VtJOviXCZd3/k64Nh1LIxmj1d8jH eXKjiOeJBdD6/H2oQXKlsxDuwpjlb2I1AFHgZFSH5CYX7ea6qLEkKThYvpjBquHxBAXL Kzvg== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5THmbmwQ (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Sat, 29 Jun 2019 19:48:37 +0200 (CEST) From: Bruno Haible To: Paul Eggert Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Sat, 29 Jun 2019 19:48:37 +0200 Message-ID: <3251111.n4rrPxjoDE@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: <99bacb9f-1192-1315-85d7-5ab4924dfef8@cs.ucla.edu> References: <2515002.Q0mBYvUW8C@omega> <99bacb9f-1192-1315-85d7-5ab4924dfef8@cs.ucla.edu> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Pip Cet X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Hi Paul, > > + If you want the use of this macro to improve, not deteriorate, > > + performance, R should not contain function calls except to functions > > + that are declared 'inline __attribute__((__always_inline__))'. */ > > A reader of that might incorrectly conclude that using such functions will > always improve performance, compared to using functions not declared that way. For functions not declared 'inline __attribute__((__always_inline__))', it depends on the inlining heuristics of the compiler whether the 'assume (R)' will be a performance improvement or the opposite. > Also, given Pip Cet's misunderstanding it'd be helpful to add a word or two > about the intent of 'assume (R)'. > > How about the attached patch? That's a good compromise. > > - evaluated. Behavior is undefined if R is false. */ > > + evaluated. The behavior is undefined if R is false. > > This is a nit, but to my ears the shorter version is better OK, fine. Bruno From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 30 05:22:40 2019 Received: (at 36370) by debbugs.gnu.org; 30 Jun 2019 09:22:40 +0000 Received: from localhost ([127.0.0.1]:45361 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhW2h-0003MS-Lf for submit@debbugs.gnu.org; Sun, 30 Jun 2019 05:22:39 -0400 Received: from mail-ot1-f46.google.com ([209.85.210.46]:39400) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhW2f-0003MG-Up for 36370@debbugs.gnu.org; Sun, 30 Jun 2019 05:22:38 -0400 Received: by mail-ot1-f46.google.com with SMTP id r21so9775143otq.6 for <36370@debbugs.gnu.org>; Sun, 30 Jun 2019 02:22:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=DAbu2eMK4hEG0OQXXkWrkKdZhuQJT2dldt2ueRttq2g=; b=auuh9t4Gy53z7T26827dtY7pff3ho1B7ybHzSvlMU5eKj/o9r1upPFle6iikCdpDz7 AGZzZm1EeTF2gfNAYo626JujMEVettO6NaCL1gkPGR+zwvRxaAKOALzFJzjTJ3w8FCgZ 7ZVyXe2zpEcg/xV7U0pAln4JIqNN2C4g9MVhY13onvXWoIHjtDC0GjqIL5C3UEWHZ0BU JymE/h8jI6ZtpF02wf3a/DWcTeceJqL8n98qhf/iF3w8RFya3D/r57rirV+X9UkCR77z 8r24fCSYSUZyxbhTVFu43JPqI37WzteP1Hfx2uRttUHVPIBUKAucWQO7fh0WKJ6v0xkP rQpA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=DAbu2eMK4hEG0OQXXkWrkKdZhuQJT2dldt2ueRttq2g=; b=rhux/DR1SOcprzmGQ8sGM7oD12uuiiMtzXq3PlWOzd3L1if+MCzAIdjSG2kVWmvKVi OieT6I56gmZqeRbdVqba2g+Q54L3655a6jjJyyogYnynlnv1RNumG+WxHAV3UCcDtDWh rbvdadYZDBcJu4uLyKIC9H2unfRXUExyOUipZFvUh+aJjLf2d34T9+DBXAumlI1Ic+hY mIMoa/CKUEXsLEQXhCj4ziB4rpPfqRrs54C9wYo5e/v2AuB9Lf8rqxxSEkkAuQPn6v5D jIY5aagu6wb6DDuvhPSvaWXaSLh1lT+moIhsWPDbVDdbFTlEMe9yrgkqOZu9kO/6mYGk RfWw== X-Gm-Message-State: APjAAAUPPt1xGHzGUuPhcG5VV6tFyc420d5EOeVZnu4EOQ+BgLBvc0O0 3nimEbGhF3hV+wFdbyR0NvVTXmuiBk2uuX0b7Gg= X-Google-Smtp-Source: APXvYqwdtFM7VRFaZSxuWppiVMOOORSZrhY8NZkpzIsZxo9FopXCN9VsnHJl5NvkhibEitzQ+xpFVG7JhZNRKa9cNjc= X-Received: by 2002:a9d:7284:: with SMTP id t4mr16343336otj.154.1561886552223; Sun, 30 Jun 2019 02:22:32 -0700 (PDT) MIME-Version: 1.0 References: <2715311.ceefYqj39C@omega> <8979488.cRkkfcT1mV@omega> <87168b28-192b-6666-e9b6-9cdc2ed3917a@cs.ucla.edu> <791ae316-3a6f-605a-0da5-874fe3d224c5@cs.ucla.edu> In-Reply-To: <791ae316-3a6f-605a-0da5-874fe3d224c5@cs.ucla.edu> From: Pip Cet Date: Sun, 30 Jun 2019 09:21:55 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Paul Eggert Content-Type: text/plain; charset="UTF-8" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Bruno Haible X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) On Sat, Jun 29, 2019 at 5:31 PM Paul Eggert wrote: > >> This is not a valid use of 'assume'. It's documented that assume's argument > >> should be free of side effects. > > > > But the compiler makes no such assumption > > Sure, but if the caller uses 'assume' contrary to its documentation, that's a > problem with the caller's code, not with 'assume'. It's merely an implementation > detail as to which pothole the problematic code runs into. I agree, for what it's worth, that the new documentation is clear on what is and isn't allowed with assume(). It's just that it's a significant API change from the previous state, and I dislike the API change. Again, this isn't about using `assume' contrary to its documentation, it's about using it in a way that the compiler cannot prove obeys the documented API, and thus handles suboptimally. > > if GCC decided to add a > > __builtin_assume() builtin, we could give it slightly different > > semantics: that the expression passed to it evaluates to true, but > > doesn't evaluate to false or fail to evaluate. Something like > > __attribute__((does_return)) might do on a function. > > Yes, the expression should return true without side effects or looping. I don't > see this as an significant difference in semantics. It's significant to GCC. It optimizes function calls that are known to return differently from ordinary function calls. > One should also not call > Gnulib assume (R) with an expression that loops forever, as this defeats the > intent of 'assume' which is to make code more efficient. No disagreement there. However, that doesn't mean the compiler is free to assume that assume()'s argument doesn't loop; it needs to prove that, whereas with the new __builtin_assume() builtin, it wouldn't have to go to that trouble. > If there's any real > confusion about this issue, we can add it to the 'assume' documentation as well. I think the new documentation is fine, in this regard. > > Also, "should" doesn't mean "must", does it? > > It's not the "should" of an Internet RFC. It's more the "should" of "you should > do this, and if you don't you're on your own". So if I add a debug print statement to an inline function that happens to be called in an eassume, I'm on my own? That's a significant API change. > > I'd prefer rewording that > > sentence as "R may or may not be evaluated: it should not normally > > have side-effects". > > Better to say that it should not have side effects at all. There's no "normally" > about that. Side effects are trouble. Except for debugging statements, other assert()s, abort()s, other assume()s, divisions by zero that happen in the eassume() code rather than after it... Again, I think there are two issues here: you want to change the API to be much more restrictive (my original patch intended to make it more lenient), and you want to document the new API. Obviously, the second point is fine. If the new requirement is that R has no side effects, we don't need the "R may or may not be evaluated". In fact, it might confuse others in the same way I was confused. I read the old documentation as: As far as side effects go, each assume(R) may decide, independently and unpredictably, whether side effects of R are visible or not: R may or may not be evaluated. This unpredictable behavior can be confusing; to avoid confusion, R RFC-SHOULD not have side effects. the new documentation, I read as: If R has any side effects, assume(R) is undefined. It can cause compilation, linking, or run-time errors. > > wouldn't it be even > > nicer to give up (most of) the distinction between assert and assume > > and just tell people to use assume? > > No, because 'assert (false)' has well-defined behavior, whereas behavior is > undefined for programs that do 'assume (false)' . This is a fundamental > difference between the two. Thus the "most of", yes. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 30 11:31:36 2019 Received: (at 36370) by debbugs.gnu.org; 30 Jun 2019 15:31:36 +0000 Received: from localhost ([127.0.0.1]:47146 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhbnj-0007Wi-FU for submit@debbugs.gnu.org; Sun, 30 Jun 2019 11:31:35 -0400 Received: from mail-ot1-f45.google.com ([209.85.210.45]:43021) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhbnh-0007RC-Hy for 36370@debbugs.gnu.org; Sun, 30 Jun 2019 11:31:34 -0400 Received: by mail-ot1-f45.google.com with SMTP id q10so961703otk.10 for <36370@debbugs.gnu.org>; Sun, 30 Jun 2019 08:31:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=hOtmnfP+RJE3PdINDxXV0EyMNi2emzrPpyvycAZLdxw=; b=KRttlW3A0u6k7lZzY/CalO34I79pXzOEuPJhOITarrz9EhfqbYMMnWSf7JEIy29WNY 4yiIYugBMxvMmjoVyjEetQcd64qH1jT3t82zq7BmxgOjPtr4J4Nh8GveI2yj4iKNyrzB xPMeJipdOH67XAPyxYBz7WVBfS8vjUzFMUy5fnHKlzb4HukTHPd5vSpIAubrn1xm9K44 arQKJKYpUMLGnht+d+5vl/6NU06Ff4NqhvBKV6hQcvZR0bkesJaCGH1Gf5axhtBchMD4 feUS9JEK6qw2rGSNXGjPSq6PStAzSl9cgw/g5V49087/VhMXfOCsGYwoUq48gYPCg9uz vHuA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=hOtmnfP+RJE3PdINDxXV0EyMNi2emzrPpyvycAZLdxw=; b=tnK+y+v9pC7JwpSFUPHgcxys3H+3cqbgF5B62esC5/keKgsvlc3rIM6rYb/H18q9Zy pb8WBPQ4cSUUZfTiFFu3ti5TR39Xfi6rO9kL6wIXpEPF4j8yzgVFNNSbILffHb/2vh5c TXYH+/xt4hesvncoA/ghJR2nqfzK7azieTDh3W3s3BLLdI5WWesf0mJv0N1kgRMHBT42 aBKZM8aw4PMLGf0eoMVvltVmMQiTFW873x1d5kLlwhQshmKcaBtwODeiOyWcAaRdkasQ Kv7YjBEEWovWTgdxznDyiJM8YDRW8GHK4GaLreKkh2z2J63/2UxNNe8W1HIqDhgeKU28 3fAw== X-Gm-Message-State: APjAAAW0sXxttAWhIgWpjI0U6g44HS1gbaCbgD29ucn0zAtFrW2kWDxZ egFxWXdQK34EBfI4hd+GlYOWjUb3PZKTPApnTBU= X-Google-Smtp-Source: APXvYqz5pQT1iMdmaQ47zRHTUl4PivBtKRtFAxEs7AeFbsNf0dpACUY8KSlomsCYueCZUz+ap9/vzQ8gFcobzbQqEGk= X-Received: by 2002:a9d:664c:: with SMTP id q12mr14928630otm.175.1561908687983; Sun, 30 Jun 2019 08:31:27 -0700 (PDT) MIME-Version: 1.0 References: <2067160.1HRgjLhtDS@omega> <2515002.Q0mBYvUW8C@omega> In-Reply-To: <2515002.Q0mBYvUW8C@omega> From: Pip Cet Date: Sun, 30 Jun 2019 15:30:51 +0000 Message-ID: Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible Content-Type: text/plain; charset="UTF-8" X-Spam-Score: -0.2 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.2 (-) On Sat, Jun 29, 2019 at 10:31 AM Bruno Haible wrote: > Pip Cet wrote: > > I would like to state that the current assume does > > behave very badly when combined with -fno-inline-small-functions > > -fno-inline. > > Since we can't address this limitation through an acceptable change > to the 'assume' macro, we need to address it through documentation. I agree. There's a limitation bad enough for me to consider it a bug in current GCC, and even if that's lifted tomorrow, it wouldn't be backported so it would be quite a while until I'd ask you to reconsider the matter. > > marking it > > as __attribute__((always_inline)) is problematic because it might > > directly contradict what the programmer was trying to achieve by > > passing -fno-inline. > > __attribute__((always_inline)) exists precisely to make a distinction > between functions where inlining is usually desirable vs. functions > where inlining is essential. Indeed. In this case, it's usually desirable but not essential for the correctness of the program, IMHO. I understand you disagree. > We don't need to warn against the uses > of __attribute__((always_inline)) -- confusing behaviour in the debugger > etc. -- becauses these drawbacks are already well-known. I disagree completely. There's no warning in the GCC documentation for the attribute. > As a user of the 'assume' macro, I want a definitive statement about what > I need to provide so that the macro works in the sense of improved performance. > A statement about "often" is too vague. I agree. > How about this proposed patch? > > diff --git a/lib/verify.h b/lib/verify.h > index f8e4eff..ed1ba19 100644 > --- a/lib/verify.h > +++ b/lib/verify.h > @@ -261,7 +261,10 @@ template > > /* Assume that R always holds. This lets the compiler optimize > accordingly. R should not have side-effects; it may or may not be > - evaluated. Behavior is undefined if R is false. */ > + evaluated. The behavior is undefined if R is false. > + If you want the use of this macro to improve, not deteriorate, > + performance, R should not contain function calls except to functions > + that are declared 'inline __attribute__((__always_inline__))'. */ My suggestion would be "Assume that R always holds. This lets the compiler optimize accordingly. Behavior is undefined if R is false, fails to evaluate, or has side effects. Performance will suffer if R contains function calls that are not inlined at compile time." That would describe the API as I understand you and Paul think it always has been; I think it describes a drastically stricter API than what the old comment did. As a reminder, my starting point was that I wanted to make the API more lenient. So, obviously, I disagree with the API change but it is more important that there's consensus on what the API actually is than it is to have a good API. From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 30 11:46:01 2019 Received: (at 36370) by debbugs.gnu.org; 30 Jun 2019 15:46:01 +0000 Received: from localhost ([127.0.0.1]:47159 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhc1h-0000GX-G0 for submit@debbugs.gnu.org; Sun, 30 Jun 2019 11:46:01 -0400 Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.20]:23294) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhc1e-0000GN-RL for 36370@debbugs.gnu.org; Sun, 30 Jun 2019 11:46:00 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1561909556; s=strato-dkim-0002; d=clisp.org; h=References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: X-RZG-CLASS-ID:X-RZG-AUTH:From:Subject:Sender; bh=JjQZDPqu9xo7JVS5vy85cBU6E5JzGFk5iJW1cuHoJzw=; b=ex0bc6ayEtRi1Wv31lToMYWQi2W0P/+QFLThDtBcD81brJqOcX+YsyhZl5euSytXJO YeR8kM8Gicit4RBlN75WbDdRXGRHxt4UFyJlO0p0aVTtK3ZU2EcGLmJKanXCOCJGYOPy x0+TkB8KxQx9gp47/YqcKHUTsEjbnip/c/We+tsO0jOiCuJF+qYhuFdI7VMC+45KRUvw 3045aE+ZB4//p0u8CSvHENeoAary5IOZKq++xdsWt4sLZy6bZr8qf04JohOtRxELbjoQ U6M4gYxJZZi7YD18DyW6CfExQJQLXan3TTRHJVwx+JChaOd5QwAb0rb2ryTEvfA1uhGK 04hg== X-RZG-AUTH: ":Ln4Re0+Ic/6oZXR1YgKryK8brlshOcZlIWs+iCP5vnk6shH+AHjwLuWOGaf0zJZW" X-RZG-CLASS-ID: mo00 Received: from bruno.haible.de by smtp.strato.de (RZmta 44.24 DYNA|AUTH) with ESMTPSA id v018bcv5UFjqq8G (using TLSv1 with cipher ECDHE-RSA-AES256-SHA (curve secp521r1 with 521 ECDH bits, eq. 15360 bits RSA)) (Client did not present a certificate); Sun, 30 Jun 2019 17:45:52 +0200 (CEST) From: Bruno Haible To: Pip Cet Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers Date: Sun, 30 Jun 2019 17:45:52 +0200 Message-ID: <2053813.cCqrqANjgC@omega> User-Agent: KMail/5.1.3 (Linux/4.4.0-151-generic; KDE/5.18.0; x86_64; ; ) In-Reply-To: References: <2515002.Q0mBYvUW8C@omega> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" X-Spam-Score: 0.0 (/) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, Paul Eggert , bug-gnulib@gnu.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -1.0 (-) Pip Cet wrote: > My suggestion would be "Assume that R always holds. This lets the > compiler optimize accordingly. Behavior is undefined if R is false, > fails to evaluate, or has side effects. Performance will suffer if R > contains function calls that are not inlined at compile time." I like this wording. Bruno From debbugs-submit-bounces@debbugs.gnu.org Sun Jun 30 21:46:46 2019 Received: (at 36370) by debbugs.gnu.org; 1 Jul 2019 01:46:46 +0000 Received: from localhost ([127.0.0.1]:47518 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhlP3-0000Ox-IK for submit@debbugs.gnu.org; Sun, 30 Jun 2019 21:46:46 -0400 Received: from eggs.gnu.org ([209.51.188.92]:56026) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hhlP0-0000Ok-Lp for 36370@debbugs.gnu.org; Sun, 30 Jun 2019 21:46:43 -0400 Received: from fencepost.gnu.org ([2001:470:142:3::e]:41874) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1hhlOu-0002Uz-Fn; Sun, 30 Jun 2019 21:46:36 -0400 Received: from rms by fencepost.gnu.org with local (Exim 4.82) (envelope-from ) id 1hhlOs-0002aM-UQ; Sun, 30 Jun 2019 21:46:35 -0400 Content-Type: text/plain; charset=Utf-8 From: Richard Stallman To: Pip Cet In-Reply-To: (message from Pip Cet on Sun, 30 Jun 2019 15:30:51 +0000) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers References: <2067160.1HRgjLhtDS@omega> <2515002.Q0mBYvUW8C@omega> Message-Id: Date: Sun, 30 Jun 2019 21:46:34 -0400 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, eggert@cs.ucla.edu, bruno@clisp.org X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: rms@gnu.org Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) [[[ To any NSA and FBI agents reading my email: please consider ]]] [[[ whether defending the US Constitution against all enemies, ]]] [[[ foreign or domestic, requires you to follow Snowden's example. ]]] > I agree. There's a limitation bad enough for me to consider it a bug > in current GCC, If you have encountered an apparent GCC bug, please report it. The GCC developers need our help. -- Dr Richard Stallman President, Free Software Foundation (https://gnu.org, https://fsf.org) Internet Hall-of-Famer (https://internethalloffame.org) From debbugs-submit-bounces@debbugs.gnu.org Tue Jul 02 19:39:49 2019 Received: (at 36370) by debbugs.gnu.org; 2 Jul 2019 23:39:49 +0000 Received: from localhost ([127.0.0.1]:48162 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hiSNJ-000052-Cl for submit@debbugs.gnu.org; Tue, 02 Jul 2019 19:39:49 -0400 Received: from zimbra.cs.ucla.edu ([131.179.128.68]:47568) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1hiSNG-0008WS-Oj for 36370@debbugs.gnu.org; Tue, 02 Jul 2019 19:39:47 -0400 Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 1EE79161436; Tue, 2 Jul 2019 16:39:41 -0700 (PDT) Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id ZmBfJSSsp-Zp; Tue, 2 Jul 2019 16:39:40 -0700 (PDT) Received: from localhost (localhost [127.0.0.1]) by zimbra.cs.ucla.edu (Postfix) with ESMTP id 405D0161598; Tue, 2 Jul 2019 16:39:40 -0700 (PDT) X-Virus-Scanned: amavisd-new at zimbra.cs.ucla.edu Received: from zimbra.cs.ucla.edu ([127.0.0.1]) by localhost (zimbra.cs.ucla.edu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id FanKQxcblped; Tue, 2 Jul 2019 16:39:40 -0700 (PDT) Received: from [192.168.1.9] (cpe-23-242-74-103.socal.res.rr.com [23.242.74.103]) by zimbra.cs.ucla.edu (Postfix) with ESMTPSA id 1184B161436; Tue, 2 Jul 2019 16:39:40 -0700 (PDT) Subject: Re: bug#36370: 27.0.50; XFIXNAT called on negative numbers To: Bruno Haible References: <2515002.Q0mBYvUW8C@omega> <2053813.cCqrqANjgC@omega> From: Paul Eggert Organization: UCLA Computer Science Department Message-ID: Date: Tue, 2 Jul 2019 16:39:39 -0700 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:60.0) Gecko/20100101 Thunderbird/60.7.2 MIME-Version: 1.0 In-Reply-To: <2053813.cCqrqANjgC@omega> Content-Type: multipart/mixed; boundary="------------8B752DA5CDBF3730188CA762" Content-Language: en-US X-Spam-Score: -2.3 (--) X-Debbugs-Envelope-To: 36370 Cc: 36370@debbugs.gnu.org, bug-gnulib@gnu.org, Pip Cet X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: debbugs-submit-bounces@debbugs.gnu.org Sender: "Debbugs-submit" X-Spam-Score: -3.3 (---) This is a multi-part message in MIME format. --------------8B752DA5CDBF3730188CA762 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Bruno Haible wrote: > I like this wording. OK, I merged that into the wording I proposed and installed the attached. One new point that I added is that I sometimes use 'assume (X)' to pacify GCC so that it does not issue a bogus warning in nearby code; this benefit of 'assume' is independent of the efficiency of the generated code. --------------8B752DA5CDBF3730188CA762 Content-Type: text/plain; charset=UTF-8; name="0001-verify-document-assume-better.txt" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="0001-verify-document-assume-better.txt" RnJvbSBjODgyOTk2MDI2OTMxZDliMTFiMDg3OGE5YmIwMzJjYTZiMzk0MWRkIE1vbiBTZXAg MTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBQYXVsIEVnZ2VydCA8ZWdnZXJ0QGNzLnVjbGEuZWR1 PgpEYXRlOiBUdWUsIDIgSnVsIDIwMTkgMTY6MzM6MDQgLTA3MDAKU3ViamVjdDogW1BBVENI XSA9P1VURi04P3E/dmVyaWZ5Oj0yMGRvY3VtZW50PTIwPUUyPTgwPTk4YXNzdW1lPUUyPTgw PTk5Pz0KID0/VVRGLTg/cT89MjBiZXR0ZXI/PQpNSU1FLVZlcnNpb246IDEuMApDb250ZW50 LVR5cGU6IHRleHQvcGxhaW47IGNoYXJzZXQ9VVRGLTgKQ29udGVudC1UcmFuc2Zlci1FbmNv ZGluZzogOGJpdAoKKiBsaWIvdmVyaWZ5Lmg6IFJld29yZCBkb2MgKEJ1ZyMzNjM3MCkuCi0t LQogQ2hhbmdlTG9nICAgIHwgNSArKysrKwogbGliL3ZlcmlmeS5oIHwgOCArKysrKy0tLQog MiBmaWxlcyBjaGFuZ2VkLCAxMCBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlm ZiAtLWdpdCBhL0NoYW5nZUxvZyBiL0NoYW5nZUxvZwppbmRleCA3N2Q4ZTllNmEuLmI4OWZk NWQ5ZSAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsx LDggQEAKKzIwMTktMDctMDIgIFBhdWwgRWdnZXJ0ICA8ZWdnZXJ0QGNzLnVjbGEuZWR1Pgor CisJdmVyaWZ5OiBkb2N1bWVudCDigJhhc3N1bWXigJkgYmV0dGVyCisJKiBsaWIvdmVyaWZ5 Lmg6IFJld29yZCBkb2MgKEJ1ZyMzNjM3MCkuCisKIDIwMTktMDctMDIgIEJydW5vIEhhaWJs ZSAgPGJydW5vQGNsaXNwLm9yZz4KIAogCWxvY2FsY2hhcnNldCwgbmxfbGFuZ2luZm86IEZp eCByZXR1cm4gdmFsdWUgZm9yIFVURi04IGxvY2FsZXMgb24gTVNWQy4KZGlmZiAtLWdpdCBh L2xpYi92ZXJpZnkuaCBiL2xpYi92ZXJpZnkuaAppbmRleCBmOGU0ZWZmMDIuLjliOGUxZWQy MCAxMDA2NDQKLS0tIGEvbGliL3ZlcmlmeS5oCisrKyBiL2xpYi92ZXJpZnkuaApAQCAtMjU5 LDkgKzI1OSwxMSBAQCB0ZW1wbGF0ZSA8aW50IHc+CiAjIGRlZmluZSBfX2hhc19idWlsdGlu KHgpIDAKICNlbmRpZgogCi0vKiBBc3N1bWUgdGhhdCBSIGFsd2F5cyBob2xkcy4gIFRoaXMg bGV0cyB0aGUgY29tcGlsZXIgb3B0aW1pemUKLSAgIGFjY29yZGluZ2x5LiAgUiBzaG91bGQg bm90IGhhdmUgc2lkZS1lZmZlY3RzOyBpdCBtYXkgb3IgbWF5IG5vdCBiZQotICAgZXZhbHVh dGVkLiAgQmVoYXZpb3IgaXMgdW5kZWZpbmVkIGlmIFIgaXMgZmFsc2UuICAqLworLyogQXNz dW1lIHRoYXQgUiBhbHdheXMgaG9sZHMuICBCZWhhdmlvciBpcyB1bmRlZmluZWQgaWYgUiBp cyBmYWxzZSwKKyAgIGZhaWxzIHRvIGV2YWx1YXRlLCBvciBoYXMgc2lkZSBlZmZlY3RzLiAg QWx0aG91Z2ggYXNzdW1pbmcgUiBjYW4KKyAgIGhlbHAgYSBjb21waWxlciBnZW5lcmF0ZSBi ZXR0ZXIgY29kZSBvciBkaWFnbm9zdGljcywgcGVyZm9ybWFuY2UKKyAgIGNhbiBzdWZmZXIg aWYgUiB1c2VzIGhhcmQtdG8tb3B0aW1pemUgZmVhdHVyZXMgc3VjaCBhcyBmdW5jdGlvbgor ICAgY2FsbHMgbm90IGlubGluZWQgYnkgdGhlIGNvbXBpbGVyLiAgKi8KIAogI2lmIChfX2hh c19idWlsdGluIChfX2J1aWx0aW5fdW5yZWFjaGFibGUpIFwKICAgICAgfHwgNCA8IF9fR05V Q19fICsgKDUgPD0gX19HTlVDX01JTk9SX18pKQotLSAKMi4xNy4xCgo= --------------8B752DA5CDBF3730188CA762-- From unknown Mon Aug 18 11:29:36 2025 Received: (at fakecontrol) by fakecontrolmessage; To: internal_control@debbugs.gnu.org From: Debbugs Internal Request Subject: Internal Control Message-Id: bug archived. Date: Wed, 31 Jul 2019 11:24:06 +0000 User-Agent: Fakemail v42.6.9 # This is a fake control message. # # The action: # bug archived. thanks # This fakemail brought to you by your local debbugs # administrator