<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=http://email.email.llvm.org/c/eJztW1mP2zgS_jXuF8KCDp8P_dBXMg30zg4mmR1gXwxKomwlkqiIUtveX79fkTpt2d2ZzGCBxThOWy2RdbGqWF_R7cvweDtx7_C-C8qKJ8wXO_4ay8LcnNiPE_vuIeHZduJ-eHn51z-YSONSMVUFOxbIULBIFmyysDMpDoHIS1xOE-6LRIQsqrKgjGWmWLnjJUv5V6FYXLI4zaVSsZ8IVkqWyICXgnGiUu4KuccnUyXupSIrzdRE8FDR4LyQ24KnrBRFGmecqLOw0nR4xniJSXlZD8z5VhPOmBGNxhKDars7kZhFoCkso635-XkXQ1alQBsXvAh2cSlgokJM4ywUucAPSMezkBUiAZ9Qc8UVDJLWGkcySeSePZc8i6uUPf10d__MJu5K-koUr2QhGO8lzqqDJnSXhYWMw4m7Hohyp_VXJfv48MBCCRtmsmRYJqhNUkJVmDIdzDHL9yhKHieqv5b3giQilZjiaY4lqE068ZqpC9u8g6Ch9QFv1tjLCgLWZ_UKkRmHVpCbTZb32sZ7qOn6Uqb4mHj3uP_YG-33RtczzwcFvUH-pUFhb1BwaZDoDQovDYp6g8SlQdveoOjSoF09qDGYHr0dGW1-xhmFRpx1pM19hteunVXPaKc2i9TzVukjcCuVHNk-TpI2RASTWSB6MVAIHuzgRZjd0F_YA-_5SRTG7VlQcLVjPg--lgUPTLQHlA6mgUzzmKK89t80XMyYD4bFkVz8eeIuU1apONuyJAl95lelcVe8q2xPQVT0Q0mreeqCjQPODNOJe483m_7THvNGjNKcuCXBaypZUWX0AReESyKDdHqQV9aTVjSHDF_yYitKaCzIZhih6bQjH6qioIgXBxFUJafkpYRONdAU8bGTKch-ULuq4EkWf8V1TWBJ9jisFpvFrBfaHWOIae51KxbwhEzLI9wy8UR2RCaLM2RGWk4ZEd9gx7EeyLCljvGlofNLIQOhFHNnruMhlco8F2GbF1htjInrORP3gWVIfWziPRK9RmK6T_PIVxRchh6reJthg_j0_PHu_tfPnY_q3EnUbKwfsw82XssIr6UtnMhfsiT2A0tJa4EF3Ww-Pm8KHisKMVAEYZdsgGSp71oBiMydvjMOtUk4NpUd1AGv7zP8-YKfOsVfYyEi-NfZaLACzjl1b-0659S5L4uSCOoLTXC5HiHonhLk4WI91-KqMgxMPHaUN2TaTZWRwcKNOqa-TFzYnt7nUxjF8mqMrXfONuBi8V1sV8urfBcjbGcjbH1jvnO2uEP5yuuitkngoO4sR8jPO_LmNQMfEZl8pRXRSW5Dwb_pcoGmNx-htxijF3gtvV1PIG-MwHKMQLhuCdCupGePrdHqzNeCmR-dejL9tkHKKspNvcfpD-8RV302FJ-IKKRg-OKjU1-_4rrHAq8wXK7oYZzFJVHxHqqMv6LIoYQ88Z7oWYSHl54VZRJurg2ArMHXDbakEdaLVR2GpNVUa6VDx3PsEQOtR6y78Hi33JqAtu_sfDeazJ_Gt_q6JsxzVICq2-TDeoMVvc2adlqFShzJk_Ztnh1RkhcYQ9c8OSoM8EXAMUjPJMczBmB70M4hXoxbR9qvZYUClYrUvcAb5UGJah4V954fmX800w8H2svKGPpHhUz1TVTEkGS_01NoUJXkBTBAv9gnZmZbFaGFapkER1Y90uYap3wbZ4LtUFLq8oFHEepwxULhV9st9-MkLo-0HXIGVFFOUyQ0kQIUpDkK3w_aEkZ_hY2CUdmSiAN7qGsJjWF0sS4OmI-h5Fwwa6TljstTrKDIAbSdySRU7UBKbMFU9tOlWQIlWizAUPSfQAvR7BokltYqgejDlSOFNfAiuJRoLKROYYvKRRBHsSgsYIdunIFFvkTpD7ywz2p0RM_jALYvi-MUmAsIziieBYnWnETf7yQqmwa5afNcRgYl1Xr9erWGCpZlnd27g29pYyOnpMeOQw0Nj1i9ErIbhzOucZEsymBmFEDE0N3Tunk8lWJwYKq4TVsNv6-6burhzPiGUCXVY1R4iW-VyOrCWIPi4SpY7KmtuxtIStdbgnFxpk2eiUOJGDi2dp4yB96Q78iLqAQQBD9NfdwGGHhRVRRVZC4ktJCq9R0CNEF014RPQW5t8oaJG3Y8eNAao-PRYmg1BNGNTxGPL5UinEvZoeZOWdQU-GQjKpF0SlQ6e5gwN8XskXGlZBDr7BUA4mYVQlYL9_QKA1baFXidkShXaexu4qThPwbk4cQxViJDBJED6LC54BGUffRgkCcRCnBUO9KvtqHKYlTPulB6HXYIPiGo4NMxxRgSFA8CWdQqG8nm9xSfkzntdbuyhG5ejaVFZgV5XogIrgTnsQLCyR_2-I_b-EmSVnxLZW2j3EbT6mMk74n9LLNpiw66bguHt-akYlm3JXRi78XXyCSL_b4TmXjVe0NvrWNlgjHTy6ctot3R7Citx0EN-ADsarIIdjjw1zktkVgsnZ6zMWnJW2hGmw_O6ypGodXcrRAtsAQpBrOSoyZNLkfRhTxAC6nRU2cp0_jA9ojcx7GavKj7Mw0epX6KFjtLKA_VvSmsZwFOp3lVuzH8k2GnEWxKRBMpv1JPzJcwWgoIAOchk3NaNErb7qpGxir-jyCVg7xiFGN0PdjJCCGyuvkE1-Sm64NIDKtmH9OLQG5uGjjXUPPfiPl7EfPMm_8PEfNivfxTETNp8_-GmH_URtcR82K9_hsx_whi9v3Z-rvYLudX2c7fgNKtujN_dYnv9nDYYEOE13HKsZtX22i0GsNtizNg63vzpUe0twHALJF1LqozW7TadKPNunnXIXjLjIfOObPfdEW1-ZXcuSspjRbvguewUDi76IfBgW-avj1sPtYt6OHZef2aLdeLFs_yXrthNhuLNXuUQtcA8XsUxnRynDEC3G8JBG8RcMcIIJk0BMK3CHhjBHo9F_EWgdkogc4G0VsE5mMEws4G27cILMYIiOVo22iUwHKMQOS9r23knDnmAiv4d9-oZ6GxQFus_qTG0X2_xwAIUh9EUlHbnK3uh30lgiWyaQbVyI5KVHHsKuNTGOYf9TlxDfQYHcoe2cunx7sOJ_eQhy53zRFvAz0JQ7W1Xd1waUGxxZ6ZL5JYNCegzaE16ZRCFdMPM10p6r6w9gh1kP601rQm9a-hZHDA82PUpwZxjB2OP-sj7RY0kH6mbQMVyAa9o3KNOfTZnOm5jSobVoUGkX2FJ94H9hTrxh20SgilUVds20EBwJpC8qaj0x4USz3BnMIR4JaaBoBNRh9c1TJ1piLwWyUhi-DdLbirEZ8vIkI8xgMMBNKeqEZNBic7P3cmZArQL1IfQCuJdRulxmKhSKkqL8gGJ4grNMfYBnDVKP3N42o4o9XcEgfYV_duULti9VZ0xQetn_YoNpKyN2BwiNsFayHKCgQNMf6eHpLxCQRwXpXw-N7XF_BAtw1ybsKw1xTREQMzADhqTE_hmpXWeHi7HmsPSgH4XDb9RFhuOrDExF5bJczR_RbFyGE2sqhbj2uBHh5uE-knuNj824NdYnb6IqbTKbsX8MYOwtejOzK5i7prC8y2nlGutA9ruyfOMRcdCzyfzOxhq6p55N2dCTAiD6YPBLBeiNrGJxntXlNgbQVRbHIpYicY3u5Vi8wjmceKyOGURIXcjLVe2v7JYHHmvm8NJMgrtfumjT8v-GFILhTRJoj4RkYRoWZn0WhTpvmACCHfb8aA8Me4N8zphrX8nQF_mTfsg-vsV-1TuP63hsf9vb1xz0x6TfLB6FS-9rSH4egqjM81G-_d9VcXG-9wbXWjpe9VrDdyeuahJDeeDB1BidoJEQgoxutGnO5kkJu6Lqdg0Q5Le6cfl2rM5-t4QlIekOjkHfhLXwn_SGqu3fn8mre__PJJFwRPGXYZyiSErCW2njNC3vWw-fwZoTgkU2Ev5bOOUJUI33FXMGZZ0imHPW2uChHZ7UJ3d0bUca5I8aCPoOLyVAzDdkyOQJVmTc1lHea1IL07fUF6WiCYpoMM0ZgDZZ33ZOT5RPIAxHkP9B6n4kwNsaE6zBDwRbkX2C7rIZTl6wAdJ-aOikSvL3SsRQVDHU3fY1vG_pmxutGPVOr0jXQWP--gV5voziT9XwX1v0_MdGH2BfEe9JEOOeFzFknmnEljX53-s-yON01peSUav0ey1hf64qkzf0hktn1DyFPd2jAa2P6HhMV2_JSFJ4c9J9mMKgDr0hmZTmyHj-epzX24OCWQKRJFx2sXh6HILqbui4XDlURPZPeCf31jP3h3uXFR-7PqY3zkSDHSVB_XxPuuQqC3AR64SQYbfe45svl_Ktctr9fTvdEZ3RsvmaC3VTrTa9r8KX4Z62__6QrU1K5AN4q8wbEt_JvOKh84qXImyydnZdkzy2WDGrXza9y2MlkK6-PPv001IK-dmH5e3Kh5GBbUMz69QQ29a2XfsPwmyNVU9z8TXA4pYMyJki7j9VcJWixM1pzqfU7XAtdL-u4U53JRf7WMH1b8dXiwmTbNQ_PdopF6_0qRzq5U6Y33fbj_Q_U24tUHh8ffLVQQ1jsLb_vg0CTrhYzdDfiS5r3SeGb_8vL5StEHkZ-GIrcGuSrFHy4UG3FHdl77EEXvvTlaRxDlh09PVN6Yy3u7z1T_3q1VM3ogytBvRkrq80K6zfzvWr46ob9rbM_IVJRiRmLR3w4k1rXpxvz70e3s-rzTPc0EzeosJq5ToTiR_hfIfmbINybWnK6N6q_Vt4qHbzpqL9ciYZkTwdVvOr-ypTVHtvVOsi31QPSTCzn3LOFey7ZNersJb71w7a35Da_KnSxuARZ2cdycR6rgpiqS2-F3JrbIn5Vff1UiSV6bjyl4aPO6H_Sfa9CXvuaevXBvdrcRn4fhYjELVp6_ns2ddRgAk8wduKgQ87V_o_9SRd1O5sivbib25i8-SPz5482PSxDfurbr2o69tJ3ZfD635n7gh4to6blOKHi0gIlEymM4MuhYstjeFLeapF9tFR5Si0x1D7miA1MhtMCQsIzLRP9ivh0_f2QPMhRbYb5Y1rauVCBz-rpRmvO4UG2f13y3v_km4I2W_VYL_l9K0oiP>53062</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            [clang] Codegen for noexcept scopes impairs program crash analysis
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            new issue
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          serhiihuralniksc
      </td>
    </tr>
</table>

<pre>
    **Actual behavior**
Clang/LLVM emits such code for `noexcept`-labeled functions that makes it impossible to locate a `throw` statement that leads to program termination due to an attempt to propagate an exception through `noexcept` frame.

This issue is architecture-independent and related to platforms that follow Itanium EHABI (observed for Linux and Android).

At least GCC does not have this problem.

**Details**
Below is a sample program:
```cc
// noexcept.cc 

void a() { throw "boom"; }
void b() { a(); }
void c() { b(); }
void d() { c(); }
void e() { d(); }
void f() { e(); }
void g() { f(); }
void h() noexcept { g(); }

int main() {
    h();
}
```
This obviously will terminate once exception reaches `h()`.

Here is a crash backtrace for clang-compiled Linux amd64 binary (I'm using lldb but this is unwinder-independent):
```
$ clang++ -O0 noexcept.cc 
$ lldb a.out -o run -o "thread backtrace"
(lldb) target create "a.out"
Current executable set to '/home/shuralnik/a.out' (x86_64).
(lldb) run
terminate called after throwing an instance of 'char const*'
Process 24213 stopped
* thread #1, name = 'a.out', stop reason = signal SIGABRT
    frame #0: 0x00007ffff70e1fb7 libc.so.6`__GI_raise(sig=2) at raise.c:51

Process 24213 launched: '/home/shuralnik/a.out' (x86_64)
(lldb) thread backtrace
* thread #1, name = 'a.out', stop reason = signal SIGABRT
  * frame #0: 0x00007ffff70e1fb7 libc.so.6`__GI_raise(sig=2) at raise.c:51
    frame #1: 0x00007ffff70e3921 libc.so.6`__GI_abort at abort.c:79
    frame #2: 0x00007ffff7ad6957 libstdc++.so.6`___lldb_unnamed_symbol24$$libstdc++.so.6 + 89
    frame #3: 0x00007ffff7adcae6 libstdc++.so.6`___lldb_unnamed_symbol287$$libstdc++.so.6 + 6
    frame #4: 0x00007ffff7adcb21 libstdc++.so.6`std::terminate() + 17
    frame #5: 0x00000000004007ef a.out`__clang_call_terminate + 15
    frame #6: 0x00000000004007c3 a.out`h() + 35
    frame #7: 0x00000000004007d9 a.out`main + 9
    frame #8: 0x00007ffff70c4bf7 libc.so.6`__libc_start_main(main=(a.out`main), argc=1, argv=0x00007fffffffdd78, init=<unavailable>, fini=<unavailable>, rtld_fini=<unavailable>, stack_end=0x00007fffffffdd68) at libc-start.c:310
    frame #9: 0x000000000040063a a.out`_start + 42
(lldb) ^D
```

App has terminated but the backtrace is useless for any further analysis because the call stack was partially unwound and we were taken away by the cxx runtime from the place where the culprit `throw` was executed. It is easy to imagine how this affects debuggability of a post-mortem dumps/traces for some complex C++ code that exposes C interface with `noexcept`s at the boundary to conform to the base platform ABI.

The reason for this lost backtrace is how Clang implements `noexcept` specifier. An implementation boils down to an implicit try-catch that encloses the whole function code:
```cc
try {
    // ...
    // All code in my function that may potentially throw
    // ...
} catch (...) {
    __clang_call_terminate(current_exception);
}
```
There is an interesting consequence for such implementation. Exception propagation goes in the next way:
- 1st phase (search): runtime successfully finds a handler in the `noexcept` function
- 2d phase (action): runtime propagates an exception down to the just found handler, unwinding top frames and executing any associated cleanups
Eventually a stack is brought back to the `noexcept` frame which now calls `__clang_call_terminate` which is clearly shown in the snippet above.

So all is done according to the [spec](https://en.cppreference.com/w/cpp/language/noexcept_spec):
> Non-throwing functions are permitted to call potentially-throwing functions. Whenever an exception is thrown and the search for a handler encounters the outermost block of a non-throwing function, the function std::terminate or std::unexpected (until C++17) is called:

But it appears that this is not the only possible correct implementation and even more - it looks suboptimal in all aspects (binary size, cpu time, debuggability). This is what GCC produces for the same sample:
```
$ g++ -O0 noexcept.cc 
$ lldb a.out -o run -o "thread backtrace"
(lldb) target create "a.out"
Current executable set to '/home/shuralnik/a.out' (x86_64).
(lldb) run
terminate called after throwing an instance of 'char const*'
Process 24435 stopped
* thread #1, name = 'a.out', stop reason = signal SIGABRT
    frame #0: 0x00007ffff7697fb7 libc.so.6`__GI_raise(sig=2) at raise.c:51

Process 24435 launched: '/home/shuralnik/a.out' (x86_64)
(lldb) thread backtrace
* thread #1, name = 'a.out', stop reason = signal SIGABRT
  * frame #0: 0x00007ffff7697fb7 libc.so.6`__GI_raise(sig=2) at raise.c:51
    frame #1: 0x00007ffff7699921 libc.so.6`__GI_abort at abort.c:79
    frame #2: 0x00007ffff7ad6957 libstdc++.so.6`___lldb_unnamed_symbol24$$libstdc++.so.6 + 89
    frame #3: 0x00007ffff7adcae6 libstdc++.so.6`___lldb_unnamed_symbol287$$libstdc++.so.6 + 6
    frame #4: 0x00007ffff7adbb49 libstdc++.so.6`___lldb_unnamed_symbol275$$libstdc++.so.6 + 57
    frame #5: 0x00007ffff7adc4b8 libstdc++.so.6`__gxx_personality_v0 + 680
    frame #6: 0x00007ffff70b3573 libgcc_s.so.1`___lldb_unnamed_symbol46$$libgcc_s.so.1 + 83
    frame #7: 0x00007ffff70b3ad1 libgcc_s.so.1`_Unwind_RaiseException + 689
    frame #8: 0x00007ffff7adcd47 libstdc++.so.6`__cxa_throw + 55
    frame #9: 0x0000555555554796 a.out`a() + 44
    frame #10: 0x000055555555479f a.out`b() + 9
    frame #11: 0x00005555555547ab a.out`c() + 9
    frame #12: 0x00005555555547b7 a.out`d() + 9
    frame #13: 0x00005555555547c3 a.out`e() + 9
    frame #14: 0x00005555555547cf a.out`f() + 9
    frame #15: 0x00005555555547db a.out`g() + 9
    frame #16: 0x00005555555547e7 a.out`h() + 9
    frame #17: 0x00005555555547f3 a.out`main + 9
    frame #18: 0x00007ffff767abf7 libc.so.6`__libc_start_main(main=(a.out`main), argc=1, argv=0x00007fffffffdd78, init=<unavailable>, fini=<unavailable>, rtld_fini=<unavailable>, stack_end=0x00007fffffffdd68) at libc-start.c:310
    frame #19: 0x000055555555468a a.out`_start + 42
(lldb) ^D
```

Backtrace is preserved and program was terminated w/o partial unwind. They implement `noexcept` by emitting an empty LSDA for such functions. This leads runtime to terminate at the 1st phase. I believe this behavior is mandated by the ABI. At least libstdc++ and libc++ do so.

**Expected behavior**
Is it possible for Clang to emit such code that will cause runtime to terminate during the 1st phase? Either by leveraging the same approach that GCC does or by using any other corner case that by the ABI should fail handler search before unwind even starts.

**Extra**
Below are assembly listings that demonstrate implementation details more clearly:
```cc
// exc.cc
extern int bar(int a);

int foo(int a) noexcept {
    return bar(a);
}
```
Clang output. Termination landing pad and associated LSDA entry are present.
```
# $ clang -O2 -S -o - exc.cc
        .text
        .file   "exc.cc"
        .globl  _Z3fooi                 # -- Begin function _Z3fooi
        .p2align        4, 0x90
        .type   _Z3fooi,@function
_Z3fooi:                                # @_Z3fooi
.Lfunc_begin0:
        .cfi_startproc
        .cfi_personality 3, __gxx_personality_v0
        .cfi_lsda 3, .Lexception0
# %bb.0:
        pushq   %rax
        .cfi_def_cfa_offset 16
.Ltmp0:
        callq   _Z3bari
.Ltmp1:
# %bb.1:
        popq    %rcx
        .cfi_def_cfa_offset 8
        retq
.LBB0_2:
        .cfi_def_cfa_offset 16
.Ltmp2:
        movq    %rax, %rdi
        callq   __clang_call_terminate
.Lfunc_end0:
        .size   _Z3fooi, .Lfunc_end0-_Z3fooi
        .cfi_endproc
        .section        .gcc_except_table,"a",@progbits
        .p2align        2
GCC_except_table0:
.Lexception0:
        .byte   255                     # @LPStart Encoding = omit
        .byte   3                       # @TType Encoding = udata4
        .uleb128 .Lttbase0-.Lttbaseref0
.Lttbaseref0:
        .byte   1                       # Call site Encoding = uleb128
        .uleb128 .Lcst_end0-.Lcst_begin0
.Lcst_begin0:
        .uleb128 .Ltmp0-.Lfunc_begin0   # >> Call Site 1 <<
        .uleb128 .Ltmp1-.Ltmp0          #   Call between .Ltmp0 and .Ltmp1
        .uleb128 .Ltmp2-.Lfunc_begin0   #     jumps to .Ltmp2
        .byte   1                       #   On action: 1
.Lcst_end0:
        .byte   1                       # >> Action Record 1 <<
                                        #   Catch TypeInfo 1
        .byte   0                       #   No further actions
        .p2align        2
                                        # >> Catch TypeInfos <<
        .long   0                       # TypeInfo 1
.Lttbase0:
        .p2align        2
                                        # -- End function
        .section        .text.__clang_call_terminate,"axG",@progbits,__clang_call_terminate,comdat
        .hidden __clang_call_terminate  # -- Begin function __clang_call_terminate
        .weak   __clang_call_terminate
        .p2align        4, 0x90
        .type   __clang_call_terminate,@function
__clang_call_terminate:                 # @__clang_call_terminate
# %bb.0:
        pushq   %rax
        callq   __cxa_begin_catch
        callq   _ZSt9terminatev
.Lfunc_end1:
        .size   __clang_call_terminate, .Lfunc_end1-__clang_call_terminate
                                        # -- End function
        .ident  "clang version 10.0.0-4ubuntu1~18.04.2 "
        .section        ".note.GNU-stack","",@progbits
        .addrsig
        .addrsig_sym __gxx_personality_v0
```
GCC output. No pads, only LSDA with an empty call-site table.
```
# $ g++ -O2 -S -o - exc.cc
        .file   "exc.cc"
        .text
        .p2align 4,,15
        .globl  _Z3fooi
        .type   _Z3fooi, @function
_Z3fooi:
.LFB0:
        .cfi_startproc
        .cfi_personality 0x9b,DW.ref.__gxx_personality_v0
        .cfi_lsda 0x1b,.LLSDA0
        jmp     _Z3bari@PLT
        .cfi_endproc
.LFE0:
        .globl  __gxx_personality_v0
        .section        .gcc_except_table,"a",@progbits
.LLSDA0:
        .byte   0xff
        .byte   0xff
        .byte   0x1
        .uleb128 .LLSDACSE0-.LLSDACSB0
.LLSDACSB0:
.LLSDACSE0:
        .text
        .size   _Z3fooi, .-_Z3fooi
        .hidden DW.ref.__gxx_personality_v0
        .weak   DW.ref.__gxx_personality_v0
        .section        .data.rel.local.DW.ref.__gxx_personality_v0,"awG",@progbits,DW.ref.__gxx_personality_v0,comdat
        .align 8
        .type   DW.ref.__gxx_personality_v0, @object
        .size   DW.ref.__gxx_personality_v0, 8
DW.ref.__gxx_personality_v0:
        .quad   __gxx_personality_v0
        .ident  "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0"
        .section        .note.GNU-stack,"",@progbits
```
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJztW1mP2zgS_jXuF8KCDp8P_dBXMg30ZgeTzA6wLwYlUbYSSVREqW3vr9-vSJ227O7MgQUW4zhttUTWxapifUW3L8Pj7cS9w_suKCueMF_s-GssC3NzYj9O7LuHhGfbifvh5eVf_2AijUvFVBXsWCBDwSJZsMnCzqQ4BCIvcTlNuC8SEbKoyoIylpli5Y6XLOXfhGJxyeI0l0rFfiJYKVkiA14KxolKuSvkHp9MlbiXiqw0UxPBQ0WD80JuC56yUhRpnHGizsJK0-EZ4yUm5WU9MOdbTThjRjQaSwyq7e5EYhaBprCMtubnl10MWZUCbVzwItjFpYCJCjGNs1DkAj8gHc9CVogEfELNFVcwSFprHMkkkXv2XPIsrlL29NPd_TObuCvpK1G8koVgvJc4qw6a0F0WFjIOJ-56IMqd1l-V7OPDAwslbJjJkmGZoDZJCVVhynQwxyzfoyh5nKj-Wt4LkohUYoqnOZagNunEa6YubPMOgobWB7xZYy8rCFif1StEZhxaQW42Wd5rG--hputLmeJj4t3j_mNvtN8bXc88HxT0BvmXBoW9QcGlQaI3KLw0KOoNEpcGbXuDokuDdvWgxmB69HZktPkZZxQacdaRNvcZXrt2Vj2jndosUs9bpY_ArVRyZPs4SdoQEUxmgejFQCF4sIMXYXZDf2EPvOcnURi3Z0HB1Y75PPhWFjww0R5QOpgGMs1jivLaf9NwMWM-GBZHcvHnibtMWaXibMuSJPSZX5XGXfGusj0FUdEPJa3mqQs2DjgzTCfuPd5s-k97zBsxSnPilgSvqWRFldEHXBAuiQzS6UFeWU9a0RwyfMmLrSihsSCbYYSm0458qIqCIl4cRFCVnJKXEjrVQFPEx06mIPtB7aqCJ1n8Ddc1gSXZ47BabBazXmh3jCGmudetWMATMi2PcMvEE9kRmSzOkBlpOWVEfIMdx3ogw5Y6xpeGzs-FDIRSzJ25jodUKvNchG1eYLUxJq7nTNwHliH1sYn3SPQaiek-zSNfUXAZeqzibYYN4vPzx7v7X750PqpzJ1GzsX7MPth4LSO8lrZwIn_JktgPLCWtBRZ0s_n4vCl4rCjEQBGEXbIBkqW-awUgMnf6zjjUJuHYVHZQB7x-zPDnC37qFH-NhYjgX2ejwQo459S9teucU-e-LEoiqC80weV6hKB7SpCHi_Vci6vKMDDx2FHekGk3VUYGCzfqmPoycWF7ep9PYRTLqzG23jnbgIvFD7FdLa_yXYywnY2w9Y35ztniDuUrr4vaJoGDurMcIT_vyJvXDHxEZPKVVkQnuQ0F_6bLBZrefITeYoxe4LX0dj2BvDECyzEC4bolQLuSnj22RqszXwtmfnTqyfTbBimrKDf1Hqc_vEdc9dlQfCKikILhi49Off2K6x4LvMJwuaKHcRaXRMV7qDL-iiKHEvLEe6JnER5eelaUSbi5NgCyBt822JJGWC9WdRiSVlOtlQ4dz7FHDLQese7C491yawLavrPz3Wgyfxrf6uuaMM9RAapukw_rDVb0NmvaaRUqcSRP2rd5dkRJXmAMXfPkqDDAFwHHID2THM8YgO1BO4d4MW4dab-WFQpUKlL3Am-UByWqeVTce35k_tFMPxxoLytj6B8VMtU3URFDkv1OT6FBVZIXwAD9Yp-YmW1VhBaqZRIcWfVIm2uc8m2cCbZDSanLBx5FqMMVC4Vfbbfcj5O4PNJ2yBlQRTlNkdBEClCQ5ih8P2hLGP0VNgpGZUsiDuyhriU0htHFujhgPoaSc8GskZY7Lk-xgiIH0HYmk1C1AymxBVPZT5dmCZRosQBD0X8CLUSza5BYWqsEog9XjhTWwIvgUqKxkDqFLSoXQRzForCAHbpxBhb5EqU_8MI-q9ERPY8D2L4sjlNgLiA4o3gWJFpzEn2_k6hsGuSmzXMZGZRU6_Xr1RoqWJZ1du8OvqWNjZySHjsONTQ8YvVKyG4czrjGRbIog5lRABFDd0_r5vFUisGBqeI2bTX8vuq6qYcz4xtClVSPUeElvlciqwtjDYqHq2Cxp7bubiApXW8JxsWZNnkmDiVi4NjaecoceEO-Iy-iEkAQ_DT1cRtg4EVVUVSRuZDQQqrWdwjQBNFdEz4FubXJGyZu2PHgQWuMjkeLodUQRDc-RTy-VopwLmWHmjtlUVPgk42oRNIpUensYcLcFLNHxpWSQayzVwCIm1UIWS3c0ysMWGlX4HVGolylsbuJk4b_GJCHE8dYiQwRRA6gw-aCR1D20YNBnkQowFHtSL_ahiqLUT3rQul12CH4jKCCT8cUY0hQPAhkUatsJJvfU3xO5rTX7coSunk1lhaZFeR5ISK4EpzHCggnf9jjP27jJ0la8S2VtY1yG02rj5G8J_ZJZtMWHXTdFg5vzUnFsm5L6MTei6-RSRb7bScy8ar3ht5ax8oEY6aXT1tEu6PZUVqPgxrwAdjVZBHscOCvc1oisVg6PWdj0pK30Iw2H5zXVYxCq7lbIVpgCVIMZiVHTZpcjqILeYAWUqOnzlKm8YHtEbmPYzV5UfdnGjxK_RQtdpZQHqp7U1jPApxO86p2Y_gnw04j2JSIJlJ-o56YL2G0FBAAzkMm57RolLbdVY2MVfwfQSoHecUoxuh6sJMRQmR18wmuyU3XB5EYVs0-pheB3Nw0cK6h5r8R848i5pk3_x8i5sV6-aciZtLm_w0x_1EbXUfMi_X6b8T8RxCz78_WP8R2Ob_Kdv4GlG7VnfmrS3y3h8MGGyK8jlOO3bzaRqPVGG5bnAFb35svPaK9DQBmiaxzUZ3ZotWmG23WzbsOwVtmPHTOmf2qK6rNL-TOXUlptHgXPIeFwtlFPwwOfNP07WHzsW5BD8_O69dsuV60eJb32g2z2Vis2aMUugaI36MwppPjjBHgfksgeIuAO0YAyaQhEL5FwBsj0Ou5iLcIzEYJdDaI3iIwHyMQdjbYvkVgMUZALEfbRqMElmMEIu99bSPnzDEXWMG_-0Y9C40F2mL1JzWO7vs9BkCQ-iCSitrmbHU_7CsRLJFNM6hGdlSiimNXGZ_CMP-oz4lroMfoUPbIXj4_3nU4uYc8dLlrjngb6EkYqq3t6oZLC4ot9sx8kcSiOQFtDq1JpxSqmH6Y6UpR94W1R6iD9Ke1pjWpfw0lgwOeH6M-NYhj7HD8WR9pt6CB9DNtG6hANugdlWvMoc_mTM9tVNmwKjSI7Cs88T6wp1g37qBVQiiNumLbDgoA1hSSNx2d9qBY6gnmFI4At9Q0AGwy-uCqlqkzFYHfKglZBO9uwV2N-HwREeIxHmAgkPZENWoyONn5uTMhU4B-kfoAWkms2yg1FgtFSlV5QTY4QVyhOcY2gKtG6W8eV8MZreaWOMC-uneD2hWrt6IrPmj9tEexkZS9AYND3C5YC1FWIGiI8ff0kIxPIIDzqoTH976-gAe6bZBzE4a9poiOGJgBwFFjegrXrLTGw9v1WHtQCsDnsulnwnLTgSUm9toqYY7utyhGDrORRd16XAv08HCbSD_BxebfHuwSs9MXMZ1O2b2AN3YQvh7dkcld1F1bYLb1jHKlfVjbPXGOuehY4PlkZg9bVc0j7-5MgBF5MH0ggPVC1DY-yWj3mgJrK4hik0sRO8Hwdq9aZB7JPFZEDqckKuRmrPXS9k8GizP3fWsgQV6p3Xdt_HnBD0NyoYg2QcQ3MooINTuLRpsyzQdECPl-NwaEP8a9YU43rOXvDPjLvGEfXGe_ap_C9b83PO7v7Y17ZtJrkg9Gp_K1pz0MR1dhfK7ZeO-uv7rYeIdrqxstfa9ivZHTMw8lufFk6AhK1E6IQEAxXjfidCeD3NR1OQWLdljaO_24VGM-X8cTkvKARCfvwF_6SvhHUnPtzufXvP3l58-6IHjKsMtQJiFkLbH1nBHyrofNly8IxSGZCnspn3WEqkT4jruCMcuSTjnsaXNViMhuF7q7M6KOc0WKB30EFZenYhi2Y3IEqjRrai7rMK8F6d3pC9LTAsE0HWSIxhwo67wnI89nkgcgznug9zgVZ2qIDdVhhoAvyr3AdlkPoSxfB-g4MXdUJHp9pWMtKhjqaPoR2zL2z4zVjX6kUqdvpLP4eQe92kR3Jun_Iqj_fWKmC7MviPegj3TICZ-zSDLnTBr76vRPsjveNKXllWj8EclaX-iLp878IZHZ9g0hT3Vrw2hg-z8kLLbjpyw8Oew5yWZUAViXzsh0Yjt8PE9t7sPFKYFMkSg6Xrs4DEV2MXVfLByuJHoiuxf82xv7wbvLjYvan1Uf4yNHipGm-rgm3g8VAr0N8MBNMtjoc8-Rzf9zuW55vZ7ujc7o3njJBL2t0ple0-ZP8ctYf_tPV6CmdgW6UeQNjm3h33RW-cBJlTNZPjkry55ZLhvUqJ1f47aVyVJYHz_9OtWAvHZi-nlxo-ZhWFDP-PQGNfSulX3D8psgV1PdfyK4HFLAmBMlXcbrrxK0WJisOdX7nK4Frpf03SnO5aL-ahk_rPjr8GAzbZqH5rtFI_X-lSKdXanSG-_7cP-76m3Eqw8Oj79ZqCCsdxbe9sGhSdYLGbsb8DXNe6XxzP755cuVog8iPw1Fbg1yVYrfXSg24o7svPYhit57c7SOIMoPn5-ovDGX93afqf69W6tm9ECUod-MlNTnhXSb-d-1fHVCf9fYnpGpKMWMxKK_HUisa9ON-fej29n1ead7mgma1VlMXKdCcSL9r5D9zJBvTKw5XRvVX6vvFQ_fdNRerkXCMieCq191fmVLa45s651kW-qB6CcXcu5Zwr2WbZv0dhPeeuHaW_ObMi4TcTuZ35vvd88f2YMMxVaYr0a1zRcVyJy-MJPmPC5U26k0305vvst2UxXJ7fCLFlsk3cqvv1-RJK_NxxQU9Jq4H_TfeNA3xeaevXBvdre2J8TciRxn5c5WQRiuxXIe-TPEmbNeh3N-o_-8RZHQ0DMTe_NnIqTz_PEmvnVt17Ude2k7s_l8bs39wA8X0dJznVDwaAGriJTH8F3IYclie1PcapH8aqvwkLpiqnvIFZ2RCm0jos-rcieLW6CrXRw3B7gquNEy3God_gtE13Ip">