From patchwork Tue Mar 14 10:30:27 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jonathan Wakely X-Patchwork-Id: 69443 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a5d:5915:0:0:0:0:0 with SMTP id v21csp1675826wrd; Tue, 14 Mar 2023 03:32:01 -0700 (PDT) X-Google-Smtp-Source: AK7set/I8+btRswFY9Y8M5mpoP4i5mCotQhnyuaYTeJ0b3EATqMFGm04io5qN0wDjYoNNfpttCLF X-Received: by 2002:aa7:d404:0:b0:4fa:39a6:af25 with SMTP id z4-20020aa7d404000000b004fa39a6af25mr11853965edq.16.1678789921336; Tue, 14 Mar 2023 03:32:01 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1678789921; cv=none; d=google.com; s=arc-20160816; b=UjQxqxg1v7C/cG5N7vPNThVDNHl3ezWpLgb0uROD4e/a2jtjCdPnWKuxSMHhXDLlEk CvOUmprC8/6s7Jzas2j98ObmaE6C8noKd8+4LKrlaG9oea25owvvYvJrPJCAQHUU5ZBp h7Kas1rT/d4kSCY8jLa5/867Pi1d5bGpwEONQa40VgVJUF0Je6HGAQ/pIcLGDCnS7p2H SgJ7ilAJeh2+uqjeD+NOMpNEtTAVMc7/2CdrW+yJunoOJi3x188NUnU9fsBI/NcvB4/f MmcZhEmgKeCY7uD5o+6GJ8CrwZqutbT8xWbukLHANjrhn26L+DVXUIA8E8Ly4JLwOa5z NMgQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:message-id:date:subject:to :dmarc-filter:delivered-to:dkim-signature:dkim-filter; bh=evRnDMfZgy7e54u35/0tcKn0Uafv3o6QcG8do2Qlu00=; b=OebMeE2qDDTNdNhTl1TJPPIusM6aJ0kx75WHUReVnNadZhlxp1IqM77Wsg06Krko2Z UxK+qjaBQQWW19E1e9pNBzq5jIrX/PnbO11yx4DiugwGUutBy0zDGB//YmtLXeln9Na+ r0JLyxNe2PjjI+atFd7zS7mmgRdFQaatbQqJxK4NERKA88B103eOR5KjNgq0+lM6XzKs q7BnmVUqNbxw9cC9O8RZw1ZGS01qcF+5sCCp2K2mwYkWW3vl0h8/cCtTMXQKpdjMRbGn 2HPiSmB1ccR931UyBjXffv3XO4PqWQ1tteMVePlxVzgXmtp7J+QlHG/LhCuKniKHaUYM zp7g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=c6fJBo22; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id d7-20020a50fb07000000b004acb302a730si2386744edq.70.2023.03.14.03.32.01 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 14 Mar 2023 03:32:01 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=c6fJBo22; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id ABFD338582A3 for ; Tue, 14 Mar 2023 10:31:16 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org ABFD338582A3 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1678789876; bh=evRnDMfZgy7e54u35/0tcKn0Uafv3o6QcG8do2Qlu00=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=c6fJBo22BuUPymCHaw+FIdAQ27Z0SZhkKKrrtSQAl2KxZPFg0VM8nHysE7RxMLmkk W7LUUFZzeO9ikUUb2bQZp4LfkaFI/z/hcdO1voacwWS2WbIDSV7HbqQDX3IpOojSBy kHjnLvDnNjN1MbeRLjHYMshsPl3laIAf0beUnK58= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id DD6C83858D37 for ; Tue, 14 Mar 2023 10:30:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DD6C83858D37 Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-588-PNWspXXPPd6D0TQUSNljCQ-1; Tue, 14 Mar 2023 06:30:28 -0400 X-MC-Unique: PNWspXXPPd6D0TQUSNljCQ-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 3C6ED885625; Tue, 14 Mar 2023 10:30:28 +0000 (UTC) Received: from localhost (unknown [10.33.36.255]) by smtp.corp.redhat.com (Postfix) with ESMTP id AED6D2166B26; Tue, 14 Mar 2023 10:30:27 +0000 (UTC) To: libstdc++@gcc.gnu.org, gcc-patches@gcc.gnu.org Subject: [committed] libstdc++: Add assertions to std::mask_array operations [PR62196] Date: Tue, 14 Mar 2023 10:30:27 +0000 Message-Id: <20230314103027.2697727-1-jwakely@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.1 on 10.11.54.6 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jonathan Wakely via Gcc-patches From: Jonathan Wakely Reply-To: Jonathan Wakely Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1760338820642888943?= X-GMAIL-MSGID: =?utf-8?q?1760338820642888943?= The PR has an example where we currently just read off the end of a heap buffer. We can check the preconditions and assert instead. Tested x86_64-linux. Pushed to trunk. -- >8 -- Add assertions to diagnose incorrect uses of valarray masks. The assignment operators of std::mask_array do not have any explicit preconditions in the standard, but the assignment operator valarray::operator=(const mask_array&) requires the lengths to match, so it seems consistent to also require that when the operands are reversed. In support of that interpretation, libstdc++ has undefined behaviour if the right-hand operand has more elements than are selected by the mask, and libc++ has undefined behaviour if it has fewer elements. Our std::mask_array stores the number of selected elements as _M_sz so it's easy to add an assertion that checks it. For the valarray::operator[] that takes a valarray mask, [valarray.sub] in the standard says: "In each case the selected element(s) shall exist." This makes it undefined to have a mask that refers to out-of-range elements. We can easily check this too. libstdc++-v3/ChangeLog: PR libstdc++/62196 * include/bits/mask_array.h (mask_array): Add assertions to assignment operators. * include/std/valarray (valarray::operator[](valarray)): Add assertions. * testsuite/26_numerics/valarray/mask-1_neg.cc: New test. * testsuite/26_numerics/valarray/mask-2_neg.cc: New test. * testsuite/26_numerics/valarray/mask-3_neg.cc: New test. * testsuite/26_numerics/valarray/mask-4_neg.cc: New test. * testsuite/26_numerics/valarray/mask-5_neg.cc: New test. * testsuite/26_numerics/valarray/mask-6_neg.cc: New test. * testsuite/26_numerics/valarray/mask-7_neg.cc: New test. * testsuite/26_numerics/valarray/mask-8_neg.cc: New test. * testsuite/26_numerics/valarray/mask.cc: New test. --- libstdc++-v3/include/bits/mask_array.h | 13 ++++- libstdc++-v3/include/std/valarray | 2 + .../26_numerics/valarray/mask-1_neg.cc | 16 +++++++ .../26_numerics/valarray/mask-2_neg.cc | 16 +++++++ .../26_numerics/valarray/mask-3_neg.cc | 19 ++++++++ .../26_numerics/valarray/mask-4_neg.cc | 18 +++++++ .../26_numerics/valarray/mask-5_neg.cc | 19 ++++++++ .../26_numerics/valarray/mask-6_neg.cc | 19 ++++++++ .../26_numerics/valarray/mask-7_neg.cc | 18 +++++++ .../26_numerics/valarray/mask-8_neg.cc | 18 +++++++ .../testsuite/26_numerics/valarray/mask.cc | 47 +++++++++++++++++++ 11 files changed, 203 insertions(+), 2 deletions(-) create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-1_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-2_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-3_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-4_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-5_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-6_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-7_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask-8_neg.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/valarray/mask.cc diff --git a/libstdc++-v3/include/bits/mask_array.h b/libstdc++-v3/include/bits/mask_array.h index 657ab43fa7b..d4112a9d0a3 100644 --- a/libstdc++-v3/include/bits/mask_array.h +++ b/libstdc++-v3/include/bits/mask_array.h @@ -153,6 +153,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array<_Tp>& __a) { + __glibcxx_assert(__a._M_sz == _M_sz); std::__valarray_copy(__a._M_array, __a._M_mask, _M_sz, _M_array, _M_mask); return *this; @@ -166,13 +167,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline void mask_array<_Tp>::operator=(const valarray<_Tp>& __v) const - { std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); } + { + __glibcxx_assert(__v.size() == _M_sz); + std::__valarray_copy(_Array<_Tp>(__v), __v.size(), _M_array, _M_mask); + } template template inline void mask_array<_Tp>::operator=(const _Expr<_Ex, _Tp>& __e) const - { std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); } + { + __glibcxx_assert(__e.size() == _M_sz); + std::__valarray_copy(__e, __e.size(), _M_array, _M_mask); + } #undef _DEFINE_VALARRAY_OPERATOR #define _DEFINE_VALARRAY_OPERATOR(_Op, _Name) \ @@ -180,6 +187,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline void \ mask_array<_Tp>::operator _Op##=(const valarray<_Tp>& __v) const \ { \ + __glibcxx_assert(__v.size() == _M_sz); \ _Array_augmented_##_Name(_M_array, _M_mask, \ _Array<_Tp>(__v), __v.size()); \ } \ @@ -189,6 +197,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline void \ mask_array<_Tp>::operator _Op##=(const _Expr<_Dom, _Tp>& __e) const\ { \ + __glibcxx_assert(__e.size() == _M_sz); \ _Array_augmented_##_Name(_M_array, _M_mask, __e, __e.size()); \ } diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray index 7a23c27a0ce..504d02b7359 100644 --- a/libstdc++-v3/include/std/valarray +++ b/libstdc++-v3/include/std/valarray @@ -893,6 +893,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; + __glibcxx_assert(__s <= _M_size); return valarray<_Tp>(mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array (__m))); } @@ -905,6 +906,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION size_t __e = __m.size(); for (size_t __i=0; __i<__e; ++__i) if (__m[__i]) ++__s; + __glibcxx_assert(__s <= _M_size); return mask_array<_Tp>(_Array<_Tp>(_M_data), __s, _Array(__m)); } diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-1_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-1_neg.cc new file mode 100644 index 00000000000..7ef11736d96 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-1_neg.cc @@ -0,0 +1,16 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + + // This is adapted from an example in C++11 [valarray.sub]. + // valarray operator[](const valarray& boolarr) const; + + const valarray v0("ab", 2); + const bool vb[] = {false, false, true, true, false, true}; + (void) v0[valarray(vb, 6)]; // aborts, mask has more elements than v0 +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-2_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-2_neg.cc new file mode 100644 index 00000000000..f380dba17a9 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-2_neg.cc @@ -0,0 +1,16 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + + // This is adapted from an example in C++11 [valarray.sub]. + // mask_array operator[](const valarray& boolarr); + + valarray v0("ab", 2); + const bool vb[] = {false, false, true, true, false, true}; + (void) v0[valarray(vb, 6)]; // aborts, mask has more elements than v0 +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-3_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-3_neg.cc new file mode 100644 index 00000000000..0b9e6fb366d --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-3_neg.cc @@ -0,0 +1,19 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + // See also PR libstdc++/62196. + + valarray v0("abcdefghijklmnop", 16); + valarray v1("ABCD", 4); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m = v0[valarray(vb, 6)]; + m = v1; // aborts, v1 has more elements than m +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-4_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-4_neg.cc new file mode 100644 index 00000000000..b996967f4ce --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-4_neg.cc @@ -0,0 +1,18 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + + valarray v0("abcdefghijklmnop", 16); + valarray v1("AB", 2); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m = v0[valarray(vb, 6)]; + m = v1; // aborts, m has more elements than v1 +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-5_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-5_neg.cc new file mode 100644 index 00000000000..8e708903b00 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-5_neg.cc @@ -0,0 +1,19 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + + valarray v0("abcdef", 6); + valarray v1("ABCDEF", 6); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m0 = v0[valarray(vb, 6)]; + const mask_array m1 = v1[valarray(vb, 5)]; + m0 = m1; // aborts, m0 has more elements than m1 +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-6_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-6_neg.cc new file mode 100644 index 00000000000..cded68c45b4 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-6_neg.cc @@ -0,0 +1,19 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + + valarray v0("abcdef", 6); + valarray v1("ABCDEF", 6); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m0 = v0[valarray(vb, 5)]; + const mask_array m1 = v1[valarray(vb, 6)]; + m0 = m1; // aborts, m0 has fewer elements than m1 +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-7_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-7_neg.cc new file mode 100644 index 00000000000..246977b8a8f --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-7_neg.cc @@ -0,0 +1,18 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + + valarray v0("abcdefghijklmnop", 16); + valarray v1("ABCD", 4); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m = v0[valarray(vb, 6)]; + m += v1; // aborts, v1 has more elements than m +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask-8_neg.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask-8_neg.cc new file mode 100644 index 00000000000..70f9ea25318 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask-8_neg.cc @@ -0,0 +1,18 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run { xfail *-*-* } } + +#include + +int main() +{ + using std::valarray; + using std::mask_array; + + // This is adapted from an example in C++11 [valarray.sub]. + + valarray v0("abcdefghijklmnop", 16); + valarray v1("AB", 2); + const bool vb[] = {false, false, true, true, false, true}; + const mask_array m = v0[valarray(vb, 6)]; + m += v1; // aborts, v1 has more elements than m +} diff --git a/libstdc++-v3/testsuite/26_numerics/valarray/mask.cc b/libstdc++-v3/testsuite/26_numerics/valarray/mask.cc new file mode 100644 index 00000000000..cb18701033e --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/valarray/mask.cc @@ -0,0 +1,47 @@ +// { dg-options "-D_GLIBCXX_ASSERTIONS" } +// { dg-do run } + +#include +#include + +using std::valarray; + +template +bool equal(const valarray& lhs, const valarray& rhs) +{ + if (lhs.size() != rhs.size()) + return false; + for (unsigned i = 0; i < lhs.size(); ++i) + if (lhs[i] != rhs[i]) + return false; + return true; +} + +// Taken from examples in C++11 [valarray.sub]. + +void +test01() // valarray operator[](const valarray& boolarr) const; +{ + const valarray v0("abcdefghijklmnop", 16); + const bool vb[] = {false, false, true, true, false, true}; + valarray v1 = v0[valarray(vb, 6)]; + + VERIFY( equal(v1, valarray("cdf", 3)) ); +} + +void +test02() // mask_array operator[](const valarray& boolarr); +{ + valarray v0("abcdefghijklmnop", 16); + valarray v1("ABC", 3); + const bool vb[] = {false, false, true, true, false, true}; + v0[valarray(vb, 6)] = v1; + + VERIFY( equal(v0, valarray("abABeCghijklmnop", 16)) ); +} + +int main() +{ + test01(); + test02(); +}