Hi there,
This is a reissue of just the AArch64-enablement patch--i.e. it doesn't
contain the other patch that introduced 'h' core note item type. This
has the points raised in the first round fixed. Besides nits this
includes the following fairly large changes:
- added hello_aarch64.ko.bz2 and enabled it in run-strip-reloc.sh.
- added funcretval_test.c with source (not compiled, just for
reference, as it is too large and unwieldy to stick into a testfile
comment). This yields funcretval_test_aarch64.bz2, which is used in
a new test suite run-funcretval.sh.
Note that this still needs to be applied on top of the 'h' patch.
IÂ won't commit that until it's good to go, as Mark didn't like to have
unexercised code in.
Thanks,
PM
-8<---------------------------------------------------------
Signed-off-by: Petr Machata <pmachata(a)redhat.com>
---
backends/ChangeLog | 14 +
backends/Makefile.am | 17 +-
backends/aarch64_corenote.c | 162 +++++++
backends/aarch64_init.c | 61 +++
backends/aarch64_regs.c | 95 ++++
backends/aarch64_reloc.def | 157 +++++++
backends/aarch64_retval.c | 375 ++++++++++++++++
backends/aarch64_symbol.c | 56 +++
backends/libebl_CPU.h | 37 ++-
libebl/ChangeLog | 4 +
libebl/eblopenbackend.c | 3 +-
src/ChangeLog | 4 +
src/elflint.c | 4 +-
tests/ChangeLog | 11 +
tests/Makefile.am | 8 +-
tests/funcretval_test.c | 828 +++++++++++++++++++++++++++++++++++
tests/funcretval_test_aarch64.bz2 | Bin 0 -> 15644 bytes
tests/hello_aarch64.ko.bz2 | Bin 0 -> 12768 bytes
tests/run-allregs.sh | 74 +++-
tests/run-funcretval.sh | 153 +++++++
tests/run-readelf-mixed-corenote.sh | 140 ++++++
tests/run-strip-reloc.sh | 6 +-
tests/testfile_aarch64_core.bz2 | Bin 0 -> 61748 bytes
23 files changed, 2194 insertions(+), 15 deletions(-)
create mode 100644 backends/aarch64_corenote.c
create mode 100644 backends/aarch64_init.c
create mode 100644 backends/aarch64_regs.c
create mode 100644 backends/aarch64_reloc.def
create mode 100644 backends/aarch64_retval.c
create mode 100644 backends/aarch64_symbol.c
create mode 100644 tests/funcretval_test.c
create mode 100755 tests/funcretval_test_aarch64.bz2
create mode 100644 tests/hello_aarch64.ko.bz2
create mode 100755 tests/run-funcretval.sh
create mode 100644 tests/testfile_aarch64_core.bz2
diff --git a/backends/ChangeLog b/backends/ChangeLog
index 3c57f8c..e7d1268 100644
--- a/backends/ChangeLog
+++ b/backends/ChangeLog
@@ -1,3 +1,17 @@
+2013-11-22 Petr Machata <pmachata(a)redhat.com>
+
+ * Makefile.am (modules): Add aarch64.
+ (libebl_pic): Add libebl_aarch64_pic.a.
+ (aarch64_SRCS): New variable.
+ (libebl_aarch64_pic_a_SOURCES): Likewise.
+ (am_libebl_aarch64_pic_a_OBJECTS): Likewise.
+ (aarch64_regs_no_Wformat): Likewise.
+ * aarch64_corenote.c, aarch64_init.c: New files.
+ * aarch64_regs.c, aarch64_reloc.def: Likewise.
+ * aarch64_retval.c, aarch64_symbol.c: Likewise.
+ * libebl_CPU.h (dwarf_peel_type): New function.
+ (dwarf_peeled_die_type): Likewise.
+
2013-11-07 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Mark Wielaard <mjw(a)redhat.com>
diff --git a/backends/Makefile.am b/backends/Makefile.am
index 5b5e067..9bca994 100644
--- a/backends/Makefile.am
+++ b/backends/Makefile.am
@@ -32,11 +32,12 @@ AM_CPPFLAGS += -I$(top_srcdir)/libebl -I$(top_srcdir)/libasm \
-I$(top_srcdir)/libelf -I$(top_srcdir)/libdw
-modules = i386 sh x86_64 ia64 alpha arm sparc ppc ppc64 s390 tilegx
-libebl_pic = libebl_i386_pic.a libebl_sh_pic.a libebl_x86_64_pic.a \
- libebl_ia64_pic.a libebl_alpha_pic.a libebl_arm_pic.a \
- libebl_sparc_pic.a libebl_ppc_pic.a libebl_ppc64_pic.a \
- libebl_s390_pic.a libebl_tilegx_pic.a
+modules = i386 sh x86_64 ia64 alpha arm aarch64 sparc ppc ppc64 s390 \
+ tilegx
+libebl_pic = libebl_i386_pic.a libebl_sh_pic.a libebl_x86_64_pic.a \
+ libebl_ia64_pic.a libebl_alpha_pic.a libebl_arm_pic.a \
+ libebl_aarch64_pic.a libebl_sparc_pic.a libebl_ppc_pic.a \
+ libebl_ppc64_pic.a libebl_s390_pic.a libebl_tilegx_pic.a
noinst_LIBRARIES = $(libebl_pic)
noinst_DATA = $(libebl_pic:_pic.a=.so)
@@ -81,6 +82,12 @@ arm_SRCS = arm_init.c arm_symbol.c arm_regs.c arm_corenote.c \
libebl_arm_pic_a_SOURCES = $(arm_SRCS)
am_libebl_arm_pic_a_OBJECTS = $(arm_SRCS:.c=.os)
+aarch64_SRCS = aarch64_init.c aarch64_regs.c aarch64_symbol.c \
+ aarch64_corenote.c aarch64_retval.c
+libebl_aarch64_pic_a_SOURCES = $(aarch64_SRCS)
+am_libebl_aarch64_pic_a_OBJECTS = $(aarch64_SRCS:.c=.os)
+aarch64_regs_no_Wformat = yes
+
sparc_SRCS = sparc_init.c sparc_symbol.c sparc_regs.c sparc_retval.c \
sparc_corenote.c sparc64_corenote.c sparc_auxv.c
libebl_sparc_pic_a_SOURCES = $(sparc_SRCS)
diff --git a/backends/aarch64_corenote.c b/backends/aarch64_corenote.c
new file mode 100644
index 0000000..8f5b9d5
--- /dev/null
+++ b/backends/aarch64_corenote.c
@@ -0,0 +1,162 @@
+/* AArch64 specific core note handling.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <elf.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#define BACKEND aarch64_
+#include "libebl_CPU.h"
+
+#define ULONG uint64_t
+#define PID_T int32_t
+#define UID_T uint32_t
+#define GID_T uint32_t
+#define ALIGN_ULONG 8
+#define ALIGN_PID_T 4
+#define ALIGN_UID_T 4
+#define ALIGN_GID_T 4
+#define TYPE_ULONG ELF_T_XWORD
+#define TYPE_PID_T ELF_T_SWORD
+#define TYPE_UID_T ELF_T_WORD
+#define TYPE_GID_T ELF_T_WORD
+
+#define PRSTATUS_REGS_SIZE (34 * 8)
+
+static const Ebl_Register_Location prstatus_regs[] =
+ {
+ { .offset = 0, .regno = 0, .count = 32, .bits = 64 }, /* x0..x30, sp */
+ };
+
+#define PRSTATUS_REGSET_ITEMS \
+ { \
+ .name = "pc", .type = ELF_T_XWORD, .format = 'x', \
+ .offset = (offsetof (struct EBLHOOK(prstatus), pr_reg) \
+ + PRSTATUS_REGS_SIZE - 16), \
+ .group = "register" \
+ }, \
+ { \
+ .name = "pstate", .type = ELF_T_XWORD, .format = 'x', \
+ .offset = (offsetof (struct EBLHOOK(prstatus), pr_reg) \
+ + PRSTATUS_REGS_SIZE - 8), \
+ .group = "register" \
+ }
+
+static const Ebl_Register_Location aarch64_fpregset_regs[] =
+ {
+ { .offset = 0, .regno = 64, .count = 32, .bits = 128 }, /* v0..v31 */
+ };
+
+static const Ebl_Core_Item aarch64_fpregset_items[] =
+ {
+ {
+ .name = "fpsr", .type = ELF_T_WORD, .format = 'x',
+ .offset = 512, .group = "register"
+ },
+ {
+ .name = "fpcr", .type = ELF_T_WORD, .format = 'x',
+ .offset = 516, .group = "register"
+ }
+ };
+
+static const Ebl_Core_Item aarch64_tls_items[] =
+ {
+ {
+ .name = "tls", .type = ELF_T_XWORD, .format = 'x',
+ .offset = 0, .group = "register"
+ }
+ };
+
+#define AARCH64_HWBP_REG(KIND, N) \
+ { \
+ .name = "DBG" KIND "VR" #N "_EL1", .type =
ELF_T_XWORD, .format = 'x', \
+ .offset = 8 + N * 16, .group = "register" \
+ }, \
+ { \
+ .name = "DBG" KIND "CR" #N "_EL1", .type =
ELF_T_WORD, .format = 'x', \
+ .offset = 16 + N * 16, .group = "register" \
+ }
+
+#define AARCH64_BP_WP_GROUP(KIND, NAME) \
+ static const Ebl_Core_Item NAME[] = \
+ { \
+ { \
+ .name = "dbg_info", .type = ELF_T_WORD, .format = 'x', \
+ .offset = 0, .group = "control" \
+ }, \
+ /* N.B.: 4 bytes of padding here. */ \
+ \
+ AARCH64_HWBP_REG(KIND, 0), \
+ AARCH64_HWBP_REG(KIND, 1), \
+ AARCH64_HWBP_REG(KIND, 2), \
+ AARCH64_HWBP_REG(KIND, 3), \
+ AARCH64_HWBP_REG(KIND, 4), \
+ AARCH64_HWBP_REG(KIND, 5), \
+ AARCH64_HWBP_REG(KIND, 6), \
+ AARCH64_HWBP_REG(KIND, 7), \
+ AARCH64_HWBP_REG(KIND, 8), \
+ AARCH64_HWBP_REG(KIND, 9), \
+ AARCH64_HWBP_REG(KIND, 10), \
+ AARCH64_HWBP_REG(KIND, 11), \
+ AARCH64_HWBP_REG(KIND, 12), \
+ AARCH64_HWBP_REG(KIND, 13), \
+ AARCH64_HWBP_REG(KIND, 14), \
+ AARCH64_HWBP_REG(KIND, 15), \
+ \
+ /* The DBGBVR+DBGBCR pair only takes 12 bytes. There are 4 bytes \
+ of padding at the end of each pair. The item formatter in \
+ readelf can skip those, but the missing 4 bytes at the end of \
+ the whole block cause it to assume the whole item bunch \
+ repeats, so it loops around to read more. Insert an explicit \
+ (but invisible) padding word. */ \
+ { \
+ .name = "", .type = ELF_T_WORD, .format = 'h', \
+ .offset = 260, .group = "register" \
+ } \
+ }
+
+AARCH64_BP_WP_GROUP ("B", aarch64_hw_bp_items);
+AARCH64_BP_WP_GROUP ("W", aarch64_hw_wp_items);
+
+#undef AARCH64_BP_WP_GROUP
+#undef AARCH64_HWBP_REG
+
+#define EXTRA_NOTES \
+ EXTRA_REGSET_ITEMS (NT_FPREGSET, 528, \
+ aarch64_fpregset_regs, aarch64_fpregset_items) \
+ EXTRA_ITEMS (NT_ARM_TLS, 8, aarch64_tls_items) \
+ EXTRA_ITEMS (NT_ARM_HW_BREAK, 264, aarch64_hw_bp_items) \
+ EXTRA_ITEMS (NT_ARM_HW_WATCH, 264, aarch64_hw_wp_items)
+
+#include "linux-core-note.c"
diff --git a/backends/aarch64_init.c b/backends/aarch64_init.c
new file mode 100644
index 0000000..749af2a
--- /dev/null
+++ b/backends/aarch64_init.c
@@ -0,0 +1,61 @@
+/* Initialization of AArch64 specific backend library.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#define BACKEND aarch64_
+#define RELOC_PREFIX R_AARCH64_
+#include "libebl_CPU.h"
+
+/* This defines the common reloc hooks based on aarch64_reloc.def. */
+#include "common-reloc.c"
+
+
+const char *
+aarch64_init (elf, machine, eh, ehlen)
+ Elf *elf __attribute__ ((unused));
+ GElf_Half machine __attribute__ ((unused));
+ Ebl *eh;
+ size_t ehlen;
+{
+ /* Check whether the Elf_BH object has a sufficent size. */
+ if (ehlen < sizeof (Ebl))
+ return NULL;
+
+ /* We handle it. */
+ eh->name = "AARCH64";
+ aarch64_init_reloc (eh);
+ HOOK (eh, register_info);
+ HOOK (eh, core_note);
+ HOOK (eh, reloc_simple_type);
+ HOOK (eh, return_value_location);
+
+ return MODVERSION;
+}
diff --git a/backends/aarch64_regs.c b/backends/aarch64_regs.c
new file mode 100644
index 0000000..0a0ad86
--- /dev/null
+++ b/backends/aarch64_regs.c
@@ -0,0 +1,95 @@
+/* Register names and numbers for AArch64 DWARF.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <dwarf.h>
+
+#define BACKEND aarch64_
+#include "libebl_CPU.h"
+
+ssize_t
+aarch64_register_info (Ebl *ebl __attribute__ ((unused)),
+ int regno, char *name, size_t namelen,
+ const char **prefix, const char **setnamep,
+ int *bits, int *typep)
+{
+ if (name == NULL)
+ return 128;
+
+ ssize_t
+ regtype (const char *setname, int type, const char *fmt, int arg)
+ {
+ *setnamep = setname;
+ *typep = type;
+ int s = snprintf (name, namelen, fmt, arg);
+ if (s > 0 && (unsigned) s >= namelen)
+ s = -1;
+ return s + 1;
+ }
+
+ *prefix = NULL;
+ *bits = 64;
+
+ switch (regno)
+ {
+ case 0 ... 30:
+ return regtype ("integer", DW_ATE_signed, "x%d", regno);
+
+ case 31:
+ return regtype ("integer", DW_ATE_address, "sp", 0);
+
+ case 32:
+ return 0;
+
+ case 33:
+ return regtype ("integer", DW_ATE_address, "elr", 0);
+
+ case 34 ... 63:
+ return 0;
+
+ case 64 ... 95:
+ /* FP/SIMD register file supports a variety of data types--it
+ can be thought of as a register holding a single integer or
+ floating-point value, or a vector of 8-, 16-, 32- or 64-bit
+ integers. 128-bit quad-word is the only singular value that
+ covers the whole register, so mark the register thus. */
+ *bits = 128;
+ return regtype ("FP/SIMD", DW_ATE_unsigned, "v%d", regno -
64);
+
+ case 96 ... 127:
+ return 0;
+
+ default:
+ return -1;
+ }
+}
diff --git a/backends/aarch64_reloc.def b/backends/aarch64_reloc.def
new file mode 100644
index 0000000..f633157
--- /dev/null
+++ b/backends/aarch64_reloc.def
@@ -0,0 +1,157 @@
+/* List the relocation types for AArch64. -*- C -*-
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+/* NAME, REL|EXEC|DYN */
+
+RELOC_TYPE (ABS64, EXEC|DYN)
+RELOC_TYPE (ABS32, EXEC|DYN)
+RELOC_TYPE (COPY, EXEC)
+RELOC_TYPE (GLOB_DAT, EXEC|DYN)
+RELOC_TYPE (JUMP_SLOT, EXEC|DYN)
+RELOC_TYPE (RELATIVE, EXEC|DYN)
+RELOC_TYPE (TLS_DTPMOD64, EXEC|DYN)
+RELOC_TYPE (TLS_DTPREL64, EXEC|DYN)
+RELOC_TYPE (TLS_TPREL64, EXEC|DYN)
+RELOC_TYPE (TLSDESC, EXEC|DYN)
+
+/* R_AARCH64_NONE records that the section containing the place to be
+ relocated depends on the section defining the symbol mentioned in
+ the relocation directive[.] (ARM IHI 0056B). */
+RELOC_TYPE (NONE, REL)
+
+RELOC_TYPE (ABS16, REL)
+RELOC_TYPE (PREL64, REL)
+RELOC_TYPE (PREL32, REL)
+RELOC_TYPE (PREL16, REL)
+RELOC_TYPE (MOVW_UABS_G0, REL)
+RELOC_TYPE (MOVW_UABS_G0_NC, REL)
+RELOC_TYPE (MOVW_UABS_G1, REL)
+RELOC_TYPE (MOVW_UABS_G1_NC, REL)
+RELOC_TYPE (MOVW_UABS_G2, REL)
+RELOC_TYPE (MOVW_UABS_G2_NC, REL)
+RELOC_TYPE (MOVW_UABS_G3, REL)
+RELOC_TYPE (MOVW_SABS_G0, REL)
+RELOC_TYPE (MOVW_SABS_G1, REL)
+RELOC_TYPE (MOVW_SABS_G2, REL)
+RELOC_TYPE (LD_PREL_LO19, REL)
+RELOC_TYPE (ADR_PREL_LO21, REL)
+RELOC_TYPE (ADR_PREL_PG_HI21, REL)
+RELOC_TYPE (ADR_PREL_PG_HI21_NC, REL)
+RELOC_TYPE (ADD_ABS_LO12_NC, REL)
+RELOC_TYPE (LDST8_ABS_LO12_NC, REL)
+RELOC_TYPE (LDST16_ABS_LO12_NC, REL)
+RELOC_TYPE (LDST32_ABS_LO12_NC, REL)
+RELOC_TYPE (LDST64_ABS_LO12_NC, REL)
+RELOC_TYPE (LDST128_ABS_LO12_NC, REL)
+RELOC_TYPE (TSTBR14, REL)
+RELOC_TYPE (CONDBR19, REL)
+RELOC_TYPE (JUMP26, REL)
+RELOC_TYPE (CALL26, REL)
+RELOC_TYPE (MOVW_PREL_G0, REL)
+RELOC_TYPE (MOVW_PREL_G0_NC, REL)
+RELOC_TYPE (MOVW_PREL_G1, REL)
+RELOC_TYPE (MOVW_PREL_G1_NC, REL)
+RELOC_TYPE (MOVW_PREL_G2, REL)
+RELOC_TYPE (MOVW_PREL_G2_NC, REL)
+RELOC_TYPE (MOVW_PREL_G3, REL)
+RELOC_TYPE (MOVW_GOTOFF_G0, REL)
+RELOC_TYPE (MOVW_GOTOFF_G0_NC, REL)
+RELOC_TYPE (MOVW_GOTOFF_G1, REL)
+RELOC_TYPE (MOVW_GOTOFF_G1_NC, REL)
+RELOC_TYPE (MOVW_GOTOFF_G2, REL)
+RELOC_TYPE (MOVW_GOTOFF_G2_NC, REL)
+RELOC_TYPE (MOVW_GOTOFF_G3, REL)
+RELOC_TYPE (GOTREL64, REL)
+RELOC_TYPE (GOTREL32, REL)
+RELOC_TYPE (GOT_LD_PREL19, REL)
+RELOC_TYPE (LD64_GOTOFF_LO15, REL)
+RELOC_TYPE (ADR_GOT_PAGE, REL)
+RELOC_TYPE (LD64_GOT_LO12_NC, REL)
+RELOC_TYPE (LD64_GOTPAGE_LO15, REL)
+RELOC_TYPE (TLSGD_ADR_PREL21, REL)
+RELOC_TYPE (TLSGD_ADR_PAGE21, REL)
+RELOC_TYPE (TLSGD_ADD_LO12_NC, REL)
+RELOC_TYPE (TLSGD_MOVW_G1, REL)
+RELOC_TYPE (TLSGD_MOVW_G0_NC, REL)
+RELOC_TYPE (TLSLD_ADR_PREL21, REL)
+RELOC_TYPE (TLSLD_ADR_PAGE21, REL)
+RELOC_TYPE (TLSLD_ADD_LO12_NC, REL)
+RELOC_TYPE (TLSLD_MOVW_G1, REL)
+RELOC_TYPE (TLSLD_MOVW_G0_NC, REL)
+RELOC_TYPE (TLSLD_LD_PREL19, REL)
+RELOC_TYPE (TLSLD_MOVW_DTPREL_G2, REL)
+RELOC_TYPE (TLSLD_MOVW_DTPREL_G1, REL)
+RELOC_TYPE (TLSLD_MOVW_DTPREL_G1_NC, REL)
+RELOC_TYPE (TLSLD_MOVW_DTPREL_G0, REL)
+RELOC_TYPE (TLSLD_MOVW_DTPREL_G0_NC, REL)
+RELOC_TYPE (TLSLD_ADD_DTPREL_HI12, REL)
+RELOC_TYPE (TLSLD_ADD_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_ADD_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLD_LDST8_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_LDST8_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLD_LDST16_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_LDST16_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLD_LDST32_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_LDST32_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLD_LDST64_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_LDST64_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLD_LDST128_DTPREL_LO12, REL)
+RELOC_TYPE (TLSLD_LDST128_DTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSIE_MOVW_GOTTPREL_G1, REL)
+RELOC_TYPE (TLSIE_MOVW_GOTTPREL_G0_NC, REL)
+RELOC_TYPE (TLSIE_ADR_GOTTPREL_PAGE21, REL)
+RELOC_TYPE (TLSIE_LD64_GOTTPREL_LO12_NC, REL)
+RELOC_TYPE (TLSIE_LD_GOTTPREL_PREL19, REL)
+RELOC_TYPE (TLSLE_MOVW_TPREL_G2, REL)
+RELOC_TYPE (TLSLE_MOVW_TPREL_G1, REL)
+RELOC_TYPE (TLSLE_MOVW_TPREL_G1_NC, REL)
+RELOC_TYPE (TLSLE_MOVW_TPREL_G0, REL)
+RELOC_TYPE (TLSLE_MOVW_TPREL_G0_NC, REL)
+RELOC_TYPE (TLSLE_ADD_TPREL_HI12, REL)
+RELOC_TYPE (TLSLE_ADD_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_ADD_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLE_LDST8_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_LDST8_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLE_LDST16_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_LDST16_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLE_LDST32_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_LDST32_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLE_LDST64_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_LDST64_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSLE_LDST128_TPREL_LO12, REL)
+RELOC_TYPE (TLSLE_LDST128_TPREL_LO12_NC, REL)
+RELOC_TYPE (TLSDESC_LD_PREL19, REL)
+RELOC_TYPE (TLSDESC_ADR_PREL21, REL)
+RELOC_TYPE (TLSDESC_ADR_PAGE21, REL)
+RELOC_TYPE (TLSDESC_LD64_LO12, REL)
+RELOC_TYPE (TLSDESC_ADD_LO12, REL)
+RELOC_TYPE (TLSDESC_OFF_G1, REL)
+RELOC_TYPE (TLSDESC_OFF_G0_NC, REL)
+RELOC_TYPE (TLSDESC_LDR, REL)
+RELOC_TYPE (TLSDESC_ADD, REL)
+RELOC_TYPE (TLSDESC_CALL, REL)
diff --git a/backends/aarch64_retval.c b/backends/aarch64_retval.c
new file mode 100644
index 0000000..0ed7d56
--- /dev/null
+++ b/backends/aarch64_retval.c
@@ -0,0 +1,375 @@
+/* Function return value location for Linux/AArch64 ABI.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <stdio.h>
+#include <inttypes.h>
+
+#include <assert.h>
+#include <dwarf.h>
+
+#define BACKEND aarch64_
+#include "libebl_CPU.h"
+
+static int
+skip_until (Dwarf_Die *child, int tag)
+{
+ int i;
+ while (DWARF_TAG_OR_RETURN (child) != tag)
+ if ((i = dwarf_siblingof (child, child)) != 0)
+ /* If there are no members, then this is not a HFA. Errors
+ are propagated. */
+ return i;
+ return 0;
+}
+
+static int
+dwarf_bytesize_aux (Dwarf_Die *die, Dwarf_Word *sizep)
+{
+ int bits;
+ if (((bits = 8 * dwarf_bytesize (die)) < 0
+ && (bits = dwarf_bitsize (die)) < 0)
+ || bits % 8 != 0)
+ return -1;
+
+ *sizep = bits / 8;
+ return 0;
+}
+
+/* HFA (Homogeneous Floating-point Aggregate) is an aggregate type
+ whose members are all of the same floating-point type, which is
+ then base type of this HFA. Instead of being floating-point types
+ directly, members can instead themselves be HFA. Such HFA fields
+ are handled as if their type were HFA base type.
+
+ This function returns 0 if TYPEDIE is HFA, 1 if it is not, or -1 if
+ there were errors. In the former case, *SIZEP contains byte size
+ of the base type (e.g. 8 for IEEE double). *COUNT is set to the
+ number of leaf members of the HFA. */
+static int hfa_type (Dwarf_Die *ftypedie, int tag,
+ Dwarf_Word *sizep, Dwarf_Word *countp);
+
+/* Return 0 if MEMBDIE refers to a member with a floating-point or HFA
+ type, or 1 if it's not. Return -1 for errors. The meaning of the
+ remaining arguments is as documented at hfa_type. */
+static int
+member_is_fp (Dwarf_Die *membdie, Dwarf_Word *sizep, Dwarf_Word *countp)
+{
+ Dwarf_Die typedie;
+ int tag = dwarf_peeled_die_type (membdie, &typedie);
+ switch (tag)
+ {
+ case DW_TAG_base_type:;
+ Dwarf_Word encoding;
+ Dwarf_Attribute attr_mem;
+ if (dwarf_attr_integrate (&typedie, DW_AT_encoding, &attr_mem) == NULL
+ || dwarf_formudata (&attr_mem, &encoding) != 0)
+ return -1;
+
+ switch (encoding)
+ {
+ case DW_ATE_complex_float:
+ *countp = 2;
+ break;
+
+ case DW_ATE_float:
+ *countp = 1;
+ break;
+
+ default:
+ return 1;
+ }
+
+ if (dwarf_bytesize_aux (&typedie, sizep) < 0)
+ return -1;
+
+ *sizep /= *countp;
+ return 0;
+
+ case DW_TAG_structure_type:
+ case DW_TAG_union_type:
+ case DW_TAG_array_type:
+ return hfa_type (&typedie, tag, sizep, countp);
+ }
+
+ return 1;
+}
+
+static int
+hfa_type (Dwarf_Die *ftypedie, int tag, Dwarf_Word *sizep, Dwarf_Word *countp)
+{
+ assert (tag == DW_TAG_structure_type || tag == DW_TAG_class_type
+ || tag == DW_TAG_union_type || tag == DW_TAG_array_type);
+
+ int i;
+ if (tag == DW_TAG_array_type)
+ {
+ Dwarf_Word tot_size;
+ if (dwarf_aggregate_size (ftypedie, &tot_size) < 0)
+ return -1;
+
+ /* For vector types, we don't care about the underlying
+ type, but only about the vector type itself. */
+ bool vec;
+ Dwarf_Attribute attr_mem;
+ if (dwarf_formflag (dwarf_attr_integrate (ftypedie, DW_AT_GNU_vector,
+ &attr_mem), &vec) == 0
+ && vec)
+ {
+ *sizep = tot_size;
+ *countp = 1;
+
+ return 0;
+ }
+
+ if ((i = member_is_fp (ftypedie, sizep, countp)) == 0)
+ {
+ *countp = tot_size / *sizep;
+ return 0;
+ }
+
+ return i;
+ }
+
+ /* Find first DW_TAG_member and determine its type. */
+ Dwarf_Die member;
+ if ((i = dwarf_child (ftypedie, &member) != 0))
+ return i;
+
+ if ((i = skip_until (&member, DW_TAG_member)) != 0)
+ return i;
+
+ *countp = 0;
+ if ((i = member_is_fp (&member, sizep, countp)) != 0)
+ return i;
+
+ while ((i = dwarf_siblingof (&member, &member)) == 0
+ && (i = skip_until (&member, DW_TAG_member)) == 0)
+ {
+ Dwarf_Word size, count;
+ if ((i = member_is_fp (&member, &size, &count)) != 0)
+ return i;
+
+ if (*sizep != size)
+ return 1;
+
+ *countp += count;
+ }
+
+ /* At this point we already have at least one FP member, which means
+ FTYPEDIE is an HFA. So either return 0, or propagate error. */
+ return i < 0 ? i : 0;
+}
+
+static int
+pass_in_gpr (const Dwarf_Op **locp, Dwarf_Word size)
+{
+ static const Dwarf_Op loc[] =
+ {
+ { .atom = DW_OP_reg0 }, { .atom = DW_OP_piece, .number = 8 },
+ { .atom = DW_OP_reg1 }, { .atom = DW_OP_piece, .number = 8 }
+ };
+
+ *locp = loc;
+ return size <= 8 ? 1 : 4;
+}
+
+static int
+pass_by_ref (const Dwarf_Op **locp)
+{
+ static const Dwarf_Op loc[] = { { .atom = DW_OP_breg0 } };
+
+ *locp = loc;
+ return 1;
+}
+
+static int
+pass_hfa (const Dwarf_Op **locp, Dwarf_Word size, Dwarf_Word count)
+{
+ assert (count >= 1 && count <= 4);
+ assert (size == 2 || size == 4 || size == 8 || size == 16);
+
+#define DEFINE_FPREG(NAME, SIZE) \
+ static const Dwarf_Op NAME[] = { \
+ { .atom = DW_OP_regx, .number = 64 }, \
+ { .atom = DW_OP_piece, .number = SIZE }, \
+ { .atom = DW_OP_regx, .number = 65 }, \
+ { .atom = DW_OP_piece, .number = SIZE }, \
+ { .atom = DW_OP_regx, .number = 66 }, \
+ { .atom = DW_OP_piece, .number = SIZE }, \
+ { .atom = DW_OP_regx, .number = 67 }, \
+ { .atom = DW_OP_piece, .number = SIZE } \
+ }
+
+ switch (size)
+ {
+ case 2:;
+ DEFINE_FPREG (loc_hfa_2, 2);
+ *locp = loc_hfa_2;
+ break;
+
+ case 4:;
+ DEFINE_FPREG (loc_hfa_4, 4);
+ *locp = loc_hfa_4;
+ break;
+
+ case 8:;
+ DEFINE_FPREG (loc_hfa_8, 8);
+ *locp = loc_hfa_8;
+ break;
+
+ case 16:;
+ DEFINE_FPREG (loc_hfa_16, 16);
+ *locp = loc_hfa_16;
+ break;
+ }
+#undef DEFINE_FPREG
+
+ return count == 1 ? 1 : 2 * count;
+}
+
+static int
+pass_in_simd (const Dwarf_Op **locp)
+{
+ /* This is like passing single-element HFA. Size doesn't matter, so
+ pretend it's for example double. */
+ return pass_hfa (locp, 8, 1);
+}
+
+int
+aarch64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
+{
+ /* Start with the function's type, and get the DW_AT_type attribute,
+ which is the type of the return value. */
+ Dwarf_Die typedie;
+ int tag = dwarf_peeled_die_type (functypedie, &typedie);
+ if (tag <= 0)
+ return tag;
+
+ Dwarf_Word size = (Dwarf_Word)-1;
+
+ /* If the argument type is a Composite Type that is larger than 16
+ bytes, then the argument is copied to memory allocated by the
+ caller and the argument is replaced by a pointer to the copy. */
+ if (tag == DW_TAG_structure_type || tag == DW_TAG_union_type
+ || tag == DW_TAG_class_type || tag == DW_TAG_array_type)
+ {
+ Dwarf_Word base_size, count;
+ switch (hfa_type (&typedie, tag, &base_size, &count))
+ {
+ default:
+ return -1;
+
+ case 0:
+ assert (count > 0);
+ if (count <= 4)
+ return pass_hfa (locp, base_size, count);
+ /* Fall through. */
+
+ case 1:
+ /* Not a HFA. */
+ if (dwarf_aggregate_size (&typedie, &size) < 0)
+ return -1;
+ if (size > 16)
+ return pass_by_ref (locp);
+ }
+ }
+
+ if (tag == DW_TAG_base_type
+ || tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
+ {
+ if (dwarf_bytesize_aux (&typedie, &size) < 0)
+ {
+ if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
+ size = 8;
+ else
+ return -1;
+ }
+
+ Dwarf_Attribute attr_mem;
+ if (tag == DW_TAG_base_type)
+ {
+ Dwarf_Word encoding;
+ if (dwarf_formudata (dwarf_attr_integrate (&typedie, DW_AT_encoding,
+ &attr_mem),
+ &encoding) != 0)
+ return -1;
+
+ switch (encoding)
+ {
+ /* If the argument is a Half-, Single-, Double- or Quad-
+ precision Floating-point [...] the argument is allocated
+ to the least significant bits of register v[NSRN]. */
+ case DW_ATE_float:
+ switch (size)
+ {
+ case 2: /* half */
+ case 4: /* sigle */
+ case 8: /* double */
+ case 16: /* quad */
+ return pass_in_simd (locp);
+
+ default:
+ return -2;
+ }
+
+ case DW_ATE_complex_float:
+ switch (size)
+ {
+ case 8: /* float _Complex */
+ case 16: /* double _Complex */
+ case 32: /* long double _Complex */
+ return pass_hfa (locp, size / 2, 2);
+
+ default:
+ return -2;
+ }
+
+ /* If the argument is an Integral or Pointer Type, the
+ size of the argument is less than or equal to 8 bytes
+ [...] the argument is copied to the least significant
+ bits in x[NGRN]. */
+ case DW_ATE_signed:
+ case DW_ATE_unsigned:
+ case DW_ATE_unsigned_char:
+ case DW_ATE_signed_char:
+ return pass_in_gpr (locp, size);
+ }
+
+ return -2;
+ }
+ else
+ return pass_in_gpr (locp, size);
+ }
+
+ *locp = NULL;
+ return 0;
+}
diff --git a/backends/aarch64_symbol.c b/backends/aarch64_symbol.c
new file mode 100644
index 0000000..b0f3377
--- /dev/null
+++ b/backends/aarch64_symbol.c
@@ -0,0 +1,56 @@
+/* AArch64 specific symbolic name handling.
+ Copyright (C) 2013 Red Hat, Inc.
+ This file is part of elfutils.
+
+ This file is free software; you can redistribute it and/or modify
+ it under the terms of either
+
+ * the GNU Lesser General Public License as published by the Free
+ Software Foundation; either version 3 of the License, or (at
+ your option) any later version
+
+ or
+
+ * the GNU General Public License as published by the Free
+ Software Foundation; either version 2 of the License, or (at
+ your option) any later version
+
+ or both in parallel, as here.
+
+ elfutils is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received copies of the GNU General Public License and
+ the GNU Lesser General Public License along with this program. If
+ not, see <
http://www.gnu.org/licenses/>. */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <elf.h>
+#include <stddef.h>
+
+#define BACKEND aarch64_
+#include "libebl_CPU.h"
+
+
+/* Check for the simple reloc types. */
+Elf_Type
+aarch64_reloc_simple_type (Ebl *ebl __attribute__ ((unused)), int type)
+{
+ switch (type)
+ {
+ case R_AARCH64_ABS64:
+ return ELF_T_XWORD;
+ case R_AARCH64_ABS32:
+ return ELF_T_WORD;
+ case R_AARCH64_ABS16:
+ return ELF_T_HALF;
+
+ default:
+ return ELF_T_NUM;
+ }
+}
diff --git a/backends/libebl_CPU.h b/backends/libebl_CPU.h
index 09c8cd1..3ad9258 100644
--- a/backends/libebl_CPU.h
+++ b/backends/libebl_CPU.h
@@ -1,5 +1,5 @@
/* Common interface for libebl modules.
- Copyright (C) 2000, 2001, 2002, 2003, 2005 Red Hat, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2005, 2013 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
@@ -29,6 +29,7 @@
#ifndef _LIBEBL_CPU_H
#define _LIBEBL_CPU_H 1
+#include <dwarf.h>
#include <libeblP.h>
#define EBLHOOK(name) EBLHOOK_1(BACKEND, name)
@@ -52,4 +53,38 @@ extern bool (*generic_debugscn_p) (const char *) attribute_hidden;
if (_die == NULL) return -1; \
dwarf_tag (_die); })
+/* Follow typedefs and qualifiers to get to the actual type. */
+static inline int
+dwarf_peel_type (Dwarf_Die *typediep, Dwarf_Attribute *attrp)
+{
+ int tag = DWARF_TAG_OR_RETURN (typediep);
+ while (tag == DW_TAG_typedef
+ || tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
+ || tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
+ {
+ attrp = dwarf_attr_integrate (typediep, DW_AT_type, attrp);
+ typediep = dwarf_formref_die (attrp, typediep);
+ tag = DWARF_TAG_OR_RETURN (typediep);
+ }
+
+ return tag;
+}
+
+/* Get a type die corresponding to DIE. Peel CV qualifiers off
+ it. */
+static inline int
+dwarf_peeled_die_type (Dwarf_Die *die, Dwarf_Die *result)
+{
+ Dwarf_Attribute attr_mem;
+ Dwarf_Attribute *attr = dwarf_attr_integrate (die, DW_AT_type, &attr_mem);
+ if (attr == NULL)
+ /* The function has no return value, like a `void' function in C. */
+ return 0;
+
+ if (dwarf_formref_die (attr, result) == NULL)
+ return -1;
+
+ return dwarf_peel_type (result, attr);
+}
+
#endif /* libebl_CPU.h */
diff --git a/libebl/ChangeLog b/libebl/ChangeLog
index eed4481..4a75c43 100644
--- a/libebl/ChangeLog
+++ b/libebl/ChangeLog
@@ -1,3 +1,7 @@
+2013-11-22 Petr Machata <pmachata(a)redhat.com>
+
+ * eblopenbackend.c (machines): Add entry for AArch64.
+
2013-11-14 Jan Kratochvil <jan.kratochvil(a)redhat.com>
Code cleanup: Remove const in prototype
diff --git a/libebl/eblopenbackend.c b/libebl/eblopenbackend.c
index ed0c0ff..c19ae1b 100644
--- a/libebl/eblopenbackend.c
+++ b/libebl/eblopenbackend.c
@@ -1,5 +1,5 @@
/* Generate ELF backend handle.
- Copyright (C) 2000-2011 Red Hat, Inc.
+ Copyright (C) 2000-2013 Red Hat, Inc.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
@@ -131,6 +131,7 @@ static const struct
{ "openrisc", "elf_openrisc", "openrisc", 8, EM_OPENRISC,
0, 0 },
{ "arc", "elf_arc_a5", "arc_a5", 6, EM_ARC_A5, 0, 0 },
{ "xtensa", "elf_xtensa", "xtensa", 6, EM_XTENSA, 0, 0
},
+ { "aarch64", "elf_aarch64", "aarch64", 7, EM_AARCH64,
ELFCLASS64, 0 },
};
#define nmachines (sizeof (machines) / sizeof (machines[0]))
diff --git a/src/ChangeLog b/src/ChangeLog
index 6658687..efb1855 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,7 @@
+2013-11-22 Petr Machata <pmachata(a)redhat.com>
+
+ * elflint.c (valid_e_machine): Add EM_AARCH64.
+
2013-11-14 Petr Machata <pmachata(a)redhat.com>
* readelf.c (handle_core_item) <'h'>: New branch for handling
diff --git a/src/elflint.c b/src/elflint.c
index acd458b..e42072b 100644
--- a/src/elflint.c
+++ b/src/elflint.c
@@ -1,5 +1,5 @@
/* Pedantic checking of ELF files compliance with gABI/psABI spec.
- Copyright (C) 2001-2012 Red Hat, Inc.
+ Copyright (C) 2001-2013 Red Hat, Inc.
This file is part of elfutils.
Written by Ulrich Drepper <drepper(a)redhat.com>, 2001.
@@ -331,7 +331,7 @@ static const int valid_e_machine[] =
EM_CRIS, EM_JAVELIN, EM_FIREPATH, EM_ZSP, EM_MMIX, EM_HUANY, EM_PRISM,
EM_AVR, EM_FR30, EM_D10V, EM_D30V, EM_V850, EM_M32R, EM_MN10300,
EM_MN10200, EM_PJ, EM_OPENRISC, EM_ARC_A5, EM_XTENSA, EM_ALPHA,
- EM_TILEGX, EM_TILEPRO
+ EM_TILEGX, EM_TILEPRO, EM_AARCH64
};
#define nvalid_e_machine \
(sizeof (valid_e_machine) / sizeof (valid_e_machine[0]))
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 9a8ac61..fd432ad 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,14 @@
+2013-11-22 Petr Machata <pmachata(a)redhat.com>
+
+ * testfile_aarch64_core.bz2, hello_aarch64.ko.bz2: New files.
+ * funcretval_test.c, funcretval_test_aarch64.bz2: Likewise.
+ * Makefile.am (EXTRA_DIST): Add these.
+ (TESTS): Add run-funcretval.sh.
+ * run-allregs.sh: Use testfile_aarch64_core.bz2 for a regs_test.
+ * run-readelf-mixed-corenote.sh: ... and for a readelf -n test.
+ * run-strip-reloc.sh: Add a test on hello_aarch64.ko.bz2.
+ * run-funcretval.sh: New file.
+
2013-11-18 Josh Stone <jistone(a)redhat.com>
* testfilebazdbg_plr.bz2: New testfile.
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 4f8e9e4..9615d6e 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -89,7 +89,7 @@ TESTS = run-arextract.sh run-arsymtest.sh newfile test-nlist \
run-test-archive64.sh run-readelf-vmcoreinfo.sh \
run-readelf-mixed-corenote.sh run-dwfllines.sh \
run-dwfl-report-elf-align.sh run-addr2line-test.sh \
- run-addr2line-i-test.sh run-varlocs.sh
+ run-addr2line-i-test.sh run-varlocs.sh run-funcretval.sh
if !STANDALONE
check_PROGRAMS += msg_tst md5-sha1-test
@@ -124,7 +124,7 @@ EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
run-strip-test4.sh run-strip-test5.sh run-strip-test6.sh \
run-strip-test7.sh run-strip-test8.sh run-strip-groups.sh \
run-strip-reloc.sh hello_i386.ko.bz2 hello_x86_64.ko.bz2 \
- hello_ppc64.ko.bz2 hello_s390.ko.bz2 \
+ hello_ppc64.ko.bz2 hello_s390.ko.bz2 hello_aarch64.ko.bz2 \
run-unstrip-test.sh run-unstrip-test2.sh run-unstrip-M.sh\
run-elflint-self.sh run-ranlib-test.sh run-ranlib-test2.sh \
run-ranlib-test3.sh run-ranlib-test4.sh \
@@ -216,7 +216,9 @@ EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
testfile_implicit_pointer.c testfile_implicit_pointer.bz2 \
testfile_parameter_ref.c testfile_parameter_ref.bz2 \
testfile_entry_value.c testfile_entry_value.bz2 \
- testfile_implicit_value.c testfile_implicit_value.bz2
+ testfile_implicit_value.c testfile_implicit_value.bz2 \
+ testfile_aarch64_core.bz2 \
+ funcretval_test.c funcretval_test_aarch64.bz2
if USE_VALGRIND
valgrind_cmd='valgrind -q --trace-children=yes --error-exitcode=1
--run-libc-freeres=no'
diff --git a/tests/funcretval_test.c b/tests/funcretval_test.c
new file mode 100644
index 0000000..7e20f52
--- /dev/null
+++ b/tests/funcretval_test.c
@@ -0,0 +1,828 @@
+signed char fun_char (void) { return 5; }
+short fun_short (void) { return 6; }
+int fun_int (void) { return 7; }
+void *fun_ptr (void) { return &fun_ptr; }
+int fun_iptr (void) { return 8; }
+long fun_long (void) { return 9; }
+__int128 fun_int128 (void) { return 10; }
+
+typedef struct { int i[10]; } large_struct1_t;
+large_struct1_t fun_large_struct1 (void) {
+ large_struct1_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 } };
+ return ret;
+}
+
+typedef struct { int i1; int i2; int i3; int i4; int i5;
+ int i6; int i7; int i8; int i9; int i10; } large_struct2_t;
+large_struct2_t fun_large_struct2 (void) {
+ large_struct2_t ret = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+ return ret;
+}
+
+float fun_float (void) { return 1.5; }
+float _Complex fun_float_complex (void) { return 1.5 + 2.5i; }
+
+double fun_double (void) { return 2.5; }
+double _Complex fun_double_complex (void) { return 2.5 + 3.5i; }
+
+long double fun_long_double (void) { return 3.5; }
+long double _Complex fun_long_double_complex (void) { return 4.5 + 5.5i; }
+
+#ifdef FLOAT128
+__float128 fun_float128 (void) { return 3.5; }
+#endif
+
+// 8 byte vectors.
+
+typedef signed char __attribute__ ((vector_size (8))) vec_char_8_t;
+vec_char_8_t fun_vec_char_8 (void) {
+ vec_char_8_t ret = { 1, 2, 3, 4, 5, 6, 7, 8 };
+ return ret;
+}
+
+typedef short __attribute__ ((vector_size (8))) vec_short_8_t;
+vec_short_8_t fun_vec_short_8 (void) {
+ vec_short_8_t ret = { 2, 3, 4, 5 };
+ return ret;
+}
+
+typedef int __attribute__ ((vector_size (8))) vec_int_8_t;
+vec_int_8_t fun_vec_int_8 (void) {
+ vec_int_8_t ret = { 3, 4 };
+ return ret;
+}
+
+typedef long __attribute__ ((vector_size (8))) vec_long_8_t;
+vec_long_8_t fun_vec_long_8 (void) {
+ vec_long_8_t ret = { 5 };
+ return ret;
+}
+
+typedef float __attribute__ ((vector_size (8))) vec_float_8_t;
+vec_float_8_t fun_vec_float_8 (void) {
+ vec_float_8_t ret = { 1.5, 2.5 };
+ return ret;
+}
+
+typedef double __attribute__ ((vector_size (8))) vec_double_8_t;
+#ifndef AARCH64_BUG_1032854
+//
https://bugzilla.redhat.com/show_bug.cgi?id=1032854
+vec_double_8_t fun_vec_double_8 (void) {
+ vec_double_8_t ret = { 3.5 };
+ return ret;
+}
+#endif
+
+// 16 byte vectors.
+
+typedef signed char __attribute__ ((vector_size (16))) vec_char_16_t;
+vec_char_16_t fun_vec_char_16 (void) {
+ vec_char_16_t ret = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+ return ret;
+}
+
+typedef short __attribute__ ((vector_size (16))) vec_short_16_t;
+vec_short_16_t fun_vec_short_16 (void) {
+ vec_short_16_t ret = { 2, 3, 4, 5, 6, 7, 8 };
+ return ret;
+}
+
+typedef int __attribute__ ((vector_size (16))) vec_int_16_t;
+vec_int_16_t fun_vec_int_16 (void) {
+ vec_int_16_t ret = { 2, 3, 4 };
+ return ret;
+}
+
+typedef long __attribute__ ((vector_size (16))) vec_long_16_t;
+vec_long_16_t fun_vec_long_16 (void) {
+ vec_long_16_t ret = { 3, 4 };
+ return ret;
+}
+
+typedef __int128 __attribute__ ((vector_size (16))) vec_int128_16_t;
+vec_int128_16_t fun_vec_int128_16 (void) {
+ vec_int128_16_t ret = { 999 };
+ return ret;
+}
+
+typedef float __attribute__ ((vector_size (16))) vec_float_16_t;
+vec_float_16_t fun_vec_float_16 (void) {
+ vec_float_16_t ret = { 1.5, 2.5, 3.5, 4.5 };
+ return ret;
+}
+
+typedef double __attribute__ ((vector_size (16))) vec_double_16_t;
+vec_double_16_t fun_vec_double_16 (void) {
+ vec_double_16_t ret = { 2.5, 5 };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef __float128 __attribute__ ((vector_size (16))) vec_float128_16_t;
+vec_float128_16_t fun_vec_float128_16 (void) {
+ vec_float128_16_t ret = { 7.5 };
+ return ret;
+}
+#endif
+
+// Homogeneous floating-point aggregates.
+
+typedef struct { float f; } hfa1_float_t;
+hfa1_float_t fun_hfa1_float (void) {
+ hfa1_float_t ret = { 1.5 };
+ return ret;
+}
+
+typedef struct { double f; } hfa1_double_t;
+hfa1_double_t fun_hfa1_double (void) {
+ hfa1_double_t ret = { 3.0 };
+ return ret;
+}
+
+typedef struct { long double f; } hfa1_long_double_t;
+hfa1_long_double_t fun_hfa1_long_double (void) {
+ hfa1_long_double_t ret = { 3.0 };
+ return ret;
+}
+
+typedef struct { float f[1]; } hfa1_float_a_t;
+hfa1_float_a_t fun_hfa1_float_a (void) {
+ hfa1_float_a_t ret = { { 1.5 } };
+ return ret;
+}
+
+typedef struct { double f[1]; } hfa1_double_a_t;
+hfa1_double_a_t fun_hfa1_double_a (void) {
+ hfa1_double_a_t ret = { { 3.0 } };
+ return ret;
+}
+
+typedef struct { long double f[1]; } hfa1_long_double_a_t;
+hfa1_long_double_a_t fun_hfa1_long_double_a (void) {
+ hfa1_long_double_a_t ret = { { 3.0 } };
+ return ret;
+}
+
+typedef struct { float f; float g; } hfa2_float_t;
+hfa2_float_t fun_hfa2_float (void) {
+ hfa2_float_t ret = { 1.5, 3.0 };
+ return ret;
+}
+
+typedef struct { double f; double g; } hfa2_double_t;
+hfa2_double_t fun_hfa2_double (void) {
+ hfa2_double_t ret = { 3.0, 4.5 };
+ return ret;
+}
+
+typedef struct { long double f; long double g; } hfa2_long_double_t;
+hfa2_long_double_t fun_hfa2_long_double (void) {
+ hfa2_long_double_t ret = { 3.0, 4.5 };
+ return ret;
+}
+
+typedef struct { float f[2]; } hfa2_float_a_t;
+hfa2_float_a_t fun_hfa2_float_a (void) {
+ hfa2_float_a_t ret = { { 2.5, 3.5 } };
+ return ret;
+}
+
+typedef struct { double f[2]; } hfa2_double_a_t;
+hfa2_double_a_t fun_hfa2_double_a (void) {
+ hfa2_double_a_t ret = { { 3.0, 3.5 } };
+ return ret;
+}
+
+typedef struct { long double f[2]; } hfa2_long_double_a_t;
+hfa2_long_double_a_t fun_hfa2_long_double_a (void) {
+ hfa2_long_double_a_t ret = { { 3.0, 4.0 } };
+ return ret;
+}
+
+typedef struct { float f; float g; float h; } hfa3_float_t;
+hfa3_float_t fun_hfa3_float (void) {
+ hfa3_float_t ret = { 1.5, 3.0, 4.5 };
+ return ret;
+}
+
+typedef struct { double f; double g; double h; } hfa3_double_t;
+hfa3_double_t fun_hfa3_double (void) {
+ hfa3_double_t ret = { 3.0, 4.5, 9.5 };
+ return ret;
+}
+
+typedef struct { long double f; long double g; long double h; } hfa3_long_double_t;
+hfa3_long_double_t fun_hfa3_long_double (void) {
+ hfa3_long_double_t ret = { 3.0, 4.5, 9.5 };
+ return ret;
+}
+
+typedef struct { float f[3]; } hfa3_float_a_t;
+hfa3_float_a_t fun_hfa3_float_a (void) {
+ hfa3_float_a_t ret = { { 3.5, 4.5, 5.5 } };
+ return ret;
+}
+
+typedef struct { double f[3]; } hfa3_double_a_t;
+hfa3_double_a_t fun_hfa3_double_a (void) {
+ hfa3_double_a_t ret = { { 3.0, 3.5, 4.0 } };
+ return ret;
+}
+
+typedef struct { long double f[3]; } hfa3_long_double_a_t;
+hfa3_long_double_a_t fun_hfa3_long_double_a (void) {
+ hfa3_long_double_a_t ret = { { 3.0, 4.0, 5.0 } };
+ return ret;
+}
+
+typedef struct { float f; float g; float h; float i; } hfa4_float_t;
+hfa4_float_t fun_hfa4_float (void) {
+ hfa4_float_t ret = { 1.5, 3.5, 4.5, 9.5 };
+ return ret;
+}
+
+typedef struct { double f; double g; double h; double i; } hfa4_double_t;
+hfa4_double_t fun_hfa4_double (void) {
+ hfa4_double_t ret = { 3.5, 4.5, 9.5, 1.5 };
+ return ret;
+}
+
+typedef struct { long double f; long double g; long double h; long double i; }
hfa4_long_double_t;
+hfa4_long_double_t fun_hfa4_long_double (void) {
+ hfa4_long_double_t ret = { 3.5, 4.5, 9.5, 1.5 };
+ return ret;
+}
+
+typedef struct { float f[4]; } hfa4_float_a_t;
+hfa4_float_a_t fun_hfa4_float_a (void) {
+ hfa4_float_a_t ret = { { 4.5, 5.5, 6.5, 7.5 } };
+ return ret;
+}
+
+typedef struct { double f[4]; } hfa4_double_a_t;
+hfa4_double_a_t fun_hfa4_double_a (void) {
+ hfa4_double_a_t ret = { { 3.0, 4.5, 5.0, 5.5 } };
+ return ret;
+}
+
+typedef struct { long double f[4]; } hfa4_long_double_a_t;
+hfa4_long_double_a_t fun_hfa4_long_double_a (void) {
+ hfa4_long_double_a_t ret = { { 3.0, 4.0, 5.0, 6.0 } };
+ return ret;
+}
+
+typedef struct { float f; float g; float h; float i; float j; } nfa5_float_t;
+nfa5_float_t fun_nfa5_float (void) {
+ nfa5_float_t ret = { 1.5, 3.5, 4.5, 9.5, 10.5 };
+ return ret;
+}
+
+typedef struct { double f; double g; double h; double i; double j; } nfa5_double_t;
+nfa5_double_t fun_nfa5_double (void) {
+ nfa5_double_t ret = { 3.5, 4.5, 9.5, 1.5, 2.5 };
+ return ret;
+}
+
+typedef struct { long double f; long double g; long double h; long double i; long double
j; } nfa5_long_double_t;
+nfa5_long_double_t fun_nfa5_long_double (void) {
+ nfa5_long_double_t ret = { 3.5, 4.5, 9.5, 1.5, 2.5 };
+ return ret;
+}
+
+typedef struct { float f[5]; } nfa5_float_a_t;
+nfa5_float_a_t fun_nfa5_float_a (void) {
+ nfa5_float_a_t ret = { { 4.5, 5.5, 6.5, 7.5, 9.5 } };
+ return ret;
+}
+
+typedef struct { double f[5]; } nfa5_double_a_t;
+nfa5_double_a_t fun_nfa5_double_a (void) {
+ nfa5_double_a_t ret = { { 3.0, 4.5, 5.0, 5.5, 6.5 } };
+ return ret;
+}
+
+typedef struct { long double f[5]; } nfa5_long_double_a_t;
+nfa5_long_double_a_t fun_nfa5_long_double_a (void) {
+ nfa5_long_double_a_t ret = { { 3.0, 4.0, 5.0, 6.0, 7.0 } };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef struct { __float128 f; } hfa1_float128_t;
+hfa1_float128_t fun_hfa1_float128 (void) {
+ hfa1_float128_t ret = { 4.5 };
+ return ret;
+}
+
+typedef struct { __float128 f; __float128 g; } hfa2_float128_t;
+hfa2_float128_t fun_hfa2_float128 (void) {
+ hfa2_float128_t ret = { 4.5, 9.5 };
+ return ret;
+}
+
+typedef struct { __float128 f; __float128 g; __float128 h; } hfa3_float128_t;
+hfa3_float128_t fun_hfa3_float128 (void) {
+ hfa3_float128_t ret = { 4.5, 9.5, 12.5 };
+ return ret;
+}
+
+typedef struct { __float128 f; __float128 g; __float128 h; __float128 i; }
hfa4_float128_t;
+hfa4_float128_t fun_hfa4_float128 (void) {
+ hfa4_float128_t ret = { 4.5, 9.5, 3.5, 1.5 };
+ return ret;
+}
+#endif
+
+// Homogeneous vector aggregates of 1 element.
+
+typedef struct { vec_char_8_t a; } hva1_vec_char_8_t;
+hva1_vec_char_8_t fun_hva1_vec_char_8 (void) {
+ hva1_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 } };
+ return ret;
+}
+
+typedef struct { vec_short_8_t a; } hva1_vec_short_8_t;
+hva1_vec_short_8_t fun_hva1_vec_short_8 (void) {
+ hva1_vec_short_8_t ret = { { 2, 3, 4, 5 } };
+ return ret;
+}
+
+typedef struct { vec_int_8_t a; } hva1_vec_int_8_t;
+hva1_vec_int_8_t fun_hva1_vec_int_8 (void) {
+ hva1_vec_int_8_t ret = { { 3, 4 } };
+ return ret;
+}
+
+typedef struct { vec_long_8_t a; } hva1_vec_long_8_t;
+hva1_vec_long_8_t fun_hva1_vec_long_8 (void) {
+ hva1_vec_long_8_t ret = { { 5 } };
+ return ret;
+}
+
+typedef struct { vec_float_8_t a; } hva1_vec_float_8_t;
+hva1_vec_float_8_t fun_hva1_vec_float_8 (void) {
+ hva1_vec_float_8_t ret = { { 1.5, 2.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_8_t a; } hva1_vec_double_8_t;
+hva1_vec_double_8_t fun_hva1_vec_double_8 (void) {
+ hva1_vec_double_8_t ret = { { 3.5 } };
+ return ret;
+}
+
+typedef struct { vec_char_16_t a; } hva1_vec_char_16_t;
+hva1_vec_char_16_t fun_hva1_vec_char_16_t (void) {
+ hva1_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16 } };
+ return ret;
+}
+
+typedef struct { vec_short_16_t a; } hva1_vec_short_16_t;
+hva1_vec_short_16_t fun_hva1_vec_short_16_t (void) {
+ hva1_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 } };
+ return ret;
+}
+
+typedef struct { vec_int_16_t a; } hva1_vec_int_16_t;
+hva1_vec_int_16_t fun_hva1_vec_int_16_t (void) {
+ hva1_vec_int_16_t ret = { { 3, 4, 5, 6 } };
+ return ret;
+}
+
+typedef struct { vec_long_16_t a; } hva1_vec_long_16_t;
+hva1_vec_long_16_t fun_hva1_vec_long_16_t (void) {
+ hva1_vec_long_16_t ret = { { 4, 5 } };
+ return ret;
+}
+
+typedef struct { vec_int128_16_t a; } hva1_vec_int128_16_t;
+hva1_vec_int128_16_t fun_hva1_vec_int128_16_t (void) {
+ hva1_vec_int128_16_t ret = { { 6 } };
+ return ret;
+}
+
+typedef struct { vec_float_16_t a; } hva1_vec_float_16_t;
+hva1_vec_float_16_t fun_hva1_vec_float_16_t (void) {
+ hva1_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_16_t a; } hva1_vec_double_16_t;
+hva1_vec_double_16_t fun_hva1_vec_double_16_t (void) {
+ hva1_vec_double_16_t ret = { { 2.5, 3.5 } };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef struct { vec_float128_16_t a; } hva1_vec_float128_16_t;
+hva1_vec_float128_16_t fun_hva1_vec_float128_16_t (void) {
+ hva1_vec_float128_16_t ret = { { 4.5 } };
+ return ret;
+}
+#endif
+
+// Homogeneous vector aggregates of 2 elements.
+
+typedef struct { vec_char_8_t a; vec_char_8_t b; } hva2_vec_char_8_t;
+hva2_vec_char_8_t fun_hva2_vec_char_8 (void) {
+ hva2_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 },
+ { 2, 3, 4, 5, 6, 7, 8, 9 } };
+ return ret;
+}
+
+typedef struct { vec_short_8_t a; vec_short_8_t b; } hva2_vec_short_8_t;
+hva2_vec_short_8_t fun_hva2_vec_short_8 (void) {
+ hva2_vec_short_8_t ret = { { 2, 3, 4, 5 },
+ { 3, 4, 5, 6 } };
+ return ret;
+}
+
+typedef struct { vec_int_8_t a; vec_int_8_t b; } hva2_vec_int_8_t;
+hva2_vec_int_8_t fun_hva2_vec_int_8 (void) {
+ hva2_vec_int_8_t ret = { { 3, 4 },
+ { 4, 5 } };
+ return ret;
+}
+
+typedef struct { vec_long_8_t a; vec_long_8_t b; } hva2_vec_long_8_t;
+hva2_vec_long_8_t fun_hva2_vec_long_8 (void) {
+ hva2_vec_long_8_t ret = { { 5 },
+ { 6 } };
+ return ret;
+}
+
+typedef struct { vec_float_8_t a; vec_float_8_t b; } hva2_vec_float_8_t;
+hva2_vec_float_8_t fun_hva2_vec_float_8 (void) {
+ hva2_vec_float_8_t ret = { { 1.5, 2.5 },
+ { 2.5, 3.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_8_t a; vec_double_8_t b; } hva2_vec_double_8_t;
+hva2_vec_double_8_t fun_hva2_vec_double_8 (void) {
+ hva2_vec_double_8_t ret = { { 3.5 },
+ { 4.5 } };
+ return ret;
+}
+
+typedef struct { vec_char_16_t a; vec_char_16_t b; } hva2_vec_char_16_t;
+hva2_vec_char_16_t fun_hva2_vec_char_16_t (void) {
+ hva2_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16 },
+ { 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17 } };
+ return ret;
+}
+
+typedef struct { vec_short_16_t a; vec_short_16_t b; } hva2_vec_short_16_t;
+hva2_vec_short_16_t fun_hva2_vec_short_16_t (void) {
+ hva2_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 },
+ { 3, 4, 5, 6, 7, 8, 9, 10 } };
+ return ret;
+}
+
+typedef struct { vec_int_16_t a; vec_int_16_t b; } hva2_vec_int_16_t;
+hva2_vec_int_16_t fun_hva2_vec_int_16_t (void) {
+ hva2_vec_int_16_t ret = { { 3, 4, 5, 6 },
+ { 4, 5, 6, 7 } };
+ return ret;
+}
+
+typedef struct { vec_long_16_t a; vec_long_16_t b; } hva2_vec_long_16_t;
+hva2_vec_long_16_t fun_hva2_vec_long_16_t (void) {
+ hva2_vec_long_16_t ret = { { 4, 5 },
+ { 5, 6 } };
+ return ret;
+}
+
+typedef struct { vec_int128_16_t a; vec_int128_16_t b; } hva2_vec_int128_16_t;
+hva2_vec_int128_16_t fun_hva2_vec_int128_16_t (void) {
+ hva2_vec_int128_16_t ret = { { 6 },
+ { 7 } };
+ return ret;
+}
+
+typedef struct { vec_float_16_t a; vec_float_16_t b; } hva2_vec_float_16_t;
+hva2_vec_float_16_t fun_hva2_vec_float_16_t (void) {
+ hva2_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 },
+ { 2.5, 3.5, 4.5, 5.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_16_t a; vec_double_16_t b; } hva2_vec_double_16_t;
+hva2_vec_double_16_t fun_hva2_vec_double_16_t (void) {
+ hva2_vec_double_16_t ret = { { 2.5, 3.5 },
+ { 3.5, 4.5 } };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef struct { vec_float128_16_t a; vec_float128_16_t b; } hva2_vec_float128_16_t;
+hva2_vec_float128_16_t fun_hva2_vec_float128_16_t (void) {
+ hva2_vec_float128_16_t ret = { { 4.5 },
+ { 5.5 } };
+ return ret;
+}
+#endif
+
+// Homogeneous vector aggregates of 3 elements.
+
+typedef struct { vec_char_8_t a; vec_char_8_t b; vec_char_8_t c; } hva3_vec_char_8_t;
+hva3_vec_char_8_t fun_hva3_vec_char_8 (void) {
+ hva3_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 },
+ { 2, 3, 4, 5, 6, 7, 8, 9 },
+ { 3, 4, 5, 6, 7, 8, 9, 10 } };
+ return ret;
+}
+
+typedef struct { vec_short_8_t a; vec_short_8_t b; vec_short_8_t c; }
hva3_vec_short_8_t;
+hva3_vec_short_8_t fun_hva3_vec_short_8 (void) {
+ hva3_vec_short_8_t ret = { { 2, 3, 4, 5 },
+ { 3, 4, 5, 6 },
+ { 4, 5, 6, 7 } };
+ return ret;
+}
+
+typedef struct { vec_int_8_t a; vec_int_8_t b; vec_int_8_t c; } hva3_vec_int_8_t;
+hva3_vec_int_8_t fun_hva3_vec_int_8 (void) {
+ hva3_vec_int_8_t ret = { { 3, 4 },
+ { 4, 5 },
+ { 5, 6 } };
+ return ret;
+}
+
+typedef struct { vec_long_8_t a; vec_long_8_t b; vec_long_8_t c; } hva3_vec_long_8_t;
+hva3_vec_long_8_t fun_hva3_vec_long_8 (void) {
+ hva3_vec_long_8_t ret = { { 5 },
+ { 6 },
+ { 7 } };
+ return ret;
+}
+
+typedef struct { vec_float_8_t a; vec_float_8_t b; vec_float_8_t c; }
hva3_vec_float_8_t;
+hva3_vec_float_8_t fun_hva3_vec_float_8 (void) {
+ hva3_vec_float_8_t ret = { { 1.5, 2.5 },
+ { 2.5, 3.5 },
+ { 3.5, 4.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_8_t a; vec_double_8_t b; vec_double_8_t c; }
hva3_vec_double_8_t;
+hva3_vec_double_8_t fun_hva3_vec_double_8 (void) {
+ hva3_vec_double_8_t ret = { { 3.5 },
+ { 4.5 },
+ { 5.5 } };
+ return ret;
+}
+
+typedef struct { vec_char_16_t a; vec_char_16_t b; vec_char_16_t c; }
hva3_vec_char_16_t;
+hva3_vec_char_16_t fun_hva3_vec_char_16_t (void) {
+ hva3_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16 },
+ { 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17 },
+ { 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18 } };
+ return ret;
+}
+
+typedef struct { vec_short_16_t a; vec_short_16_t b; vec_short_16_t c; }
hva3_vec_short_16_t;
+hva3_vec_short_16_t fun_hva3_vec_short_16_t (void) {
+ hva3_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 },
+ { 3, 4, 5, 6, 7, 8, 9, 10 },
+ { 4, 5, 6, 7, 8, 9, 10, 11 } };
+ return ret;
+}
+
+typedef struct { vec_int_16_t a; vec_int_16_t b; vec_int_16_t c; } hva3_vec_int_16_t;
+hva3_vec_int_16_t fun_hva3_vec_int_16_t (void) {
+ hva3_vec_int_16_t ret = { { 3, 4, 5, 6 },
+ { 4, 5, 6, 7 },
+ { 5, 6, 7, 8 } };
+ return ret;
+}
+
+typedef struct { vec_long_16_t a; vec_long_16_t b; vec_long_16_t c; }
hva3_vec_long_16_t;
+hva3_vec_long_16_t fun_hva3_vec_long_16_t (void) {
+ hva3_vec_long_16_t ret = { { 3, 4 },
+ { 4, 5 },
+ { 5, 6 } };
+ return ret;
+}
+
+typedef struct { vec_int128_16_t a; vec_int128_16_t b; vec_int128_16_t c; }
hva3_vec_int128_16_t;
+hva3_vec_int128_16_t fun_hva3_vec_int128_16_t (void) {
+ hva3_vec_int128_16_t ret = { { 6 },
+ { 7 },
+ { 8 } };
+ return ret;
+}
+
+typedef struct { vec_float_16_t a; vec_float_16_t b; vec_float_16_t c; }
hva3_vec_float_16_t;
+hva3_vec_float_16_t fun_hva3_vec_float_16_t (void) {
+ hva3_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 },
+ { 2.5, 3.5, 4.5, 5.5 },
+ { 3.5, 4.5, 5.5, 6.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_16_t a; vec_double_16_t b; vec_double_16_t c; }
hva3_vec_double_16_t;
+hva3_vec_double_16_t fun_hva3_vec_double_16_t (void) {
+ hva3_vec_double_16_t ret = { { 2.5, 3.5 },
+ { 3.5, 4.5 },
+ { 4.5, 5.5 } };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef struct { vec_float128_16_t a; vec_float128_16_t b; vec_float128_16_t c; }
hva3_vec_float128_16_t;
+hva3_vec_float128_16_t fun_hva3_vec_float128_16_t (void) {
+ hva3_vec_float128_16_t ret = { { 4.5 },
+ { 5.5 },
+ { 6.5 } };
+ return ret;
+}
+#endif
+
+// Homogeneous vector aggregates of 3 elements.
+
+typedef struct { vec_char_8_t a; vec_char_8_t b; vec_char_8_t c; vec_char_8_t d; }
hva4_vec_char_8_t;
+hva4_vec_char_8_t fun_hva4_vec_char_8 (void) {
+ hva4_vec_char_8_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8 },
+ { 2, 3, 4, 5, 6, 7, 8, 9 },
+ { 3, 4, 5, 6, 7, 8, 9, 10 },
+ { 4, 5, 6, 7, 8, 9, 10, 11 } };
+ return ret;
+}
+
+typedef struct { vec_short_8_t a; vec_short_8_t b; vec_short_8_t c; vec_short_8_t d; }
hva4_vec_short_8_t;
+hva4_vec_short_8_t fun_hva4_vec_short_8 (void) {
+ hva4_vec_short_8_t ret = { { 2, 3, 4, 5 },
+ { 3, 4, 5, 6 },
+ { 4, 5, 6, 7 },
+ { 5, 6, 7, 8 } };
+ return ret;
+}
+
+typedef struct { vec_int_8_t a; vec_int_8_t b; vec_int_8_t c; vec_int_8_t d; }
hva4_vec_int_8_t;
+hva4_vec_int_8_t fun_hva4_vec_int_8 (void) {
+ hva4_vec_int_8_t ret = { { 3, 4 },
+ { 4, 5 },
+ { 5, 6 },
+ { 6, 7 } };
+ return ret;
+}
+
+typedef struct { vec_long_8_t a; vec_long_8_t b; vec_long_8_t c; vec_long_8_t d; }
hva4_vec_long_8_t;
+hva4_vec_long_8_t fun_hva4_vec_long_8 (void) {
+ hva4_vec_long_8_t ret = { { 5 },
+ { 6 },
+ { 7 },
+ { 8 } };
+ return ret;
+}
+
+typedef struct { vec_float_8_t a; vec_float_8_t b; vec_float_8_t c; vec_float_8_t d; }
hva4_vec_float_8_t;
+hva4_vec_float_8_t fun_hva4_vec_float_8 (void) {
+ hva4_vec_float_8_t ret = { { 1.5, 2.5 },
+ { 2.5, 3.5 },
+ { 3.5, 4.5 },
+ { 4.5, 5.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_8_t a; vec_double_8_t b; vec_double_8_t c; vec_double_8_t d;
} hva4_vec_double_8_t;
+hva4_vec_double_8_t fun_hva4_vec_double_8 (void) {
+ hva4_vec_double_8_t ret = { { 3.5 },
+ { 4.5 },
+ { 5.5 },
+ { 6.5 } };
+ return ret;
+}
+
+typedef struct { vec_char_16_t a; vec_char_16_t b; vec_char_16_t c; vec_char_16_t d; }
hva4_vec_char_16_t;
+hva4_vec_char_16_t fun_hva4_vec_char_16_t (void) {
+ hva4_vec_char_16_t ret = { { 1, 2, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16 },
+ { 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17 },
+ { 3, 4, 5, 6, 7, 8, 9, 10,
+ 11, 12, 13, 14, 15, 16, 17, 18 },
+ { 4, 5, 6, 7, 8, 9, 10, 11,
+ 12, 13, 14, 15, 16, 17, 18, 19 } };
+ return ret;
+}
+
+typedef struct { vec_short_16_t a; vec_short_16_t b; vec_short_16_t c; vec_short_16_t d;
} hva4_vec_short_16_t;
+hva4_vec_short_16_t fun_hva4_vec_short_16_t (void) {
+ hva4_vec_short_16_t ret = { { 2, 3, 4, 5, 6, 7, 8, 9 },
+ { 3, 4, 5, 6, 7, 8, 9, 10 },
+ { 4, 5, 6, 7, 8, 9, 10, 11 },
+ { 5, 6, 7, 8, 9, 10, 11, 12 } };
+ return ret;
+}
+
+typedef struct { vec_int_16_t a; vec_int_16_t b; vec_int_16_t c; vec_int_16_t d; }
hva4_vec_int_16_t;
+hva4_vec_int_16_t fun_hva4_vec_int_16_t (void) {
+ hva4_vec_int_16_t ret = { { 3, 4, 5, 6 },
+ { 4, 5, 6, 7 },
+ { 5, 6, 7, 8 },
+ { 6, 7, 8, 9 } };
+ return ret;
+}
+
+typedef struct { vec_long_16_t a; vec_long_16_t b; vec_long_16_t c; vec_long_16_t d; }
hva4_vec_long_16_t;
+hva4_vec_long_16_t fun_hva4_vec_long_16_t (void) {
+ hva4_vec_long_16_t ret = { { 3, 4 },
+ { 4, 5 },
+ { 5, 6 },
+ { 6, 7 } };
+ return ret;
+}
+
+typedef struct { vec_int128_16_t a; vec_int128_16_t b; vec_int128_16_t c; vec_int128_16_t
d; } hva4_vec_int128_16_t;
+hva4_vec_int128_16_t fun_hva4_vec_int128_16_t (void) {
+ hva4_vec_int128_16_t ret = { { 6 },
+ { 7 },
+ { 8 },
+ { 9 } };
+ return ret;
+}
+
+typedef struct { vec_float_16_t a; vec_float_16_t b; vec_float_16_t c; vec_float_16_t d;
} hva4_vec_float_16_t;
+hva4_vec_float_16_t fun_hva4_vec_float_16_t (void) {
+ hva4_vec_float_16_t ret = { { 1.5, 2.5, 3.5, 4.5 },
+ { 2.5, 3.5, 4.5, 5.5 },
+ { 3.5, 4.5, 5.5, 6.5 },
+ { 4.5, 5.5, 6.5, 7.5 } };
+ return ret;
+}
+
+typedef struct { vec_double_16_t a; vec_double_16_t b; vec_double_16_t c; vec_double_16_t
d; } hva4_vec_double_16_t;
+hva4_vec_double_16_t fun_hva4_vec_double_16_t (void) {
+ hva4_vec_double_16_t ret = { { 2.5, 3.5 },
+ { 3.5, 4.5 },
+ { 4.5, 5.5 },
+ { 5.5, 6.5 } };
+ return ret;
+}
+
+#ifdef FLOAT128
+typedef struct { vec_float128_16_t a; vec_float128_16_t b; vec_float128_16_t c;
vec_float128_16_t d; } hva4_vec_float128_16_t;
+hva4_vec_float128_16_t fun_hva4_vec_float128_16_t (void) {
+ hva4_vec_float128_16_t ret = { { 4.5 },
+ { 5.5 },
+ { 6.5 },
+ { 7.5 } };
+ return ret;
+}
+#endif
+
+// Mixed HFA.
+typedef struct { float _Complex a; float b; } mixed_hfa3_cff_t;
+mixed_hfa3_cff_t fun_mixed_hfa3_cff (void) {
+ mixed_hfa3_cff_t ret = { 1.5 + 2.5i, 3.5 };
+ return ret;
+}
+
+typedef struct { double _Complex a; double b; } mixed_hfa3_cdd_t;
+mixed_hfa3_cdd_t fun_mixed_hfa3_cdd (void) {
+ mixed_hfa3_cdd_t ret = { 1.5 + 2.5i, 3.5 };
+ return ret;
+}
+
+typedef struct { long double _Complex a; long double b; } mixed_hfa3_cldld_t;
+mixed_hfa3_cldld_t fun_mixed_hfa3_cldld (void) {
+ mixed_hfa3_cldld_t ret = { 1.5 + 2.5i, 3.5 };
+ return ret;
+}
+
+typedef struct { float b; float _Complex a; } mixed_hfa3_fcf_t;
+mixed_hfa3_fcf_t fun_mixed_hfa3_fcf (void) {
+ mixed_hfa3_fcf_t ret = { 3.5, 1.5 + 2.5i };
+ return ret;
+}
+
+typedef struct { double b; double _Complex a; } mixed_hfa3_dcd_t;
+mixed_hfa3_dcd_t fun_mixed_hfa3_dcd (void) {
+ mixed_hfa3_dcd_t ret = { 3.5, 1.5 + 2.5i };
+ return ret;
+}
+
+typedef struct { long double b; long double _Complex a; } mixed_hfa3_ldcld_t;
+mixed_hfa3_ldcld_t fun_mixed_hfa3_ldcld (void) {
+ mixed_hfa3_ldcld_t ret = { 3.5, 1.5 + 2.5i };
+ return ret;
+}
+
+typedef struct { vec_float_8_t a; vec_short_8_t b; } mixed_hfa2_fltsht_t;
+mixed_hfa2_fltsht_t fun_mixed_hfa2_fltsht_t (void) {
+ mixed_hfa2_fltsht_t ret = { { 3.5, 4.5 }, { 1, 2, 3, 4 } };
+ return ret;
+}
+
+int main(int argc, char *argv[])
+{
+ return 0;
+}
diff --git a/tests/funcretval_test_aarch64.bz2 b/tests/funcretval_test_aarch64.bz2
new file mode 100755
index 0000000000000000000000000000000000000000..5494e102536b2fda2f73362ae07e93050c923ced
GIT binary patch
literal 15644
zcmV+%J>$YcT4*^jL0KkKS^6T&cmQIxfB*mg|NsC0|NsC0|NsC0|NsC0|NsC0|NsC0
z|NsC0|Nr1YTY&j)@B_7cz8^iT4I#43ZD+%~?d}jTuo`5eKH7AxgWTk<sih0I-(Ppv
z+C`_^s=IUT?=1~h^SZlW=I-O^?X_NBcF<>Ty5JvudGp^_-LAsSZRZ@fOab)gt{rK6
zcheBQ<!)6#_uo#Fd!BDzcZPWY-zlN(#;c%kw8?rhX`Ywe&$Sv~V0Fc8t=79%C$Whx
zHSF(WhKPXzW`Qt66GlT3riQ1G1ZdRL!~kkA)bg36GGx+tlW5f0CZ3up_)}?5(t2s3
zsitC{O$?bPhG<8sdSOr1KSN2iPbuv|4^v@J)S7rx%6gtCG(s8x1OS;bU`!}vF*0H#
z(@#kCF#}IfdLvB((g4r_lR>6~Lm&a5Z3*gWpa1}93`0O@Xfy*rGyn#f1R#?ph?%6&
zr=<T<Xw>x7epK|uH<F*F85$ZrLncic27#c+88kgifIUI#002EeGzN_g2dDth000^Q
z13<{rKmtuDkRXFhhJi5yNt#Wnp2?<@$)ieoJyX<rn<kB^KSG{U^-N7Rrqd)0fZnJF
zsA$oNp{9U(k5f$sk5km~Kr{dYL8gEJ14BRus1ZnnCYns98Y$*R)ioZ{WX)64O-7z+
zsj0Odnl(L7)Sii_>Q6*|shXaeCy_E_Wb`A&9-)NEpvIa(k)}+V05F*v4FTwbLrn%v
zsiuZUsA$Qc2$Dewra&f|28}eP$&(SJYM-X3>SWUs)X^JLQ__BuYLE3%`822LlABOH
zPgBroJxveQHl})}@}|muspT3QYG_BO#PkWE4^TZI4^!HZ(WmMOpk!!znhiZe&wk!s
z=azTIPL^^^Oq|E6V$6sov&-W2a&?pBmy%{=U$n%;^ywu)+<<d^<iCaxi>|7wNWobF
z5rQg;NWqAUBv4}&iZTKWMhgXt1r=3`7@(qq83hqUMiEgF6o8CXVko3p1&mcxMj}Om
zs-l7bpoppnk}+6|5CmeXF-0UsD3Rf%lM*bF5E!Dk#7PyX0MryZ5m3_*0klF95*g{J
zNeGDNA7AZH$Tj2a>R#)3p4Gz!DfK(BVhx2Y=>7+~z-TZs%968o&D7z{eMt1u`uZ1=
z8m*5A<UJ-=ycYU`i3h;RpSgfM4`J@Txb{C!&hWYRQG-Jxyh!HU<EKN={4Dr6e#H*P
zaa>)8eHH^NIPse_{OE5?q&hk$Dl-%nA$_xIN8U-e$)>xrzcl{7VH_~R`}3e6---GR
z$nbiD{&m-&K;Pb@oaSsKorY4IJ@Z@%ohj|y*$Tkmg*YA(^R^VtUQxHIJB@ZEjb(tr
zwr3SB3G1{wk(VURX@O3}6qN>!2k@{fP$|;+#*_^U95z(5&XPG4QJ*IOrkq9)Dj*g?
zhzvw4iNRnX*vOC}3LqmC#W9dv0YO5m87P9wd<=|%WI2>t1)DI6EZOO=YPbziMte-8
zk#JH?i!QXH8P6b$#h`I$GLX*9t)>i0X`pI>DW!HrNoC};dF)E{Mhe2`X4A`kOUFi@
zJb{9iN}@#*b{~yWnL_wOR9#60UqePg2Pw;K0^WO(sB>GCXdFfo8oPQ|q-e9klMY5X
zXJV3eDwrI*E{iZR!hMHn$jGkdc1MIQv_#8;CEJ^}pICg#)3Gx45+dAh#FzLCaul;#
zgCk%VC7dq)(-Q~)vJi@@C!sWBfWWLIAVAE4k)<FYl16Y^XpS{vz+tYA%5^K40j_r1
zbBQq;)tu`)^LA5t9F@A%Z&8^){2fS#2R;GC10fh;Q4rV$XhH>Z*IEq@6Ne53R&}yP
z`K)9({I?e04@=+q_&=KGjS9$LW^U;3Wo`ZPK+nR0flLUZ_fUUm0Xi!ZRRh}e5&`{R
zIzXn*8~6lq;X_{nsjSuL3~x3pO+ybRQ<e5BVjux_CP0hf++=mC08|@`xyX=uUc0(>
zE}fHMP#jC4At>%<v_MmH`5(%mH?qD?Z;AP4Q*H{~h#L^GlH~mVXeCW+-2V%QGTa;a
zJURN7IT~T|F~V|ntN&3IK=Y!hua<)oT=*82kV_V(KnjqAp#!;ydVXCCe-lnwt#};1
zg*-UpZOoS0zyJf@pRP53JM-K#n6c<>7snp8cX^qsSZ*Dnw<_Cy*M_{uryL&hZVo_f
zfzNLQ_Y;qd#Giycv-o?tX9GqE00{sVCJX})Ppv|v-%0OT4pchHotK@e!WG!a<bZ;@
zux)-eZ8J$!1~_ERlJrpv;)eCI5Sx$<+o(gSw7XJBWdmcWHteOhG9q!w05L;XY|7N;
zoB%GCq&8Jo)<ZK!RP6brSPU{u8HSgV;@Hm617AEFKn(@&rh_X`7>kEyY{)qj8T2JH
z2N~&O4A-<2;A1q*0WFaYimePasvVh?@^)o=YpD~ZTPW8|^A@$6Eb_xnxXd#nS|*ZV
z04;PF1Tg0iGt$8a15yarCkgQ6-zBKPeBrAwOuI8PW<w$fbS5zZIcW>XiDJe}E7^eF
zMYy_^upt%<3Vf_bRP?r&E;{>PUUv!uo2cF_H}7IEvF11(N#Aq09qdR+Ac8v$uWW;n
zraR&T4M=9Z1Vc0e_=+tipx&B^a4Vl@gG9bsRvQ}_(L~hO*VIr0OkRv#Xl0zZSc$hq
zB#MSvv9UB!q^*ZRqYzCKWRpE9cDB8fJRJchv|1uaxD?(?Uy`+SUg?)a!VM5r2n@D>
zTS5{+EhA+FsaG25A;E?mIl#)&+)Uaw&ADChc+qEh+Btw-p`=ajHZZuBo?sjd?Djwb
zv~EjmI2q@#lIW6WM%qZ!lB3Ow%|v;e)fG-|`l_4z<Xz=t1DYBVlne9FX^3D$%8J`w
zG8Hn$(aX1^YcXoT!zM~g5g}?ynwHL04t>MMe!zE=-6pvGT0O<E+?p*N`J04sajN0s
zic}oDMGMWzcs6_0Dzia~o;zO>txszqPO$iOdKeWe5HW|eqcb+c;YC^Csj#*sUY+qk
zD`8~YH|yxnXYvKoUV#*sn(eK%m*AuC)kQu3*eW9Y4^<U?TCV!L_nPZYe==I#q2^v%
z1e|Ha?DoB>lfi$d>rB@WFNjDI3k8ftB7mzD76`!@SF_*tx40WpSVE-i9lIE7`LpL4
zFz(1`7O<!BNk<pzhu`nA`wfSkO_Y)e32-K!(E48(H@LL~RqkE)p}2J==ecAA#YArA
zEjC6&S&+-rIcjtYlm5ot`<-{o&`Tqm?cJ$zSE>tw@n{*C0K`;$h$0<%b^go!7KYnG
zIO0II%MTjaz?;oCja31Kcu+b8J_N#P%>+f*@ttX|l--r^m@USoF^=F;j8JWh6fnpL
zX1b3M>@8%f`|N=QG8D|ggCehif?`>>fe8>}jDt^7p^kXxk53%7*x1;&5^n9*mStl!
z@p9zRh4>&)jE~QiKIQmmP9_1hIetYal*zG$WQN3$sC(2U0?q(MWdT)M-N#Xl)Yj^@
zoObJ=q%A>p*<xOHbkzp^vGJ^h(o3$Q+eHe9X3d*6YtR73AZ5#%!gK&=1Y;P+C73X)
zUBXy+ECve%SecaM7cO(A2{c8<afJ;TTxU#I8KeY4Eyi&qnMDleIGIRiIl&|{i<YwI
zInG+CBWs-C10p%Hw>iO+HWe;&jG!576b9Eh#3n~6d{02ew?xoD!-B@v`)U#aG-$Ih
za8*@60;N#|5FOB94OK+~OEnOxs->$-IX1ErGV?aHNd{%btb~IzYe2D?rvw-=2qjfg
z2sBkwumQ|lM*<C1?(YpHn2~$k;D!RJ1h06#?)M;)L>t{f4)?ss29OBVCoc6-L<$C}
z2O=+hAWf}|OGHbIV;Gqwtz?!l7{)OGVTb?*tT^)<QXikjp)CYJ_q9L^!-|*L!UCbi
z<Vi?-o{XVEU-e=ENhIr?a4aRF7{uaS30~%QC@5E=0gMVk?jkwBE}gxtHaluNj+GuH
z+lqGR^QK!Z&<xRnKqaU)JhBYPj#S8roID#Q>i~R+-Z+Ta6nM9Axlr#ZJNq%%@^`fx
zNv#TgD`X!|qA6HyX98qo8Aehf3k8L=Rfbt(={h)OjS+B@N9i;4jtvr43Z-R3Q>ieD
zD2fOfzCvJz6HHXJvBFIim`o_nf*45X&{ZPb?9N4X7EA9EtPy%t)WZrIP^^lJ7%W(8
zOkk?UA#O8d$|}q%6)ILJj^vodRg*~86+xT;5aT*yLOtI)>MSF%kd%s-dDa}KN`#Vh
ze#!e2?*3Qs6HPQNriO-rjWo8>+G=r&Z8$??AfPA^SpZmXFbz@$>%lM1?2JcXc-@Q7
zMyMi`%7I2uGg9*)ikj<9uY1LdLJ}Uw6X%_~=Rg6`EWwcji*i5^&}6McgBJ;T8TQOH
zzc&(LK9o)D?AzI-39TU{t{fRq*<F`8z}r=EYfS7M;$$xuGRL{8h%SvgJs6O2j4)sZ
zgcow-KtjdjOk<N0ynJ|ZCP|~$!LU(96-5?$#IVrTQ7DF@z}8_08I^~&86y}A1z80o
zQDCDH6_He_^@I+bRPADAyuJ_vsHAK_As|R$=up}QT14i=;!BU@l<U2?c;*50=MdS(
zX_AcLI5V{Xo?sx-g-@zA46m!@GJJ&jh}v>%P{RMB{ZBJ2sA+(`b^{DxEE(I@yc)PL
zL)X0oNU|uWT9!Pcj7o|u^W#!?qMvY}#0s=N^9tYKw1vIl<qc-%g5Q+Nsw#^X0)lp~
zzXUVj2Hd*tW~O%jRXQ$UqKiDltYUPTQ@z*Kep!rT16nw^E+3S2M^p~%37abd?wmWj
zf?d;xPUz#<&Ow$au~sPgEs8U(&_PcbltPG>lxIdzq6|#vj98<MdUt7GDsf|}p>+yQ
zf;CL4M9_ePgh)V&6i5hAl0>|k5}FzYhRuvohT#)w3oxRcu3++f|H-{8!tLJ*$4j*5
z<oo-~l0rkL!kRr?HKDr#p-`kkHKA@m?)^HU8gAQRys$m`&p#^oA_^yjZgdbsq(z|u
zRuCpgAcR;%KzC5|E|DZemwgT)7L_Q^m#TqCDsg;6hw0To=2Gd*yQdo==~PRCT!cX-
z8S9pEq@y~li1QUfHDn~!ks;t9Z83GX7A9KgEIZ~zI_{DM(Jj~ST)@msOXB|vKxe}U
ztP={)2v-afL{iWliNOaTSh1rZvv6)ZXNu(%=Lbip-{NvQtrR<bzMeB|y;`(;=5EcG
zVZ5T?-LGaLTWI;v4O*l=o+zFVHx~g63-C(_9?7>(7sS1KN(2Z1;2~=Un}N0RLPR^r
z$nyNpAC16on<pgl4|;qPR>sM?IvO8G+JWjk5jA{Hk1sxOBE?vf&`KyEiVA{xNLWRX
z`m^G`Vf;SQgA~OILXstd=r;`w3>b};<)x*IL`;Zdr;i&0N{viuFv57ZC#=>}yB%6+
zVlWpBF>F9I1>K-X3A;QCh%sismWZ%J6j|qnnzaq3Qqi`tWk%H%5s50mfllaT`Lj_9
zjM1<cV$?;5L}Ma6`PX48EEHHgCJ!P~lo}jn2tGNcpiod2PBu|kuu)=#Bs}Q}sfV%x
ziIf)nfSp?uWfN`Y2VmoeFy<UQO`<(uv9q<;vz!Vn6j|3p!f=8`2c1Kmip7d?H5Lkb
zM@aW3dOb6wbHpjA_h6m@gCb<dj2Q|i?hGG(WHN_>e7>0F)?d}YsPQ2}5RxJsbSf#*
zVem{!h$ymdWUx*i<PPMLDtLgfx@ah|MdM*v>k3)Oz^sZtN(t2*dNi>`iVHZ+92obL
zZaVpum8eCG`rv(!R12*Rv#3#EprE4}@JzgrwlrAVHH#Gz&Fz9Wv6onE<Zda8MFBbz
zGR^Q=@k$*x*w=Vp%LmKn{_fYg+VEeuJ9=zKwD~dFZKw&HXFX3Vo!1TBB|F~>O=B6D
zR4N?2s=ZyghSZ|VD@_UlttwS&)or%hOKMYWHo{v=Xl(}TuMp15r^n)aU$f0}J5HPG
z-#F#{*V*ll2mG)0c7Ha*Ra=3x#I~tczPd$ybeUDs>-d?(5SG!j%3(~XSt(_fRHZ3Q
zvhS<x_WN9Y$4S+Bp26>K{W$rWbfl-KvD-QramMIYa+{SZI?ZQ{;vyp0&l%*&Jk3?F
zmQgP8F~OjUnyw7-jjJ0mym&#T`;EK))^jtw>Rqo7)d9%CPar;l<lRvgix<lBPavb-
z9y!)9@}0o-Mp@<1U+9VX1FjApCzo*{<ZI_X`B^1N^$C05tvR1Voewz4L+yUaT3Z_m
zOmx~XFft|;GLy~gWHW+~I9%+lm#{@hRD^xkLe@5Cu9g^~_F!rnlP+RMQv(2fPgCSv
zW(1`cR%S9dII&ohx$k@Jfk3xai5L(nE3l7A31<Px84#m4r2exI<#u5#d$VWLlpJ4R
zU(8#mWf~YxVg*DtAQpg#UAIrW>rkiHi}YzRpKk#j=$U85t!oLl54_{~)(zO0$C1&m
zOK_#z`IMN&eunSgS>1`d6K-%oGDE<ftWfvfE}t&pKNb#1Ab${1z7;&2*Kut@sp#~^
z=$|{zK?Jm}D>-ln5mglx>Z=zT_G;>~eeYBG7$;Eu=Yxs&+`oN|%pp8CzF=VrzODQ8
z1LOL#MKwti#>rz%DZr3b4_B47H_FKQQ*1(7fw8N*;;2xnFZ3Mb!#4n8r#&YM0_GLT
z8jdTi-yMB=$!yq|p&^?EP@Nft%!dKq{dE8j%q)AJ=>$zoi=|OLA#*eSFZ}ETI?zL;
z06c{W?LN&_1yoRArR$~XqoqsxZU609-iEa1Mdf|hyDV=*4#fazVCba-+p0iBkXZp_
zFo_R#>VE6@R!wQO5AN*#HND8D$99Q`(3E>^0tOneB!3cTi{y4ne~+Q>wq%;w<RxMD
z+`sd|&SthB=t_e3konzDorr7`lQm((?TT|m50|g$+q;P9ju9Sw4uCn3K6imYrK}lP
zgyi-a>4qc^jh5>s-bODDTAN-Qm{WcrJ&)V+;MT)ZA6lCje*cU3IOhFRcCs9=h{?Q}
zX5l5lq7o(@`QVuam_Q(A2oZdrQnfNw&3&{rSKo_MMS<cQCK6yIE`VDa$hp=@p}J(u
z8W{Lw>v1OUur!{(N89(eP<UQNW-qP6$jiX6$@MWjzw@w$5sw<#s|B7XUv^lK^eI3>
z4AIOZ*yj2i&neS%y%(D8ICUTo!h=N%ZF;Xc>1osTbJqCYr;>YgMs>KA77urf`KPZv
zd7;Y;YvX$P_L8IUFSqWla&Y=O4F{rMq$&yI9*7xpP@N@fTiDfUyozX8Z&*@9H`#fY
zp$K?;c~uHfFoq@eH*a1dAl7ed6~YuZk*k52#2YP^%Wt>gs|#h0^TCNBS%}Y%=-3Zd
z=%VpI$4TfTU_9QCT$T;$KI?D8z-a}3XNanHFlG+Vsp(r(%rn+uWIktG=&rba%YSRp
zMDIbp+!SEr^&X^>9_z>H`-+w1`%}s=!wfLOWz3h5GI)IZ$E(u)EJE>@@y<;aCDgxt
z!}$84lfLKs43`l<%iw1$B!Etz<5*jK?sv|)U&8g$NMKmm2)W@1ohljv=!fL*dUg=I
zo7(Z@khr*yu;cl&9kx%`&a@{}mDbTk;KFbkIVYKz$C`ARUTgf>P)xFwAv8%L-&s!H
zA$;{*Z&Jv4%6ZG&r|<~SeuspmNnarm5J~y)rsFHPm?rx#zM6bETKedSgQm0ZGM(mE
zrm%-sn?vt8A4@56Z>giLWPVn^<$XoLlf~=FAz>^=$R9<~RXZH-$LRxF6VUFemTY9m
zd`-U}GJSVH<^1=j`7+hpygh79IAl*UAc9CTfQSkYx7g3<Yd@#Ywf}1=6r1sV`!C(G
z{XUoF;QkJG5<(SPvaxm8TSLFhNZ>EP^SED+lZDm)C#@}=Gugj;?s-Bjkr)$5$Rx-v
z;DQoNDeaAk*BtRdnjVPpD6bDg(ey>Fgv-Kbt`Gk|(TSwYdEWf!f3XK4W55_lFb!nv
zO!Y<=D#H*&43$PeZjf~od^_z%1!uThHMgi*atlaU4{dzr5o#_4*#mH(HH(A#rITF1
zD9AEweH&qt36tDXX#Ot$Cjv0;unp~WHY%K&G5R21BICQ51<yaZ8P`OL`}}LTzA`0h
zc#Ubxa$WtOm3ej6$&%RNkYTbAU~ZdNDi2rYP`-pyca150ZYPaksqhh23LjJN^Ho)v
zuBC}CyN!RLx%=Ei)6$f3ITZa4%?Hkl>2Oe-HA=oh8k&|6xW1E~eg4z+%eF%^?Di>g
zBe4X+aVG&0FG5%qAq4~MaQv%<;_Ol>@;u7x24jGhhgjN9=Hl!W0I?cOziEJ#{{3&E
zO}}r<w9EE-PKGb1?Q->uyysqg8V=e&^viqgV<Arhtk+&=7t@){+J6tdo3!k88(R)@
zFJ8QP637`8&|m?N)h3-7$OytfKtsCX9CKn^3CO8#%Q4u*=CU~$nM#ytXqXjAlKhN^
zIRjD$S51!Au~f+YfhVbwe&_rt!=4QJzW&(d?TaYafL#f3as|kmdiA0WqQ8R+j=^|V
zEz-K$4m$71$SP{283cm~Fg{HiXuJI1pQF?6@g%wZJDcpjd#v00IzBuoXj3#U7C$=q
zr|SRdKNjnqn)ZGyZeuQ;yLYOts4@b;$d2;*(J4w&Nlki{W~d8xhFoLpMW7-S5~T4U
z5l|2~J{CrT8i-2E8K{_tc#5Jyc~djg_Fw+%dVIn_gVhhqyKn>mJKg-=JMn_n{7>qb
zR4~*a$ib3^Nj>?15vTUJ+drdGyVhkrFOHA(%VoTOch~i{pP9tC9jCAjGirZlO+H0j
zhTh!Qo9~0&`#4%{-w*c7{uJ;a%_1w@rlkl+fR>6W3>5hIX1K#Kicba$3_Nh82A&>T
z2*Wu=)ctEz^;3}~yOIsPtMeWztOrNbd7p!e{&lhDwc+WVz<T$a_zH<Bfbrj@<7~2%
z{}%S|ee`r3_d6|qPm$YW$VxlRD%Ps5yhiag+sxZHTYqA!d)@o^+&XMGa2|0pfW#To
zX93p;8i0a=Oqs%o?dbOclxfNG$z3je{lqQhzxP}NGc#PNXSHr0W>&yx!$ypgpa6UT
z#0Ukdx&_eX2ak6p6B-FbNg<#!5~7fUaR((nm(_h=`OW^%zrbuMcHW15oM+YM>@qi$
z<GlUo%yF>&&uhKe`EFdgre)JVUk=B=vr@08&EfRXHXkQj>brdNugS;9-6TAd>i&Y(
z+9f@3OrUIhfkW3yMKTHPk??U(xPWG3Pco8f#WedH<7SP09BlR!Dkx;!1H-J@Lj3x@
zUH!g~Q-Olxu%&{6%q2!p5S2lLx7+m3!ENktS}&76T-mpQF$=`hEQ?@0F;BYzB7+7B
zFkmP_77PVo#R3Fas{~0V+8cD2;!bdcK@iA|=Z}x6_gfy{gVXl9FTsVo?X-QCi|PMg
zyP>F)$^RYqHxa{z?OV8U+4JW6eBRH??eKHGDA0RKFByFG<LA}j4aT~}919O(01sLU
zqJ3n7!k9G<_WDWU_BvhfGhJEtw|P@CF?X+V)52L*mU6iQ1OOKx!2s<n^m4yOeNG>%
z!T9~1RL;k}n-9g^xPz8`q5bd+%zIJe=dm#wwrttEjMpL?j4a2+;L-Rhdv<nCowDu;
z6r%-d5$F1dmZ1xUfC(^END-A3WNA5T!lmJ`>OId@S!zimN=(7_nE7pvZo%_LtTkx?
zZw>+=dN}{zOToVRwtU$is^iLg&+%c#eN*1=ax_CJ7YbdjxrYs$IB?>Q`oqYj`29bw
z@9^VCrS@eRcKPeq(=1FG_W+1a1_6Yma#I#-+faZ@%sUB_O!P?ANO`CmhtEnxCgDt+
zg>fJP<b-XWU^0=C#JR!by%yuG%jPb)AAjp_`CU%0RrKFcZc9ezF+D$B^WV|<8nx@$
zx2OkWwg-d)cxeo$VlgBNvmzrPBpFsDI-RTZwSE_`^KX4lXN!`s-E-`D+@B-Q@$kG(
z7sjHiFOt&hUA@j!Cn86Du&GaYeeM09i-3i@*kn@@q!>px-1!owdKRYhQ{>R-^%1)3
z(?Byc6M_Q^AFNSq1@0IG9grd%;M^<>BUxq-6GageXLS3z$7cWz|F`eFY~SYQI3Kf%
zrs_VQx~sWz=)}H0qYuw&!$z%IgD_?YD58qw;Z9wH02zZYAgdHrSS(p0sGur<EEQCU
zs*11$1yu!+RtgG5iXteYii(24VyG&jjDoCEBC<tQiVGkrf{|jykw_?@t0KivRgp-d
ziYkJv0T?QgK~w=17Db4FDj=f8Ml4cARRxO`VxcGN(=r{KCkvw|(f5147mee1ewTmw
z?v1LbE8I>-6*KXg%NYO)(e%1kcuUgvzPHA8#``1T_N}nPjI9l&mfbWYX{L9n`#d3d
zk)hJ&wY}clnqWo}+v>SIKS9gdcs{$x_;Xjj6o~W%G0GYV5Gf~w*m1Wxa5)2^KD9sM
zbui-zWZ27W7^5n4YgD{IHMM^pUQ{Eioq3@^&!MLG3n8%C<}^ewVPVThMb3*M`6fsh
zga}{~@>`j5n$N}d|KHy3>Z+>Qn4*d(zvg>x){bO7`TKe-95X(|y$K+FAJ_GFce$Y-
z8&`+HzW=S@`oP47vS?X7ze1+&?XH`6f1C5XUZ?2!e>WU(#Fn;I8XUu(GDs|L1NR)3
zjz^e_q+m|^WuFHaQS5lOYsC;@CeX>*fvkzL)Lq5R)EOCI>h8FzE4r(G_&PJMAPmR|
z1QVi@8dzMRNARhZACbpT8AA<qrV!452jc!)>(fu^dn+os=rpCMa%ShdBuh|31_>$g
z9+dKWw*fHnoCd&Yk5Ad*m;rJQ!$5pJd_@8H|F7TqKli==*ZTcV{`RX}W`>UQIq9n+
zy3r!S1mexsIY>SH;>G)KKc)T83#S<7L&4T}ly_?{w2z=_LC7Xd03DbBJupKZUbRmE
z)H!CNs;j(IC-X1EkL`mD#T|?@7nDyvQhY0$Cv0!&x!;}^dOg3_?e;x@dsn^G?QxTM
zARg16B2=)fFPF!Y<NvGl7}T7lD0+ki%=f!lc^Mdfk&%+(mX6o3%&fj@AAZzl#8Ff&
z)O!=j_4*19d?FmA^ePZdY$X0%hfiVY9=vnq@Nzjn*43l1h7ucVqJ90Qfu@==2Js}4
zgi_zFDph=@8d~5~SGWQFK=3g=4{zA}ZVB#78L>7q4S}LnR3~v>fpv>tYl}5){O}@l
zv7S4qdPp)e&2ug7?bj%T4A=k>01Od=1P-WF7+_7NPg|LAm8ex3g=$o&RH!??FLlq{
z_C54tn~RsJb^L#a$opJe;6C9*A}a-p76=d+i3AM$KC!=M0PTD^*X!L~T`o%*0{{iV
z{Y4HO8>fu#C|AJ-49;DYx?M#bC8S1;8nu1VC-154_h0Y-T{7Si0$;_@=q6*mvdTW0
z=HX;T-@l8!$;3$@lB1*qDpgVNV&@iFW~;TcC~(Xnj<>M<9rw$cU=d-11T*Iz6Uenw
zy6+mxGZf4#%hl?8jWed4!g9Si77GC)1X?7OkYY$FAa75JJKjIh_P$SXml>PZAQ}c<
zKQwSbxN2WYH%nb>iaG(QX<t6PO7W|dTPWFx2x2UZC6S!sCty*yUq-(HaMu-eD|QcJ
zu#>VQ1n`Nt7v?&&VN}S+v!kT$Evt->fMEJ(GaoFKm4^>&?0&xIX12uRnc>>#V8Me1
z-P_YJVBS4`{lZpNYEG%o)ad#?_o43Ri?(2kE|5u*fLd4Dj96WL?j44A8XyQkm^!(!
z^0yh9g;#f-VY6qH96kh9&HtJ6Jx`DK{exNVkFCS^pM+Hbh|lAe!AP+MSjA%&Ajt%B
zN*0l#qFHH3nV2Fl0t~~Lv#T}Dv$!3VshOFa`0+Eys8L$KgbwddoBlRHK!_s%ZTKDk
zb^IwSLK*(B+8iF1l{)a_&8k?>=O|0ah)F&JaDItFMpNnk<{&3=apC3Z%xwXwP(ES;
z!LN@`1WJjWF`+zL8|qD~laVuNv}V;7V;h&$Plw_3Gn-7gSi;g%I<?hI44Vt{a@_07
ztU&oW0x~keR7_yc7X|;f<8pU00^FcDo>h<^kQpl>@y!mJi*>b06Tnz-!brO?b|eVn
zCQ;#HWwoYQ8Ws|yRa61^ZF}_nogZ7g+WC=#Kq`Sjn-&QIr>D=^V%-^R>S3iyD%;=g
zDY(3^*{%8=fI~k{F@tCTzFE73l`%ph*Xpu;t~SF>)1Z)4T8g@tIEt>bkVjGP+I&CF
zs^gW2lz=s@M#RZMFwinJI{fuDiIt4Y#HpB7u!XhFZT0U+V)gq^2QJo#5-QnYUMj0K
zg5Ni|r{i^slu^n)*BZ(`Jlpq3GBGM6`<TisvwGJRO<B+BaVYMt!<EPx-HxRs2&;AY
zm0N0d??Ai4V-cl7t3n<_G$`HrJ8iPswZb;Wf+!&ffp&GOASgy=p`gGC8P4Nn0^0i|
z0txkWt7TJOq-C7B6o`2!c$vug?cl#guwh}nmEW0Z&SnOQun!9=@dX&mrPx{7&C9t#
zPIErBW>;Q&8Ns_97Lb;G`Vd2y5~FW!_4%ejVvB1NI?XkaZvar3<!qn}G8k1uMb7!l
zmb2%nJytJ6fK7WM*V^TG&Ja$hB?*&~*m@^qUYT*LA-8w;K8Rf43zPw1<;V-dLz-d&
zMuU%_zv8lzL0`jzi9LLp%y-Ov)fFaK54ekbOW^ar!}xfZ-Wz{|PD6j{$;v)e{JmFw
z4s+jm9luwt((7H;zdpmV{m6bhv8BNF6KUD0HeeO?NK2$Urff8<%Z5=zd}7Z5*lBY!
zeMCJjTSj{iVdeV{THnyMTSaQaJnoR#+UIbV+R5FR4e`VHr}yqh9+UiGKr~kL_)}&9
zsP|Itm}hj>U_e4(02`4aDXk)DOQ;bO1PSy#vy&N=vNW3OmA&%j0EC7B0$3y<H9^qb
zS4#y0?^5r68-is#%S_G8<ja%-06+i|;Ol7mb_D=nT^9-vTV#L{3>Vk6)bkuZ!32V*
zN!m|Rev?hcDFOhgZs!(n@pJTT8C=D0eO-kmD{{5V41xkvwtbn_0EziT*#UA&$?vbT
z07uN`uk&it5CmD5Xd9gT&@TmRRgD#@5qrn$YVb^m5HkQ7g6m`!7z^HnBp$>nR4P<E
zPC^tH7*}7W96P)h^>~}t^>E3K$eSQM^ydLNB#s4gEyf1tzh`6b_jD~aeRrG6<E>WU
za75;4K_E}ljm~T$i3NaH39cg`X<V(TZY#1z)z#f?*ntspx`=#$APf->x+k<3##<m4
zAWMg2XlP)|T3N9GU{Qq`uOPhA$z-s!I56SjUhnqsCh0J6aBVL0cbvTIu|sle$}a;(
zad`Xa998*82FG=Rgh*)u?yxz40aAm*GzLtp(v$ty@j$y)bn6=#s^P5Nc8%Pw1Gi}(
zqFsOh<(YmjQ}g`4gX&%}=>6C0t$X$N?v<@h{kH&MO9$8!5J(}=9z4T>btk(1-X1EK
z5q9`in6Mkk_N#k*w43oz>!)I_ud>oH!@7vsw^i^%O#qDbPbId*JA9QOLw(5p&Gu33
za&R6%XGH3@T#CJiTXT%!0~1pgCX*IJ*H9pG_RcG9Wy_l7&F9~q=5?w!{syMwM@^M!
zR-uyA7BJ-Qe0JN<e=D=GLpn;;t75*@oyGUxirf+C=+eQ1Cm!vr=k+RE)T3^{Q&q{e
z7MfS-?lDV?4NI3RQ?mt3l`&~mw_5E;ZESCJv!Z6gDq-Kl1$`=0$8&k7axCk5S*EK#
zg}zTt+-tXzYY5V*r&mFrLn7()DYK<QsIq-e9;SNoWYx^Jxbtph%bx~RrPMSbR4A&d
zB{#P9ws9k+(v%f6nrKb5r-?pwjM$P~SKHggt)m^~rJTpm9KLm7IxNUEEa%%tn?g-%
zm{F(M*4oR6?y^;!mSse{sh4?R_RdU+6|$SX$xopoTo^X>)TP?TuAe@8+ljQF<fYov
zS;m((+69!j)Tv-uP@$5^TU1JG8uIbw+qaPgspSw5r63v*TAO+oHk>g2`&dpgPUf}j
z^s$P~9ewiGV^adzveHqqUGBH7RrBvJU#Zmgz8RgP5l6E<r=RBcTUw)A=J+Jlvhb4f
z5K#{aD1uT~@*xbAwOld-$*4q=6-TbtxN$9FGiF;r>qdqOd2n_6W}`JKS)cYQ=k
zAtluv4`kIS_%qJ)`yS7}&T!{A&Bvj^=z0j9|Fm>UkA2J4RQ5ea+vEGg-E`DLn0N{n
z8=24`j`g+acK*!7hj&T(J%AwQvzLLunIS1jnlwg{S+qtsy0GnSYlalUm|-eXn6*qg
zBMgg+d%K2bQM9%e$xzOX6FL;gj~GXv4xS7+bcGPjGs^1;lH}G&uaz=|8pxGb<PL#@
z0L%lJ5_1e0&m$@iTZwJl#;mkTPHTW*)B&^$2PI|8RWjq<uSZ`bxbR`kV@|ec<BmOD
z<~)%<a$WX}5J3es8!5H*@@U!4obnvn$=45=sGi!_C3Rgk!oJ>wdby4px1{0y&6Jw@
z`V^fsbw^^qC37|ndFP)MjQi5dE&cwz3K#Zx5k;-L%c~CpElPLq;n|8Un7BJaj%o>f
zSHUo=C0E+qy1Zuc7E#>`Gl5k06pLD=*S(_A)$6O#dvkW?;+lo%Jz#p;d+97i3wuH+
zqEfcCGS`L+n=wTcPrm$7MW?}z%Wb!bi8n(8amO33yBu-Bsl3#M#~j@*!q=BoDVoIh
zUV1q7@Vx2`opfT?dF{GS-VI}M{Us{nn%n*S%{2wxY`5~jwTK&e={7L!=^_fyZeh)t
zy76s9He=b3U_%3~?e6hsp`FCIrkZDE+kRPPf>@%1a`TzjW@>B;$19S{EVAgqf$KUs
zRTfraiEs@oF+~>ktPj5I&S7eti{LiiNcOg#u`IIdKauB~(b0{l*0seHPVGV=wC1yo
zS&le#7m2pv*o$HK=*hDlNO8jovnEqZq|-_`QX__x>ePianvs%IQ&k!+JjKuhjsa?c
zK2K#kE}ybMo{(Fqe~YoRr1XtIj$mD0-miT7F3y8V`#;s6B^EWHiEWnAO{QcfU>b~Y
zrwqKhu7%=4`&?R~?_aHdWWP(|dK6g#TGe<Lp?C$LFkr#R;$)u7!tl%a?eBdzN8Km~
zD}#M()-rc#q}4DPFv<Bp7du(}*bj5uZZA5%k-mM-GmgPgtep*(3Q+lDd_2(Q{GM%d
zZF-H@TI#G&#S8>75WQ$vv10XhH0RTCZm%oFyM*5Zm@DlAunBNI(GC`{hKG0%hX8B^
zfXEQExHwY+Lmk>w1C_8F5CH&y2*M!*Apt?4pbP|qB*7L&VXTnafwJ>3LWbcS=0{V#
zd+w2+7dm>+*unNPs!wl;aM+Adi>(Y8DAM)VV<ZZYqGOKTBnFJgYiN)vGBjO$y>{od
z*cll<j)daty06yf;GGfYsC3SVCvbHG`JA(dtIqJnBnCiP1w(-7RoxF)DN*Ld5{LKC
z>1{7Jw(R-8Z|QhGv*AcdIsP4|y!Woqz%UfeA+HS4<?jBMiMF%Fh`VG02tjZ41eAsp
zmxY1y?YW(2GIbiPJAWINy9jhR)1MG`=Lq(lJQu&?OPeGR8xg(tzF(<|d>F0U9Vk^K
zK~WX{HJL3Jb2-AJO1Y=0?=X@ZcS@|kXwRwHE`ET}gK4@3?&qgz2&Yg3)y-A1ZsP*C
zOv(D>G}G}M1`z2X2sDHtDF{kT^$&{+Ibo~_(O{eblw;mpU|TH(DRSx3iWq*sjP0BD
zd1m)l?|<KW<2~9R0ENcN+?;v09rL6`bV}5zQY}YZ?6^uTTAn=V{7;Ymou=90oeQsN
zIg)J7czLG+_E1x}<8niCl(Um^`Jq+HLL}QvNv0aUU$1jd67c}c@OE2>Yk0ssaae>x
zApjzY1X!>Y!6|7+^&%$01Pcl<Me|_Nz*aBy;^=i!<r@pHLglhF2t-JPBM7h%h(Usp
zkr9Y02@{JM<mY`3dT}8Q3KNO!hd9%3A*--V?8aLWwpOI0P%2jY>y=WHz$Gf8DQW*I
zDkPu<WZ{o3gr-3NTz3CM^M?}U2-?)=yDlrTP+8+b3@E|~Mmb>cwW-wzd6xJA&Ocf0
zU{eINwHHQeAgcslg@iE-`FT3H)w^i|RAst16}Ji6b{VExDAcimAhngPK#raR*Zm#w
zHR_uVR8<^JKbu<#;e9r}{Y{NZH7pGW4f}?}^xL?+U$k`r$=M;;$LLd^!O6$>pPxJW
z-qY^eXk6y!ImNikjI$1Hw>iseiYbu?7{Qkp$CxOYLqRKt7^1kw5yNgVZ4@ZX3yWHa
z;W0~Xl`+Yu2jsb#1aGeYC$ZCSVq@vdF2X_HRe;1;s-UY8i@slwsqu|A&)N^#9_$96
zOwE!q;|t#kjBWD1?A2P9pC0*M`bm^fwTQ8T6xh6%mvIv>C9Db}W?icPXfzu?5bYA;
z?H_aUx$M_V2iY+%zyN0vP-Pb}5fma~Wxr2b-e{fqMAy^=;t(J(BLXl5aMP`hyuF8L
zU;z!QI2LgL2H;yOf+K7~lP+LDh=_-Y3MMCvQwDA_E&y!(DA$fjk?#9ALtE?HKFtPn
zoSZM+=SK#O#xQEeMYvqNZW!A#D9sydDabEQ=1Kw`!<vFoNFo^*2W^xX=eLR*8r*s!
zxY)QbAVDz@A`C!uo!pmlQ^0W$AR?i`h=hzh2zXE(;23x=ofvme@Pdbcq7*x#lbCo=
zj6?#ULUfcEf?ggXb!QP*Iv#ca>iErS2VQbLVV6zI(wr^9h78YHaBj{TZMx&^#vSjq
zzpgb(@g@2AOE{lB%c34)NmdP|Lba3Z2Uo%RA8MlToj^$h+&4pPca7jF(sj+H<edQz
zS^z*u06;<j5JCVDLphya*FKe-cZU$Stqzyq8J^>$oi6U8j;B;C-Hc3bM5d2Gk2uYc
zsiR7Z1DU=REV+W->h;$#eJ6O-MnF)8*Pom>2D8lKIVkR@Fsa;$3TU&N+jg@I?EuVx
z03gfRZ(Fw84pbr4fHyHUv7wLi`A;>q#^~-Nx%e3DP5Op?imr2ZT^)H!k0$-c5GT<f
znIk}E24JSukPJ1}M;~Q5?FH^G18c8!uyWoGtP(*$=ETSy68_M|KXU+fb~p2wmw>pu
zk)b|L$n*eE@B61FUt$Tb%x{6PLvrNN3{y~=hK)?}=PID+kGqtGx6tIGZF5dBL+c~S
zT$kTCz^R-=UAW+zb|hXzRBwjlAgBh1LLD2<u9^|lAb|s8oWZv(H3OZXZ`B2I{QVAr
z?l`}NhY*a(BPI~q3{w`oCk~PmgRL<QLI{E&h$2Kl5s?`Y1VIo@#FB+UK}evWprD|n
zP*6}%P*Nx;C@3f?6cio3z1$I;>C0ZFA!CdWD|bHc6g1(dj+*pjs(r^Ei4hB68H*gG
z)d1865yisXO}n=v!0~|gn<9^09B|x*R%oXw$i4}ST`#g=n*3v6!V|>f@kz_(Rj_I4
z+9IbwOt>$%#W?}1$x(Rbshq&%X`vT6iR|~dvzfN;a}2qOr8^A_B8n)Z-R+$6kl@x^
z!_%9<aJ%^0Ndjv`v<a=97;tApc{l@rK@d#fl1u3xQIxEZM20}1?1kou*0ZCQa2N7Q
z<s!WPGMa|raDZL5Z}b@eb+)HC&I+1GS|PXxZ~)%0Fda+Zw-V9B{g$j5XC0*Mf$Z$C
z16i8UR$xMquSC!0uljSC`+JYZK0SNZY9<rVGca&}o+oUV{Re|F+?xQ2+=c9s4(!hd
zTJ;Z+K2j+KiYTfoiYTfqRTNbfR8>(_Q4vK^M~ZlxK-0ai1n~+|s;&_RlWem9_3pkD
zN9uMg8s*{CnRU&01EWy3B(cTF>n2TCDx3*AJ+@m8eRBK0UbyDWs5j_C*55mi96TDJ
zbL`t&D*~aNnZcH(6I(Kdj*N=~3>49oiUn(i5>-GxALhOn*Z5GWN=lNHyo3)Eyz0#W
zYA;P_G+{ODUIQFuA{a?pDd<)WQG}tvJeV1!fpfCj*47DBwWSy}tfgCRENIb0vfFHA
zn!zd9tU`{rKTuEm%;zeTHzDQaqHvd;;6N}rW%kGy1sOq7;pXtJQ=+0Sr$N`u6H~n1
z1Cz-<HxK{|rpO8zBRrMOU4#436=GB+_y(Q?IGiiNrOaOQyZ==!V1&W0b*REQ0@Q=T
z0T37=5h~munC_fBqg3rRGMVvloWp!LzGov)(YmE-5QLJ6bL0m@0%Sxy3ME>y$TDIY
z^62MFKSsO%vYJ-Ky;Z`zf!i6GaZrF}gajEIU>1({k3T0=xDWi>a0gHVLVsc&p_2Qg
z;56fU4h&p1T8@{X<c#<dIYZdT2pcd049J86gYfApDIgc>9gIA4$vE(^8Md`oZn@g7
z;ECiBiV#WMBSlI>I4l4qfE)4P!aO&TkSy>gX6`pvvuoyl2S2`C?F2Qv1?k%X-%8dM
ztjzJ5!r{>a?e$rnX8v|~RL(%SZiOcFQ+ffL4ZWBp;`@G&hkEwfs;Q@Ups7#dT@KYY
z%nI-|l_INe8oa0z48sFPMF2#Af&_xW1(S}Dg@B^XG^U{FOZOqDquxkbUy=@}0|_!g
zWh&UB$XP&*7@_>@0S~sMvXB8YN|a3~wPc;<j%}s6wHV8A;KeOzM5Bdqae-GBlMJ|}
z7(s%$Cyo0J{!UD8y6a(m*Il(#Z(4j>cXoU)D+LruGeu-w1q}P4K$++9rZ*5%zGz^>
z9Ug*6WIRzLIfcj+JeP6CToZWa{CK`i-8Xdk{6noY#ljU@!m)8j@a>1I^E_Xj$)|gd
z8{22Y#hG9m-~tGdO?OjQ0<5S7K@|mp$sloG7odOUdQ;ORC{Uy|;K7Nm$RAh`Op$<y
zR49~^lu=X?CzaRMPH!(?4^O6fbIlEQ66rXOd&Rc}!W6*M2y`CIiI*&|BPwAv$ZP#C
z27Kc|m_p70EH<0bKyyZn&b&_>>ON~FJo{VLaPZx|CG_zm4q^$a?{5<yXLbxZH?K;a
z&DoCUY8{sj61A2k-k^Rj<kmNrm>86$A$RCNI>YxTa(c5UCPX!|WHJ|m-<tT|3wj1s
zGNFiKUKf-$h~`{YCE%BWVut~U;$UJ}uwo7+UlTHhN@5}mO<}0Xu+|wJda<<p9`)C}
zZgZRPqcs|)q41a|uDGM)hS^FOxr3G%8FMe6Oao@tX0W>o9Q>bK^R5LMVOg$*62c90
zhF}LuNi*zzUw~@fAHdgf59!lskjq-{xsDvA8p5S&R6Q38!xq5mr0yK!*86Rtvot-@
zJM(=OZPkPmzotGo9@m?r&~F+a4XktO0TN-I-4RlaN+Ol1ThFql9L$tLf;^wS`L~VX
z0B?gpMPNZPTN91Px1T#bj;0&f;iLzA+o6cxQ$)oevQQ;Ysv058iR==qzze+)4U)}+
z1=e!sle~!e(SB?h1+-E?84xYOSC*1$*-W#Y!Ni->7GOinlNCd()@9;C8oeD}$l4}&
zEYt^kjm9^U^9jb9xZlV1-ZSF@5P9f8h-~M}?;IisJM<_Jj()X&$4kWK<I7{+oMsQ-
z-zSD2jDYpgeoa$IOu5D}i-^WGD3zU5#k5@H!D~264t&e`M4O|f?O-X&YG&k=z|U&q
zpeeHs83I4?v@~+Aw5?%AO{g3RuR`9!6vne@h_^%=hKdFWAh`z3G?_o+<|ueK<1*YO
zK{X8-vwfLypXbqF$RUmn6X|{KQ3n8uhdMP>C>;oWiV1XJz>U^?tA!a1u==T}9G0Hp
z$chuk@@9u{+q<Ra>DTDfq;W@LSd}YNn~GHAV&OArY0b&k&@&KLZQuUp42QL7gpk;v
z29QvP4blK~nbbrX<v>%Y!I-TCg~hRh6u6*1$-I7;4ACSC0w2=b*pEoc5XhsL%2sgB
zU1QdaP&kmp$ae`WCS#K`7zRMVN(dG%q8S49s%>O+<xB5@k~*@Xh~f@nFow<2D92{4
ziOy|tfZ4bdHWOw95g3bMgPd4WmO`0L)QK_-A*O+V(?&MMK?{OLWD!IKa!g2*2?q46
zH+o*jRNP@SY9CB%lp7}F_e2s*QNX~-fdde{cMTwzn3$Ir0zx4I7#M^oO$|n&DNGZW
zBse&@|CVYIA;5_cIHSxlz#IY1iPh9iw+7&0lW3O!@skwISs+Y%b21Kc<A-w%bGq5K
z?AG3~shA;lS$-b+I0do1qX2Y=KMdSn{d$}X$PZ!5m#y8c>>10>MUWx<T5=%dJ0%7P
zR3XEHAczPcJg-gTmvF9R4GU4@TzQBcLYRKC0$eb{C_9I4d-sw4)dA=r-*LekBhG8i
zxt9ZmR9b~)PA3m>0_mm$pyM4HLxBtjxJR^a@|o<AFMs)bxe(K^^e4Y~+y)ae2f}pY
z-^(NEtBav#F0SX)ZTU9|q3w_#?3;Us$o+KK3w$;vG#Ejk#0C(QB5G@fbsRWCjY>6^
zYAcLj_}!n<cIIIFG!0Yn!I8lzMUenP0znZ5B1j$vVKZ&e8mAV!@)o}{k_W_S{6pcG
z^LaamfgI4!BQC#d0g#<FciN@%dabp)5W2Ti_}oARPCj6UU>Jr2F~)%_Mk9y4n<wLT
zstlqEPjgE)n~~jjMHCbi#tdN3A*d`fGHPX+GO$~K&8*yiL6c8%tPMt*h{qbl5dwx;
zpNotbj=#|%sqiX*&{$|Jni-fs%A6<CL$Z_^^K`o(!};0DA+gz?{}*yaI8c!KBFlJY
C&x3*h
literal 0
HcmV?d00001
diff --git a/tests/hello_aarch64.ko.bz2 b/tests/hello_aarch64.ko.bz2
new file mode 100644
index 0000000000000000000000000000000000000000..431d89f95c373dcc45f2f6c79f927fc77994b90b
GIT binary patch
literal 12768
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
literal 0
HcmV?d00001
diff --git a/tests/run-allregs.sh b/tests/run-allregs.sh
index 885a1d1..6f3862e 100755
--- a/tests/run-allregs.sh
+++ b/tests/run-allregs.sh
@@ -1,5 +1,5 @@
#! /bin/sh
-# Copyright (C) 2005, 2006, 2007, 2012 Red Hat, Inc.
+# Copyright (C) 2005, 2006, 2007, 2012, 2013 Red Hat, Inc.
# This file is part of elfutils.
#
# This file is free software; you can redistribute it and/or modify
@@ -2724,4 +2724,76 @@ VFP registers:
287: d31 (d31), float 64 bits
EOF
+# See run-readelf-mixed-corenote.sh for instructions to regenerate
+# this core file.
+regs_test testfile_aarch64_core <<\EOF
+integer registers:
+ 0: x0 (x0), signed 64 bits
+ 1: x1 (x1), signed 64 bits
+ 2: x2 (x2), signed 64 bits
+ 3: x3 (x3), signed 64 bits
+ 4: x4 (x4), signed 64 bits
+ 5: x5 (x5), signed 64 bits
+ 6: x6 (x6), signed 64 bits
+ 7: x7 (x7), signed 64 bits
+ 8: x8 (x8), signed 64 bits
+ 9: x9 (x9), signed 64 bits
+ 10: x10 (x10), signed 64 bits
+ 11: x11 (x11), signed 64 bits
+ 12: x12 (x12), signed 64 bits
+ 13: x13 (x13), signed 64 bits
+ 14: x14 (x14), signed 64 bits
+ 15: x15 (x15), signed 64 bits
+ 16: x16 (x16), signed 64 bits
+ 17: x17 (x17), signed 64 bits
+ 18: x18 (x18), signed 64 bits
+ 19: x19 (x19), signed 64 bits
+ 20: x20 (x20), signed 64 bits
+ 21: x21 (x21), signed 64 bits
+ 22: x22 (x22), signed 64 bits
+ 23: x23 (x23), signed 64 bits
+ 24: x24 (x24), signed 64 bits
+ 25: x25 (x25), signed 64 bits
+ 26: x26 (x26), signed 64 bits
+ 27: x27 (x27), signed 64 bits
+ 28: x28 (x28), signed 64 bits
+ 29: x29 (x29), signed 64 bits
+ 30: x30 (x30), signed 64 bits
+ 31: sp (sp), address 64 bits
+ 33: elr (elr), address 64 bits
+FP/SIMD registers:
+ 64: v0 (v0), unsigned 128 bits
+ 65: v1 (v1), unsigned 128 bits
+ 66: v2 (v2), unsigned 128 bits
+ 67: v3 (v3), unsigned 128 bits
+ 68: v4 (v4), unsigned 128 bits
+ 69: v5 (v5), unsigned 128 bits
+ 70: v6 (v6), unsigned 128 bits
+ 71: v7 (v7), unsigned 128 bits
+ 72: v8 (v8), unsigned 128 bits
+ 73: v9 (v9), unsigned 128 bits
+ 74: v10 (v10), unsigned 128 bits
+ 75: v11 (v11), unsigned 128 bits
+ 76: v12 (v12), unsigned 128 bits
+ 77: v13 (v13), unsigned 128 bits
+ 78: v14 (v14), unsigned 128 bits
+ 79: v15 (v15), unsigned 128 bits
+ 80: v16 (v16), unsigned 128 bits
+ 81: v17 (v17), unsigned 128 bits
+ 82: v18 (v18), unsigned 128 bits
+ 83: v19 (v19), unsigned 128 bits
+ 84: v20 (v20), unsigned 128 bits
+ 85: v21 (v21), unsigned 128 bits
+ 86: v22 (v22), unsigned 128 bits
+ 87: v23 (v23), unsigned 128 bits
+ 88: v24 (v24), unsigned 128 bits
+ 89: v25 (v25), unsigned 128 bits
+ 90: v26 (v26), unsigned 128 bits
+ 91: v27 (v27), unsigned 128 bits
+ 92: v28 (v28), unsigned 128 bits
+ 93: v29 (v29), unsigned 128 bits
+ 94: v30 (v30), unsigned 128 bits
+ 95: v31 (v31), unsigned 128 bits
+EOF
+
exit 0
diff --git a/tests/run-funcretval.sh b/tests/run-funcretval.sh
new file mode 100755
index 0000000..779bd47
--- /dev/null
+++ b/tests/run-funcretval.sh
@@ -0,0 +1,153 @@
+#! /bin/sh
+# Copyright (C) 2013 Red Hat, Inc.
+# This file is part of elfutils.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# elfutils is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <
http://www.gnu.org/licenses/>.
+
+. $srcdir/test-subr.sh
+
+# The following files were obtaining by compiling funcretval_test.c
+# from this directory as follows:
+#
+# gcc -g funcretval_test.c -o funcretval_test_<YOURARCH>
+#
+# Pass -DFLOAT128 if the given arch supports __float128.
+
+testfiles funcretval_test_aarch64
+
+# funcretval_test_aarch64 was built with additional flag:
+# -DAARCH64_BUG_1032854
+# hence no fun_vec_double_8.
+testrun_compare ${abs_top_builddir}/tests/funcretval \
+ -e funcretval_test_aarch64 <<\EOF
+() fun_char: return value location: {0x50, 0}
+() fun_short: return value location: {0x50, 0}
+() fun_int: return value location: {0x50, 0}
+() fun_ptr: return value location: {0x50, 0}
+() fun_iptr: return value location: {0x50, 0}
+() fun_long: return value location: {0x50, 0}
+() fun_int128: return value location: {0x50, 0} {0x93, 0x8} {0x51, 0} {0x93, 0x8}
+() fun_large_struct1: return value location: {0x70, 0}
+() fun_large_struct2: return value location: {0x70, 0}
+() fun_float: return value location: {0x90, 0x40}
+() fun_float_complex: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4}
+() fun_double: return value location: {0x90, 0x40}
+() fun_double_complex: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_long_double: return value location: {0x90, 0x40}
+() fun_long_double_complex: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_vec_char_8: return value location: {0x90, 0x40}
+() fun_vec_short_8: return value location: {0x90, 0x40}
+() fun_vec_int_8: return value location: {0x90, 0x40}
+() fun_vec_long_8: return value location: {0x90, 0x40}
+() fun_vec_float_8: return value location: {0x90, 0x40}
+() fun_vec_char_16: return value location: {0x90, 0x40}
+() fun_vec_short_16: return value location: {0x90, 0x40}
+() fun_vec_int_16: return value location: {0x90, 0x40}
+() fun_vec_long_16: return value location: {0x90, 0x40}
+() fun_vec_int128_16: return value location: {0x90, 0x40}
+() fun_vec_float_16: return value location: {0x90, 0x40}
+() fun_vec_double_16: return value location: {0x90, 0x40}
+() fun_hfa1_float: return value location: {0x90, 0x40}
+() fun_hfa1_double: return value location: {0x90, 0x40}
+() fun_hfa1_long_double: return value location: {0x90, 0x40}
+() fun_hfa1_float_a: return value location: {0x90, 0x40}
+() fun_hfa1_double_a: return value location: {0x90, 0x40}
+() fun_hfa1_long_double_a: return value location: {0x90, 0x40}
+() fun_hfa2_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4}
+() fun_hfa2_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8}
+() fun_hfa2_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hfa2_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4}
+() fun_hfa2_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8}
+() fun_hfa2_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hfa3_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4} {0x90, 0x42} {0x93, 0x4}
+() fun_hfa3_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hfa3_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hfa3_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4} {0x90, 0x42} {0x93, 0x4}
+() fun_hfa3_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hfa3_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hfa4_float: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4} {0x90, 0x42} {0x93, 0x4} {0x90, 0x43} {0x93, 0x4}
+() fun_hfa4_double: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hfa4_long_double: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hfa4_float_a: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41} {0x93,
0x4} {0x90, 0x42} {0x93, 0x4} {0x90, 0x43} {0x93, 0x4}
+() fun_hfa4_double_a: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41} {0x93,
0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hfa4_long_double_a: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_nfa5_float: return value location: {0x70, 0}
+() fun_nfa5_double: return value location: {0x70, 0}
+() fun_nfa5_long_double: return value location: {0x70, 0}
+() fun_nfa5_float_a: return value location: {0x70, 0}
+() fun_nfa5_double_a: return value location: {0x70, 0}
+() fun_nfa5_long_double_a: return value location: {0x70, 0}
+() fun_hva1_vec_char_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_short_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_int_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_long_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_float_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_double_8: return value location: {0x90, 0x40}
+() fun_hva1_vec_char_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_short_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_int_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_long_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_int128_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_float_16_t: return value location: {0x90, 0x40}
+() fun_hva1_vec_double_16_t: return value location: {0x90, 0x40}
+() fun_hva2_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() fun_hva2_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hva2_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hva2_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hva2_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hva2_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10}
+() fun_hva2_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10}
+() fun_hva2_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10}
+() fun_hva3_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_hva3_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva3_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_hva4_vec_char_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_short_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_int_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_long_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_float_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_double_8: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8} {0x90, 0x43} {0x93, 0x8}
+() fun_hva4_vec_char_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_short_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_int_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_long_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_int128_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_float_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_hva4_vec_double_16_t: return value location: {0x90, 0x40} {0x93, 0x10} {0x90,
0x41} {0x93, 0x10} {0x90, 0x42} {0x93, 0x10} {0x90, 0x43} {0x93, 0x10}
+() fun_mixed_hfa3_cff: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41}
{0x93, 0x4} {0x90, 0x42} {0x93, 0x4}
+() fun_mixed_hfa3_cdd: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_mixed_hfa3_cldld: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_mixed_hfa3_fcf: return value location: {0x90, 0x40} {0x93, 0x4} {0x90, 0x41}
{0x93, 0x4} {0x90, 0x42} {0x93, 0x4}
+() fun_mixed_hfa3_dcd: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8} {0x90, 0x42} {0x93, 0x8}
+() fun_mixed_hfa3_ldcld: return value location: {0x90, 0x40} {0x93, 0x10} {0x90, 0x41}
{0x93, 0x10} {0x90, 0x42} {0x93, 0x10}
+() fun_mixed_hfa2_fltsht_t: return value location: {0x90, 0x40} {0x93, 0x8} {0x90, 0x41}
{0x93, 0x8}
+() main: return value location: {0x50, 0}
+EOF
+
+exit 0
diff --git a/tests/run-readelf-mixed-corenote.sh b/tests/run-readelf-mixed-corenote.sh
index 9a43809..c176e28 100755
--- a/tests/run-readelf-mixed-corenote.sh
+++ b/tests/run-readelf-mixed-corenote.sh
@@ -285,4 +285,144 @@ Note segment of 1476 bytes at offset 0x430:
3e001ba000-3e001bc000 001ba000 8192 /usr/lib64/libc-2.17.so
EOF
+# To reproduce this core dump, do this on an aarch64 machine:
+# $ gcc -x c <(echo 'int main () { return *(int *)0x12345678; }')
+# $ ./a.out
+testfiles testfile_aarch64_core
+testrun_compare ${abs_top_builddir}/src/readelf -n testfile_aarch64_core <<\EOF
+
+Note segment of 2512 bytes at offset 0x270:
+ Owner Data size Type
+ CORE 392 PRSTATUS
+ info.si_signo: 11, info.si_code: 0, info.si_errno: 0, cursig: 11
+ sigpend: <>
+ sighold: <>
+ pid: 16547, ppid: 3822, pgrp: 16547, sid: 3822
+ utime: 0.010000, stime: 0.000000, cutime: 0.000000, cstime: 0.000000
+ pc: 0x0000000000400548, pstate: 0x0000000060000000, fpvalid: 1
+ x0: 305419896 x1: 548685596648
+ x2: 548685596664 x3: 4195648
+ x4: 0 x5: 548536191688
+ x6: 0 x7: -6341196323062964528
+ x8: 135 x9: 4294967295
+ x10: 4195026 x11: 184256
+ x12: 144 x13: 15
+ x14: 548536635328 x15: 0
+ x16: 548534815304 x17: 4262024
+ x18: 548685596000 x19: 0
+ x20: 0 x21: 4195296
+ x22: 0 x23: 0
+ x24: 0 x25: 0
+ x26: 0 x27: 0
+ x28: 0 x29: 548685596320
+ x30: 548534815544 sp: 0x0000007fc035c6a0
+ CORE 136 PRPSINFO
+ state: 0, sname: R, zomb: 0, nice: 0, flag: 0x0000000000400400
+ uid: 0, gid: 0, pid: 16547, ppid: 3822, pgrp: 16547, sid: 3822
+ fname: a.out, psargs: ./a.out
+ CORE 128 SIGINFO
+ si_signo: 11, si_errno: 0, si_code: 1
+ fault address: 0x12345678
+ CORE 304 AUXV
+ SYSINFO_EHDR: 0x7fb7500000
+ HWCAP: 0x3
+ PAGESZ: 65536
+ CLKTCK: 100
+ PHDR: 0x400040
+ PHENT: 56
+ PHNUM: 7
+ BASE: 0x7fb7520000
+ FLAGS: 0
+ ENTRY: 0x4003e0
+ UID: 0
+ EUID: 0
+ GID: 0
+ EGID: 0
+ SECURE: 0
+ RANDOM: 0x7fc035c9e8
+ EXECFN: 0x7fc035fff0
+ PLATFORM: 0x7fc035c9f8
+ NULL
+ CORE 306 FILE
+ 6 files:
+ 00400000-00410000 00000000 65536 /root/elfutils/build/a.out
+ 00410000-00420000 00000000 65536 /root/elfutils/build/a.out
+ 7fb7370000-7fb74d0000 00000000 1441792 /usr/lib64/libc-2.17.so
+ 7fb74d0000-7fb74f0000 00150000 131072 /usr/lib64/libc-2.17.so
+ 7fb7520000-7fb7540000 00000000 131072 /usr/lib64/ld-2.17.so
+ 7fb7540000-7fb7550000 00010000 65536 /usr/lib64/ld-2.17.so
+ CORE 528 FPREGSET
+ fpsr: 0x00000000, fpcr: 0x00000000
+ v0: 0x00000000000af54b000000000000fe02
+ v1: 0x00000000000000000000000000000000
+ v2: 0x00000000000000000000000000000000
+ v3: 0x00000000000000000000000000000000
+ v4: 0x00000000000000000000000000000000
+ v5: 0x00000000000000000000000000000000
+ v6: 0x00000000000000000000000000000000
+ v7: 0x00000000000000000000000000000000
+ v8: 0x00000000000000000000000000000000
+ v9: 0x00000000000000000000000000000000
+ v10: 0x00000000000000000000000000000000
+ v11: 0x00000000000000000000000000000000
+ v12: 0x00000000000000000000000000000000
+ v13: 0x00000000000000000000000000000000
+ v14: 0x00000000000000000000000000000000
+ v15: 0x00000000000000000000000000000000
+ v16: 0x00000000000000000000000000000000
+ v17: 0x00000000000000000000000000000000
+ v18: 0x00000000000000000000000000000000
+ v19: 0x00000000000000000000000000000000
+ v20: 0x00000000000000000000000000000000
+ v21: 0x00000000000000000000000000000000
+ v22: 0x00000000000000000000000000000000
+ v23: 0x00000000000000000000000000000000
+ v24: 0x00000000000000000000000000000000
+ v25: 0x00000000000000000000000000000000
+ v26: 0x00000000000000000000000000000000
+ v27: 0x00000000000000000000000000000000
+ v28: 0x00000000000000000000000000000000
+ v29: 0x00000000000000000000000000000000
+ v30: 0x00000000000000000000000000000000
+ v31: 0x00000000000000000000000000000000
+ LINUX 8 ARM_TLS
+ tls: 0x0000007fb73606f0
+ LINUX 264 ARM_HW_BREAK
+ dbg_info: 0x00000610
+ DBGBVR0_EL1: 0x0000000000000000, DBGBCR0_EL1: 0x00000000
+ DBGBVR1_EL1: 0x0000000000000000, DBGBCR1_EL1: 0x00000000
+ DBGBVR2_EL1: 0x0000000000000000, DBGBCR2_EL1: 0x00000000
+ DBGBVR3_EL1: 0x0000000000000000, DBGBCR3_EL1: 0x00000000
+ DBGBVR4_EL1: 0x0000000000000000, DBGBCR4_EL1: 0x00000000
+ DBGBVR5_EL1: 0x0000000000000000, DBGBCR5_EL1: 0x00000000
+ DBGBVR6_EL1: 0x0000000000000000, DBGBCR6_EL1: 0x00000000
+ DBGBVR7_EL1: 0x0000000000000000, DBGBCR7_EL1: 0x00000000
+ DBGBVR8_EL1: 0x0000000000000000, DBGBCR8_EL1: 0x00000000
+ DBGBVR9_EL1: 0x0000000000000000, DBGBCR9_EL1: 0x00000000
+ DBGBVR10_EL1: 0x0000000000000000, DBGBCR10_EL1: 0x00000000
+ DBGBVR11_EL1: 0x0000000000000000, DBGBCR11_EL1: 0x00000000
+ DBGBVR12_EL1: 0x0000000000000000, DBGBCR12_EL1: 0x00000000
+ DBGBVR13_EL1: 0x0000000000000000, DBGBCR13_EL1: 0x00000000
+ DBGBVR14_EL1: 0x0000000000000000, DBGBCR14_EL1: 0x00000000
+ DBGBVR15_EL1: 0x0000000000000000, DBGBCR15_EL1: 0x00000000
+ LINUX 264 ARM_HW_WATCH
+ dbg_info: 0x00000610
+ DBGWVR0_EL1: 0x0000000000000000, DBGWCR0_EL1: 0x00000000
+ DBGWVR1_EL1: 0x0000000000000000, DBGWCR1_EL1: 0x00000000
+ DBGWVR2_EL1: 0x0000000000000000, DBGWCR2_EL1: 0x00000000
+ DBGWVR3_EL1: 0x0000000000000000, DBGWCR3_EL1: 0x00000000
+ DBGWVR4_EL1: 0x0000000000000000, DBGWCR4_EL1: 0x00000000
+ DBGWVR5_EL1: 0x0000000000000000, DBGWCR5_EL1: 0x00000000
+ DBGWVR6_EL1: 0x0000000000000000, DBGWCR6_EL1: 0x00000000
+ DBGWVR7_EL1: 0x0000000000000000, DBGWCR7_EL1: 0x00000000
+ DBGWVR8_EL1: 0x0000000000000000, DBGWCR8_EL1: 0x00000000
+ DBGWVR9_EL1: 0x0000000000000000, DBGWCR9_EL1: 0x00000000
+ DBGWVR10_EL1: 0x0000000000000000, DBGWCR10_EL1: 0x00000000
+ DBGWVR11_EL1: 0x0000000000000000, DBGWCR11_EL1: 0x00000000
+ DBGWVR12_EL1: 0x0000000000000000, DBGWCR12_EL1: 0x00000000
+ DBGWVR13_EL1: 0x0000000000000000, DBGWCR13_EL1: 0x00000000
+ DBGWVR14_EL1: 0x0000000000000000, DBGWCR14_EL1: 0x00000000
+ DBGWVR15_EL1: 0x0000000000000000, DBGWCR15_EL1: 0x00000000
+EOF
+
exit 0
diff --git a/tests/run-strip-reloc.sh b/tests/run-strip-reloc.sh
index 221eefb..a3245fd 100755
--- a/tests/run-strip-reloc.sh
+++ b/tests/run-strip-reloc.sh
@@ -1,5 +1,5 @@
#! /bin/sh
-# Copyright (C) 2011 Red Hat, Inc.
+# Copyright (C) 2011, 2013 Red Hat, Inc.
# This file is part of elfutils.
#
# This file is free software; you can redistribute it and/or modify
@@ -17,7 +17,8 @@
. $srcdir/test-subr.sh
-testfiles hello_i386.ko hello_x86_64.ko hello_ppc64.ko hello_s390.ko
+testfiles hello_i386.ko hello_x86_64.ko hello_ppc64.ko hello_s390.ko \
+ hello_aarch64.ko
tempfiles readelf.out readelf.out1 readelf.out2
tempfiles out.stripped1 out.debug1 out.stripped2 out.debug2
@@ -100,6 +101,7 @@ runtest hello_i386.ko 1
runtest hello_x86_64.ko 1
runtest hello_ppc64.ko 1
runtest hello_s390.ko 1
+runtest hello_aarch64.ko 1
# self test, shouldn't impact non-ET_REL files at all.
runtest ${abs_top_builddir}/src/strip 0
diff --git a/tests/testfile_aarch64_core.bz2 b/tests/testfile_aarch64_core.bz2
new file mode 100644
index 0000000000000000000000000000000000000000..9d56268843b77dfa5cab57dbeb2746ba881d78e7
GIT binary patch
literal 61748
zcmV(`K-0fMT4*^jL0KkKSwhqbIRN-nfB*mg|NsC0|NsC0|NsC0|NsC0|NsC0|NsC0
z|NsC0|Nr3O9~q+_puBVe(7+y)^}%y^KnjTK+k@vG?b@r})vtHBGuz$J00lB0-P^g)
zJKlzQr?wsTGU>d{Q$}ouyMl8XFJL!kUk9W++})W*l}ZAh5xuXl9Z;_VA3)Jv_iW&9
z0jL1FH*JtCzyr20J6{FN002FA)eXGk?*JVFbsHZ$F3a4<KsTHW_g4GcBKe>`pM2gg
zdB*@gfDC%T4yd3XS9co@aCZ6uOnDywpaZve+_jqR-Jaard)Rq*yWaY_gD%W>zH_?E
zc<esUcidv4ZK=EOmxt8zBd91ZyT>9UduO)#!25fLKHKg0*jqfawoATmA93%IzH8oX
z_j9iE>*K|(+047|cfFbgYpsjt*PlDvcg^pxm&gY9)%Ew>`|U5auxe&&UvQ@9YwNUg
zw)Jk<IwfVjN;ixEcRcQH`-bK(qbFmIcWpO5?RP=;>(5f_Zri5%QQqG2di&p0>GtET
zfmQT6YVUVK-QJg+<f&CXvTeNj2c8GI_j9w+S~a8NJG<VsW;&yTJL%_x-Rp6^*wcOX
z-E8&eTLAh11Mb}?*K+}7_ssjv+m5FA2S5Nh_uHOb-&z&9x6IxKX`?`)IySbxuH)|V
ztJXDPCH8jS=I<Ur>!O(kv~@P*!5y^@s@;0b01g4rJ+rn7_fT(Rh{f%Xz5&oUYH0!i
zG|&J5m;eG`353&3Oqu{PWB>pf8UQo~fB*mhXaEH~011S^00LkJfCDNG2tWY<1j&;?
z00961002xz0%0^VG#X3*1YnpZO&CUsdqY5*NZM&KG-T6L#3s`e+D}S0X_X(PJep6`
z%_->yngkFaKtM*C8X5qPQGqaupXe$18lICWKTkoal-o$jnwd1!KSqr-r{Sue45{pm
zQTi$3k4XJZFw%OSsp+O9^C3?)OnRewjXg#P)csAQ+NY9wWZF}0C?wKJ1PP!NW`GS7
zA%aY)`e3R0Fqtp{Vi-)CNw=z-(w<2DQ$17Ak0I)xq=&SV)Y?s`+Jh&N=|Qrdrkhct
z$~Ke5Gbjd`83sL20gw!OkVKLsG?<Az)M<>A^GT)?OjFZLg#A;}Pt=>#(*tT~O)!}>
z^-buSOw|2T%4v}G2kIx34LqlsO(PzpXg#QDsBII}+L=8~Jx8guC#dxes5E*^fweG<
zfY1pNApn3TMng>+G6sMFFicDY$jHJO0ic>@ngV3PX{LrvFoucbDdvnqVK5U4p2_NI
zHjI>h6w@b^+G(hsglz^C@g7wDh*UAL^Lv1;NApn=r^Vk$nL6;M<a<lN#B>x@SQ3U*
z$jC3m+hiBAD;at!EL4|gO`DUh*uk_qxisM1q@-;&Hpd<8q?>4Ly5+t$)353-^0WFZ
z4DqWdF@}2!RKPXG!VD7Wh?lAcOzC{zPw~3oaq_`<byN2RMM5b1YF;m$;s1vd*7Ibf
z^dCv~H79-jPsm@Icgut=|9-FJdW2c@yCrga#)MF}SrJB{pJA~8g2heUDxvTCz6UnJ
zt7HAq?;r(ejAOiWTL#_Ha%>Sn^}QzW#Wa3}n~&N4<=c2*#L?0i(zW_()JQ*uy}|z9
zadRM<_$0z_0%knxlqg425w_*bSPKHHa|ng~5iTvrF>acPtC$toLJ?{Nbtqrt<6>eJ
z{neoL_I<eULEbleI^$PUYqTi2rvp%AN8QhxCbtq!xzY}U8ojvLNo&|m1pONx$<PI^
zl23iqOM_d4tiOTAiCG}yap%pxzNDMDUXlP)U{2WsVL3yu)!<HZrc!DEz`4|OY>1zM
z&7vY|6*j2ldvdx8=UoDA4*m#YZk#&w*|0&Ib8puQN`{zXi6D_#3We+0HbvyV(o$R~
zFf%q^D>Wj~b>^VHV4Fy6NE=BFh>EHNRUoLyvMd!yi3K9aps^T1NU9K77?LRkkpux5
zBFKuuBO=JGKv@Mu7=j9dAjT{NRD!`#1%iUA$Sj>rsSn*~l0#gxotLTA!{&Ak;F3bK
zRTpL|A38e*7Ap$WKE<h7pJ8}RNX<iZTd;rt0Y+8d=M7p_Fu0{Bc<8f|)D3)`hPHIe
zmNLNdamO9GT>_;x3D5ye1=;RETvpdX%IYkb+c^oShZX2!h}u>%4daxq(ha>?qzc;|
zhkA6}C^4q9g(;!n@^=^%Bz^)9Ipy%$ma(-8q)_hdwxGG_(Th<s%X9$~Ptgqu3S8JX
zQq-mdPaH5D*Aj9LENcC376}pzaxf&ap$;{zEWHY=m8qwC`37<gT}2eDlEJp)X-Ij^
zL*Oso>Tk04&rNz`Uv~;%=CZ(bN8y$gR}sU;L;L9W#8v9JL9%-lo(ZT|m-TbkbpZuv
z;+4U|+DxgHr4h+zT)oG_^>&ePw!~ikw7i^wY7tDKLaanJR=v8*%FTx`KKa7{NH(E(
ztD~VhbSCd!*Lw?U;?a=Q@U+<9#K!gI*5TmL|5&gWA}F5cu-klAPqE}Qd6n$gTrtdo
zP%&mKMwe$GM+}H4rW#;pG-bt_1f8@=jt@ssXXWqCIDLoHwRPv)R=!$SVb$#SxF#{_
z)vmTGXKmVQ)EoNMb~tHit<JSOSzQg^b9r~~9MoSf*Nv+ckp`;fv@(*jXR9pKyHP{Y
z<e2tK?6#|#8YKB8%h{u-PSqdm!|`@XGK$$5@mPq4V+jmZ!;;FmI+#~nWz}SumUwlf
z2Q3J!2@tHx?B;=BKqNx3FrrmYl;Qe`l|ths8M4%;Tzu_u*8gQaKPFZf;c978C|ryU
zaq3O!9lN16DT8>yvJ*QFt+3^mlSiJ%BbwVTG*Qgi!X`afd@L~Cu~eQDHBgKO=|5&V
z)7I>is>4U2L`^>r)aE?po}XIECq4CQTull6o{Mz_TpclxKBiSK@rKcMsgmevNPFZl
zb{m8H`dy=r&}b*JyY?aXEKB&Ycq_7}9m8Y*?>bs^D?M%X%o!}0FxYrsFr};Uu1#&{
zhP4nFmiNl-=k7l~CtorjBVj`hgY{eQz6A}gs49UJMnQ}6KlJ>S;2mC{Xny_xKwTe$
z-$~Aw_MJUoGe1H=to6#YT5{_-v>T}al);!0^B>K^-1KWnGXc)F2u#d$nJn?kq4zzU
z=*(feow#^=vlB8x3KYBl7LT82gdm_yE9gTx3>uzKiS+nS5wsl}_ml#R1{igGCI#&e
za>e+@QX1G#nDotNDCT1P1&$X7WxYOki#^KDxy2sF(tBjd+6d3e@1E?6P+9_nZ@JY$
z8Bg{&^ZH!_A2hIqbd`|91_D*hd$lZU``q3pxB9dEef3>Qmus1ZCTtk}v$=&+G6}bp
z|Ajq`FBb9>m^0;Y9&E9A(-^#36OHe|sDs&u5|6|8?N2zPa{^h%uFP<K_9RZ-E6u5i
zw`s<*PZflgX5q7Ducxc}b{^4O_Vj`gM0Y9Fkwh*&l~zqR#Ty4>vWm2mfU+X+mLG1r
zl2{sFX`6Pm&u>L8$2%8Y`YE~b;Yl<N#mr`iQ+0>vAnlgDNR<i(zTx|?+lj<rM=go)
zW9lJp+7|uP?=`9~dK7T{n<0x=Cq6z058t&=OQL8K-@v*i3pMNB$SIxNdNUE{^C2C5
z=bG~9pyXrNYBrS$cJ4~ve+_qz1l%CH2Uqmd6iMk@AqD?~?GE9wH%SBma5{O~e23;8
z5C@`-VvHIq)U-OZt3M3`I`LbH!~;WcR>fv6tQ@(pX?Tiw1)dr;)=SA<b4awXR%#PR
zy9RiQIEqYB-jO6TP!(Yzg1)bK08$h73Iy@!sE^-$cVU;gJ&~-k$8X}#-qL9Becz1r
zi0vQR;gl<_%P*H@MfOX1QIy*S!XxhWV|sQz6|HSDx3+5n*!dN=^m)Dz1N>IDcPYj5
zCs%HHhJ323lA?+*wwFhmr_Yje&bwS>^)oTrgpQm^I<~E}D1xQ6>fICOLh(-0#4I27
z&Hcf_n2}7urpU|T<x(*~V-DVp-E-qQW*K>Nzm(Yq`AL~1bcB(0h*Oa45N{(Hzp*O@
zjLQ1r7TY5f8XQuWA9)^-)Qb_(x{r%)PFU6ik=TxRgvvBOgAYgZ`Mn7BkQF(j#^>=9
zT=#wj*}sV0_UMZ8CPRfTtseuJrsing-OX6rW4SC@#?^Y8@W}C{5g&O=#V8<(b*{;g
zWv2YQQkkwwXf=ArR8)9HthMhgw5>+9wx~AHNhFX#1cfR}wkr5T)^K)Q4J$D;LKMu+
zT~x^vH58znXjv@+5KtI^;za`rJ4rJE(oy0B0U}al2LXVV0z=L+Au9<MF=-XoM1ca6
zA`nnOyaxh+JC_p^AVdJ@^e_U_DB^<d^%SV31!x88l}b{HN+6=hBtkkYw8R5SL<m6i
zK}t!P5RDL!kunkl2&~#fiKu~CNQA6O7NSutT8dQF0TSxr!a6unN;*(NQf44PpoEA5
zAVedjA|W6NkdPom2w0^kwWQPrcA&9kX``bQCMZ=LqP5vbYLyuaiz;6?YpN*))k!sG
zMgpWR4T_~Qd_fMXX7hg<UUcNiPR*RTyEaE9ofeGgr5L9MDMBd>7*PB6_=YVECj{2P
z$S7>;C|nREg(jumm<n~=;jCTAW!4%I?Aj*;rl_H83r(p~ED>TVXr~=gZ0snCuudEG
zts%abs9Gqv)@s)acip+dS`}<rl{FTo0?z6~g$q|iTT!ZJ5m2QVfX!v16m5zEiMvtJ
zc7p5_KqAt+r%vZC5uWWSzg|YAOF@}%dm7${bns;33;`+)+D%sm$h0dA27BhQy5yp&
z<|`WVRLhKO$FZ{=h}Y{yfd<psdc69sn%f*Ysk!;o{YA6rZ-(`V5fCC53IM~G>fw3Z
z?r|%rz(i=QO`uzyMp`Lxo`zDxK+4!LUXSmRKi<T%tSbLpA1SZC!}?i!ldC~`C#43t
zCyu)_sby56(&)YsO|hnw{-@#kZHEXIq_1=xloSjF+w&~Oa6Xr-?~b<a2I;<}R>Sb#
zyCx>2o|2s2n{KA04a7~h{GOcvZ7t!rx@3qVnIE-b0Edi|LnM7CPnoH`*tQWKfe#OL
z39y`pKKvAptf?Pc(~@S3Eo^};yIE#609Y)E)6J=jU>)lu^z0<zs{rxsi6Df4S_0(3
z7SI7?03FOxK?|U`(5MDP7NV+&emfTuDNK-1;&EmcCqM2<bg!XaGnO?<$SeZrc()<N
za-bF)5=L!-S)dRhV=}d=s@N1r#iCTqu{jo@b#}?i$SVS@)9EAm7$gWJ6guxFAgw(d
zy{p|joo4K<Thfb300;tXsKhes6qaQs>q!Y>lm7+j`U@VJQ4!>i2W>0}pb-7{&E58^
z@^;+t)u!#!OideG(i$sn70gXl@nO`2Q&2=hi_`B;awEnlMy-G#p&4c6qv2Sxz8q0N
z#l0pQ@hJ7aP6Wh~Mo0jNs0kHOU{0bQe=Q^kK+*qg04{>I&7n3C6t+HIU9}hKuaf1m
z0xW~xeCivT>I~ads>+*pmqXxoZ}I*OJY*p`BRYrz&}CL@YT3^4wuEd&WEEs&ByZeU
z{Z>xjd+&Y^H)D6w{*?%F`Im`&T=#A-ZQC;{;x?ipC3>EeALn&+bQ*JeiszM%>tWX*
zymcLa_r2!8{iZ;Pf9hZmN`+Ac`^H8i${}~L(a1aY_YeB#uGY8SyAL!=mEVZor6%9f
z%Du!p{_j>pKTVWDUujCoBJ@+O`d>%0&Dz`!MNpCV`(SOwcB+sz?r7sv%vpJ&thM|i
zJh!X)pSAMgB;`?I0Z(I3?4j91u#{tMMH2njKSx?)-qMf>>)14lF=~ME6-m|4f{+g}
zzrivO!PTUH(R$axJ0xJ59>pM30hO<%XQgeRJoei=9gdT&ZpOT?ACeU^Q;Y^ys)j}%
zQAUsY`z!mUM#nw>nF?(r|Cy|AJb9Ey__f2ts!2dNIJdZZb=*?m2~|Kil&=V07J5X5
zEowXC{I7?Rhi^e%UTHyex&(@{ap>bl-dCAq2L#T`KKJ10l0#-IwFp!JL13W16H!$}
zWKkSwk(QMa6-6-uu|Z_ZPG*9lDhg#PYQmPb<t$8bGE$3(6~^f`nD|=(c8R5M%3G~^
z@44OZ{9C_ulCa>#yhdPZ>sFIZ%HuOIs<q0vQef2FOGLn`(790Qi@RPiyOvX9Ktov8
zUkq0oiZP=8ZH1x1hNBPidkJjmeK=GSMhp@I6@&Hes0FaTBP*`<+F3hJsdl-2cO|$-
z`yBB0{Yok2&@DhK{jah5y}i97RWD~TEvWYS`#o~?`(CqlT-Mb|m^_?1#mfHL$KCJ0
zERXEZLM3hhSLvqGK0k*o54WOUeWr(qkM*6efuTX+a6caRd&K-JYrNcA|G&<!o&Q#W
zheW4Dq5`tE%v+v@B1zF4!ja|>2W^(wK7*-3HBdh>{#k+$gCIymOu4=n??)h$ksj=d
zk-R|NzM;0O{N~i!+A3_SM*w~7MRm>Y`^ouVlOyAH`LHDs2|$372~VSX=~mL1Mtout
z0$=kt*jC!H<yu4HxV+ZBRF6r9KsW8EPyr;O1nUZt2!2QAH}-JPC3MiY9)nd8^~e==
zpWDty@p`plI<gTznZI?FFvm;;49VfnWnL3PkEl;K`d%sjKDc0h+dcmW_%;im>`DYA
z1^d&M-Q4X<i#GFFfU1o|T40U4rKSpCRsI7YxAT9+wgc#Y+^7;tB7TmnKmE`7bb&+@
zsHogiTSnIs%KwS`p1IKxG$YUZ-$dPQ^W)27=b-cj<>@e0Xw8#dIvmABLCg4aN_AFj
zx9o!}mn?`lA)MPwQWr@~K8%5ZOo#|QPcgmsRgLxNZ>{i6dJ2;IRb%=8uRq%DRWJbt
zb|%*U4pgLK`IXS!q{ftb{YdjHpT<!Km?#i;9+$ML+Z~*iCzR^CuP)H#rgbw}HT0^1
z68;4!*IK1vD8&F6Z_^6yxwYU!)(K_#f7g$~$pU~ves^TJlt4Eh>YwnCH1V~6F3t_N
z+sxip0o#4r(Z3MD+G8XL1b?|l(&KVa1}KC2m;8*TwzC%4Spu$5b!I6u@4bb`^c4C8
zab?dS20%$dPyj~0MfA(6&ai-l;0hyxhDO>nQlA6Jkcp811NbZL+Z%9Na1xECO9Q05
zH>}xz9=peJ2tAohiU3Ao)c*fd{8jsXzxZ?DMFg-hDk^GKT<Rg6`;;9*TY%p`*?!OX
zFgAjKAt(@^(fV9}lWtuytCT3Xg$mED_8p6=n?<QDN;mae>2KrT5QvUJC=<V`{?F6%
zynfqWn+_kY`!{aLCT&|urTIG3{dLu!*&k)32kV>-BqRtQ?ERI$WuLW*T)6di0?pxh
zT$+kq>xw7W>0|TPj{~{q<N}y{j>Z+;VI`m#k;F79B>+$QyN{5cW}S!kA^bnPX8adl
zjOW0R7w^978YPA!i>tk+Z|I6zv}|@Ks^%*GGfpS(vfcVn(9XJ7?XPC_q<A31dVYtn
z>LYs>X;sBovhcHT3h=E)`u_1{RXWVC8nbg5v3O(2U$1xcZp^P{W@mSG{RMjD(J#E#
zeIJ_2t%kPYRp#BM7W*8Hw3fkY)+=ZZ@&cO}YoGwgii(^T0~mpLr}IE~O(oMb0i$46
zXwhTnZnar-(UCu##bCPCK9YQhEVWhUsvGUX9K^9*kW7Bt&pjG8A#IVs^svIz$np*}
z({>$Jp|t8=yH?iKIvxD<&1bG!L{-N3Rl3*=A!|!8nW@V1?@p{d#T&c>Jj_<9VjD!<
z*rA~yK|f^*YoH4vt_Tin5Jff+45ME&Q*KU6XBSa2aIYI%z72Zz?6Ts6xj63R-(Wv>
z<MUj4_J&%-61R~B8X0gLvP}}n9t4rL?33{7M@kw`v6)b|DpIB#k{QtnuPUSLpw#yS
zaf+C1(VjdocHW%Mtm9q@7!AC5<2<}+o)~9Md2jF6cP~L<mF<@z8COD$E2?xNuMFx`
zq=HINJrmDU!=AXRP>Ps}oJ^roTse@=uLJa&jw&z8@QvWNq^ULIrX+dEQp2v-Ra{G{
z;s@hZ)AT4*k*98`RGzb|Lh8hkG1zKWt4{6s+7sCLdB<#1okZx@k{Wa-v5-y^nq`UY
zJ0)AG9jPUW=>0ivk{R^gDJn%eC{6kEE774V1lh9!r_ZY3nA20>d8fr0(`Q$exokLA
zAbzl@rA(gamL~-G*7GVh-6~GF>vbwtu>6%~)uSTb6rQ3}Ca$P~by-E)@lBgHIg76~
z$Eo4PP~W;04Cq6|hTarnyOcxEqgAVo8w{s5X;=sg)+!#IhS@%AA?GBAsAS@s(!6!%
z;1a%O>Ku=C$D!QgM$unC07I>cfuo4wi=v20qN-FtsT+84vPt1E@Q~{;+>&l&=3&m0
zm4HLeLIi+fyt}CbOcqER(h6^9HrIM=fesHc?Qz&^B<(T;B<((HC!U^SbNE(Be5|D6
zoT$9_o27QzNKKoy>L#6aEC4BGE}q(Rnrzd&m!KJpz$?6_wT|(NNWmk`PtRbAo$cl1
zuSS&(E5?<c)&iDQTB*E}fJOU2OOO;0gOd}y<YL{CaF5v-!PtnSt7g3ZZ;w2j*OJ1u
zvch2OI(2A&X|u9>6p|eiprOyewY9oIVsWaf_Kj)I*JEu-&9P@3r<6M(4k+^4?sPu2
z2r58HwW!MwR|#cw@d}%qN|cg-6GLk#MCSJ0Z$<jvv3W<eITQ)6Fm*rAfZDary>bPV
zS&$>m4I;9YjEgBqE+4UK^eR&<^8^5VMOo;WBRM3MPOa847OQO=6|GfJ(i+>2{pHw)
ztV6Vu)-X5i!wxTI`Wxz`XPV@0*Kq$Rr{$Cg=H(z!UW$Nrgd%lErXf2Lo97~e+Q?Kk
z*OL<X{McxG&8Z2#P$23`2Dz&ucBBq`s&Y?OQ??-ht+HId8a@%~h>mLMZOk^D9|)LE
z^nv}-5Jbw+(FaKNXKvN!ln61Yu(u2dDy~l+e^#m;6NZ4ywA*3hU&m8K5_I3%l3oA%
zBV_+8@<Zqx%*<Zl5$+QLlOsNm4Mc9grFPX2z?I~koI_d(GN`&X)-7^~>t|JA2a)me
z%UbFqozCZPKJ=&#XkpdLbdOq7pnNijk$RDLa-3fOuJwiJC}`TWRM5<+l>??Os)D5e
z*9NwAD4mf&2}B*f9V<F@WC7q5L0M3CVlf9n36atwCY7S*uT}+3HY%}1=Lo`lMsAKY
zCBtE^#E<m!y6FiHo>x8;?(Sg3V3Pu4n@B<e?7k?L4fLfIpeEKE1&UBwVVbmH2KP?P
zJVWCi^nt)o3msZF8`-h%ofXw|dYGEC?8~e-uIw=U#GIJ$-KB?4`#uW41^XsI_R_An
zsr$&r9itU5UyiUiN*)y@0x3bXf>3anL(M7S6ax&h#HN*ib9ywvfUXn}2?^E~5`Vnp
zZdw(lWw2RIBJJ?lTd@%h!F0)8O3k`1sfmq7wm8vEZ2(O_yQI<Rdl$|_=DQP8H4GC}
z2VP)qwk%ep`bP|wBK4d87j|1npNnHgeed(l_wfC{;CMha-J}r%Ii^`pru+fr5nj$)
zW?WpkFX$sccb}9qh^ajetn@QIPc{V*Omz(9)xx*hndhjMF-HJ(L;$0k=~+600(9Ra
zI$ITzaK}kyc!`-YnKXk2=S&sVBvx`_-LxGO;8U`e)rCy5!@6o#u?I^-MnYwnw*4Y0
z6fD3Fzq(l?xhRMP?V{G$%@wT3C2CWj%4cNbnG4luDtC=Bs`nvR){rlj#`DM5k=~T?
ziUiq-!D!)&>ut*861$yQAiFVSP2Q)_@V)!x8oS}Ijlu-OJhiBF8pzhc+k0c@5TX^;
zRD=RUCk#glZ#D=n<UmCLIAah;BA5kZmB!prg^cqHIfP!sDj*xX^-Gikv>^o=a@Z7Q
z11ub^SfKr`Z5uFY$B1N4B#cJoLF>6{o=E{SI9Zj24!1DbYNNPjUYc}rTnDnJhGU_F
za!L;brJZrbY9U;PaLgJO(`;Dpk(`V6g87Gf^eq?d+al$tw>V09sY+YwrArE>2%w{#
z?9R!F(Z}Ea%ed<&=ke>+IYF4NT*;=TU7#}XuP|>O1Bun~5lHcWX}=`{6c)9AT8IY!
zrGd~xqggIjn4_+WVCVA%DD6%6szqr?gcKkS?1ANtico+$asa0*8?)hpfm~&j!z$53
zkR#nY5{Nq!-g5gUL`-C;HMvt>#~>m`&J0SAAM<YR{N40~`IKlg6hH~D8q_ijfQnQ(
zrgA+=7UptJ^mhn0+uAF39n<KqVW5m&X&J;7`MkVO<q^ZZ_TK=1x({Caxb5jT=5~{n
zPNbexjKlgr5&*Xd^u`E(d4TOX(yR=BkdI*ui)Mh<f^jE94|Z8duY=rjcs}c7zv<uC
zy8l*sP*VO0`I)DZti;Wvx~;b(Vn1O7?JAWjR<z`rurpSLZlBmtosgc0e#q3s6d|u6
zp(Z<{oA=q(U*F)>4-PXEFl$npI5bfd&K(^jCcxp|M)!#ee85{A@yZ#JIZX?bN`(p-
zwG|OQyT?!m)sgPIMF0xpTrk2Vm5LG!V#v?|BHiDq!S;HE9nnEzh?uVdY_rHLGv_Nt
zWrxu7#4RcnsbIh-ttbP%*=V#d^kfRo(pnV~{OxQIO^zhqmavGIEi`3Yke-n4JGU+;
zgrG}S;Ny)WAwdjD%D#)Z6X7r(fx<bje+X9iZjiA<`;rRoIz55I1$7%qCHejAWAyeX
z`z!jrE|cK!JNPTC+4ga-^nc6W^J{)aEju%#HLlB68LfSzGdiu?#F%L(XB!tHpFV`X
zGQC4Y#20vIh-?VX=?3Wi7TDIi7ZG4yOdyZY#Pns=r;VEPWas$kI{4stGn7NDHJ++8
zF0ElSbC87*Pjqkj8~0k%)v{`N(aYxctq_w6!PE~VfI9*Z2=4$Dt?zEznfe;00i`dY
zTyQK=N+3@4%BO%)KFp$Z<tFQeRQDj<VrL!RdZI%aTeVe-7Jxm$2%d=OPyy#kVrXqw
za`>)ng9j!|VmGeiJSTL{6Gw!=vs#OG?Mjp&rjmlx;J#AG2rz1}88x2F=Uw(1ayblv
zFqJ34#q)mP=VV2lW&G&wJ&hERN)b1~w(e8|U3>OUG7x7?SHMDC$SDx)jh90O>^6}#
zBKA<l!KY|~rAa=;(~p$B1NNjD=2~~(X5Yg3%j?o<7;_pjnOgReNZd0rvpJ~D#N{^_
zbT`27X|><anV{dRC`iv}!uGG3;NJy?$_eV)P<>(340Mv*dY@C$OI7H#bwD}A2WC^D
zofsgwL4jN2e;Otq9D}%uMP=y}XDZ5ruqga1*x6Ih5Q6s@Wjftv>r94LqnDzP<_r)M
z4$HG)=>}?n6IM!>IN-TrrKcw#!A%WH==5hmI^C<-kN~N~)}?WGW-gB63x_3?0oEQ5
zN)!aZgh5+pcXe!?q3~|YSK`)YwD|sBp1amND>--i&fRN?&n+9w<jfEWC;%#}o~l{q
zZ4FxYU>2Ez+#YSXcYarC)Uw6waygz6<`d0&ZmGGFNu+EBC40!<b&h6S{=1P*|1nga
z&t|yqV?}L^P}4N+YfOcZV|H|mf}tbM7ci_c!X4Gxl;WLT#@Y&F7HD8-9(lGZ5eGW!
zL?YKOc6zXND&f(gLUn~XL?GYk1waJs9V}l9&OZM?MKe#4hus6Op5AjSbUb=^=9=RW
zxmS(07(kK)1;ZX0u)#yN!*6BfV*2EVnujkf<QQsr_YycBb9v<|Rs*u;{ntvN5eJtc
z5RR2m0KkL-|E)lmK+1)#ppu9wXhJH3;(IQ~7mb6n_Pr-_gcVI80Ra=K>1aVcDYX+(
zWmC92dQ&gI#oqe6#Mb*N6#V?I#>l>=4(4a{MJv$sUU;<>dni~RJq0yCO0!6Yb*O+s
z%oSeeH}Pk2>F-evf+(8Lr%EaH;0|;EUrJ{}M5IHN4;BQM@$I{eeBalXliOrf+eLs&
z^Dq)R4NGMJg^ha|%|^ECK((t(V8AN)d~WOcu0R861wqV!55dl*5OB!sSY*P&hPZ(4
zH1kht=61ALOxP(@LP9NC)^{$d0AoNIcJOZ8HyBWyPy*;M1(AAcK9|wid>yQO%sy2$
z>wbEqIf$|1a^K#k_^6`nNJ%YzvJLADCLmp-6Lc_BX*acVb}f2WR<Fs*nwwy}>wUzM
zn+q%!DT>WI3&uR$P%FoM{=HW(_cIik_FXeP$VKEHmIv$om&e0!?P&x@sp|UZ_BQM7
z*v;yk5(G1CZd5=FD3EnVLz9`Ebz#A^)j765_p_M}>6B@hqe#@SMZxPSe}*Wgq8boP
zj}DMI$e?54r8x0tZ%K@9cNM6Y0vPZFT|8IVLFQl?@I!KQ4cKlW+D0dL%c6>WasNBp
z@Z;^K^Kb_bncBnUGHj@|M;z}7FK<WU`LhCTSJQS<DtMci1ch;kLIBq^M(Bao#LbA`
zHq*g?pGFCh0LIf&iK+WkxMCOTsB}d`i3KvCiH*s+iy%0T`fH#ah9`5tEzV>Ok$f$-
z$g&V5sdD>QNm}t?xdj#xRxFcqJl}R~Oot*AWFy$Xz$odcQurw4Ia(_P`5g6x<s+kL
zg<<CJ=qFf62)kHO++L!49dJ(^WZfeqgSWLZLXO@sXN#j)IcIaH(e&DfZT3{5@t=PF
zuBvW*^~{zF!I+pfq!drvOFXtrPXq02JLXR%nhj4UK{NjcnFmn8V>Fus-7p&#R!Yf|
zQem5Gz$#thxRV(*mcCjV1lFlG%LCoC<fnIafu^J}Dm&~n=UVz2vrO`kK7X$H2fzG2
zXLr%w2Tfxf)v^+ystnX!iKLdV5X!SPzi87{im_+mgAETbo$WGHn^&{qLBa+p=eKiM
zdCZ=6s~ERhyE2*+NQXm9Nkkduk&UA?ch}B}7>f+D`Y^bPYm(Dz-aB{|O>J7xRTPSL
z^5rdHZ;ae`s7g;gKM61)A{fq2U+#Hq)H!L9L!5)UF0<P5%?nxoI4ilVNF-lM6qb{D
z6%@mL79R}aY|^nkJ@%TW)4bhUT$*G*yK-z&LtY&`B+^5}6S|Yh_;x~iq*LHCd*U!T
zP@-c`O5?2<UlXTB+R9w2Gi0ifC|q$oM3bL=hvYI9Bs<0q`y%_>#~WZ)3L`Dq$1If#
z*Kb(0)hE|8zxKrel6q8?gq^0F*(YI!$Q1*EL!Rw{)hex(%wL7q*2;n;(<sD3u&C_V
zd*{7Edq4IpyNW)A59wjz`(LA8!WCw|-|;DZIi>Cx__2CCr=?+pXF>-`e~j+c-R0}j
z>IkX()*ezrdP8OU`y&U-Y2Vlfs6)a<7on1%DPO=&ZnfXyiK5|fR0F3VF+YZ3grHEZ
z3Lj#BiF1F<rP$S(1*ib?dg%xWax$)ZyN^c_f=yJMSQFg|R2L!&4~NKOOyEo_s-pO-
z@{3&dO^LAhTUkE-ftYSqANN<_NOLNqdsegQ-Z-#s0z3DlxIjCCG2&8K0uz`Bg#|&}
zMy9PBD{GOX!&<|^EhNF&f%pj|>Zb-#iYki<q&7(u?+Vi^VNnPCq`{cLT_mFmGRZvz
zlh#L``?jLYOD>Wo=M6(TR)}(eHGR=x=O$ly8{VVpaY|L|15BFC1`G{a#u^;}!&&d8
zpbx;eZLm6uyDrzt)K_J<L++i_D@Is@vUR$Mq1Gx@gHsHS8pBb~r@zrY<71`#-vB}<
zjq?DE8|HV3IV6GSB2?-eENAtG*x7Nurzgt&=<&Dk4KKxCn8BslUsaH7YHW!lM0<C6
zMr~hB?OKf4d^$bl7`fJ;UAs*V?e=IHVefOjKW5+P{|i@f;Qc>U-ud2Xx)A#RgvK#e
zMHEp~P*|d@7AX->Q5Y;13JV2TuoMxJB1r`Zq^VVc#elJ76cmagpa{WWuvr!hBC4nY
zl13mxDFu=Oz(xqj2!fVE5DK4J2zd-ukoL$L*s@_Ci)ef<9mfHSqR5^$vS5OOykXij
z6~-muzhuM}IkLPaOTC=C{3<;UFT<v)A_X3$J&~6cuW0!eZcQOdT9E3YJjn$~G#5=E
zzF?>vQsgq3M{(SL3;tfqFk|NZ_5Hhx2Ib42%jVs!y&eS@w{|;ro1#{-jkR{lr2TK+
zb#hLde%S-1oDdZ4m7?-FD|#95S%)6RedDgDP8h<mhFD@JH8Z$bCcuE~SfVrLK58GZ
z^i0wvpHnHevoE*91LW&4t-DBeetXgT8HuN}#O*T?GJ!UQ^_dK4)U}!T?7oq8vy3iu
z9XrEj=j*p`RdlP{<lyf<Z98s2Usb@P+?Pnck5z|a9~v-paLS=|t>swXt5OXyRJL^5
z=+hQZ|B+~A)_44hU#a_w^hoWpQ%p9#j2YjHM`@>bO<uos4*Ux`gTz9NFB=_C45KtE
z<l>r4iLrNuknM|P^|PrWMWMqkH(nrV!G;zbj;)0skV8~H8?v00Q4%)sJZv?+Y8P81
z5Fw*XWXq}KU0-f^ZQV`doosW*J#9>L+;-!x;2lA4makDd2PCZDr0`QUUFlR~f`(*4
z&Lf<_KJA9g>#DW&H!!(MI8vTA>@_tG(1q}tcMYil^i4S+9A5P#(sXVaWE{+wqTFa`
zE@6%(Q!K1mA<^nQkJIVt^wZ$*pLTuQdDuT;(R!w$>ng8gYNv<0t(s%mDGu{%92TT+
zGRy2pr@eyfG?dg%rY4?91denorowVJjqeR&wHciv2TqEn&348%v0{~#DhI`34G%*l
z;R+R-L85&x7MPq-YOvXbWa^b37(hHDa+KvlY`e=AV+;(me;?>|{jY!E=HqvTqaneZ
zQ;=4T5fT{IN!DN(!ASL?>Tc~?G^+N5o%=JVX>bnpA#P+|zOw_s_U-?T4(QDCe82fO
z{0I&5YQj%~z1L^;kiYxW%lV~_*FUh=82+ike;#JhELz9n;@zg}J0Ko2A?XnCl+rnw
zlfN+Ugu&Y_b809q45H<zs#h}i1kF%Bnn-7aTdLt-+}WpAg3be5nTA^rD0RTHY=9OY
z`Kk&TAxgO_!|^-+qxU{9ciLK}<gLakp~@&B?J<IULDo$(7iv>2(3GB2Cn6Kf+MJtD
znN-ybF<M$;`f{5|?qfW{<{PFH+Lg(v9PR$B+-$h14<44sq1iO)$^nkIvE=tGHGH<_
zj?v^3H}bT%w}(B4B$)EG8w%MC{rXU4D)80b`i%T5c}Dfr*Eg)PZJ~Dbg<%IIWO*bc
z;fBJ#H6QA{fC~BS<btM~Ro<n;Jd8-{Oyy2dV!V_86-C&Sh`;gio`#d+BN3!mXoh4>
zAfHjz7}BY3+-lp4GAZ_3;I5g5xSTEj>+1f*$2}<$G(awlga#K$6nc{a_!$NwiwdbH
z_y*QPXMweg1q@=IxW<W;G0^4EXw=qNa;7*U$hu^aL48-r%$OTlGvPGO8FR?Y%_SKO
z5lM1{-ta!lUf)Ei#+N8wT5#sp9-ofv&~8Iy<y3+zmv&}mO|woKai}Qetj60?6B2b8
zYn-5KqFAKVU}SVS7$=XAG2p_b0|;U?l7U$nHX)4`PRiNyUPS4!mn-kZ6kq496&D_Z
zuyEA?l>tp#xG(WUCMw~*uPGK!w1Mety3aJz!L^*1^G?Sl{XLXTb%uW7pIip))p(*A
z@abtIpETFL*4uV1_q$(F^raRE@Gx-$C6TWFtA*eM*{Z0*gA`Xh4~NjDx2nJ~HQ82k
z^@D$p41|kaR;iN>esU4hfjOzoNfIVzW;khpuC7T@bB1d1DXE_|#?c*B#%AZ)6xLJY
zV7!gI6@G6$a(eIYKnb{_4W$&OrBvIwMr(zh`(Pj(C!$j4(GZS9o{=38IHDgSk%mLe
zaWjaJXQK@LPHWx1-0un3_8Qv^mdIsz8ysofPPeGN*9`UPVFYaL6ev2*rI=m$iOu#W
zS}2MLj1ff@J6XxzZoPFD18#eEMr|_cl`zVPgF=bg1H4eGN;41$V9P@4owN-_NFBc-
z%t2=6RF#TO8J6X#mn6(-`w_(9N@$~2EJlnfdo%;`-+k|H;dslyW*qeoTk?Gk>#+O_
zzBrvw<8--7B7kYfEea$t1FrpY0l6mIQ0WA?xZJhThNCl7T$a}rtRbP?_P1HiJJyAj
zKU(RT6$@%|94S0Kjj%tH@_#Sec=yHqJ^dsWEL2WJAQYA6nPkOIRHZti%a-OUWVG7Y
zmn)RgVyjVZSpq4rz}9s4+UYf6rJGQb2DOz^cMEYip_{IgNNXsv0?{QCs><xjFfU)f
za1X)irO0cV?`~PMv=YnJuTJAYtXKsMg+@WT%6uqHTd!ak)ppmn=tPnOj7E%ncp+4V
z;3tjrTO43KGj9rf%!)z@)G;YV90F{qEQ0{0gK0&9vOOV1EH{oC_RH?02F$Bu%EWJ3
zaxO5-u~+O%!sAzDat+jOATIi-m}OSY!h??2eNilhLW`(oP}+nr?MeyWy~*Fjph@G5
zxL<DnWA>e&4({{uIe7V9LKhBfkY%&QMsU5c^m81no3DavGf<lpHJ}(nbT<a&fllfS
z%Q#QSWc)Agi=0~8oDJuvS1N%=?~#^Q<*ui!qCpCo2)F8Z7o-@vAm|V}&_LhdG(U#T
zl*<6tS#r!r8&a`jlq-ye+h|K|wt{vuatoo)7D(C_F;xXBl{h_S3TfAyppiEFcMUL2
z@V`_NdE%D`ktvnu{JUMB9%4oVif&ZilO-CKf-&f(D46Rgu?v}S%nO!DCZ4=andT>9
z#7j3AqPVB5%EWOh)~psR>NLX1H?UYN;Vo9SRu?WflNrSeO_JP47}`-Ws;zBqTZswS
zWc5R~`FFZuq&WnEzoez@cFf0eN`uC(H+EAYd5TJnq}W1ehTNcoN$>h&h3RqnKZR9e
zt$7_LUvG1#+}zXGuZ<hZWOePcotu3v0?6G*AT64@IF8xXyWanp>5PR8QMLPK?zdAe
zJzfPcB42AZ;kw-sjL!NZa)Ck3D1@E`2!TjX9fh*5@NlD{uF6o^7gm!@y0EFFzAb=g
zXUI=L-Q6&$V-68NddkOrF4aXM$oEQCPRl=r$>*UriO3}9chLRC$()U@CJr^OI3_uk
zLVXd<^z`ElMK^R8o`nr-@4ZdOQ|&Hc#+IdI1r!!66AKB&l3rRJr^S5achKe?^M0x+
zMze})X)3o@24W~G#VxR%x9TL^!0S8(Ckr1rpdNVg2+pwUD}4G)KvP<?7zY&TOBi_>
zwg#MK8p?_YfMX{>Zsc%GxjnnK=XS}trAI2uX;Dch@)Bs;f!`sVrRWBQg)xT)3n5n8
zke}(L%PUY8Q2{|khR8yB9gtwbjGkLrd2A-bSy<W1YbPn-;hiS~u*dqC(9MPwhv;JQ
z+fM~E=@ra{vVLn=`HUywK!NDW00JU!xAxQ^49&^oC0DWF#<aPY9+zL9mT7>B#Ss*(
zK={lje$S|$IGj*l3}U6>^Syp-Yr9Br@-Dh5yDbxEIV=k0D#{$!*dCO<ZngOTx7>PL
zpZtG6BY^&Nv%d=BVaoyqaniw)Th{3Ak6)LEPa_{1;D>KKlc=c|n#wR@voV|QGuAt9
zG(NJwnBpAW6Hs2f;C@nN^{3dc$Er4)!=XP#iMei9Db#fAz1)UM+pwE4;8#8e9l4I<
z>%+gLg@TjrKQjq-u9+r9?nff-mnnDGxc;sBHu8f@sRii62PRR`U3q3-H&%>h<ZrGw
zr4U}A>GEW<)Rvs8%a1viYZ9YQSq?F-J(`LXZ>L%n^}+aDI<E_hodCA&DQ}d}ylz`O
z$`=+LnQ|dMa^GlO#*}K!7?R-AYW1oyG=WN{6@is_@N+p=_|>yEaV%E12sO<KBnUQ5
zQZW$L+{tp5VME({(K9~so408ard4cht|3?>1&h)48(mcbI%Xj&wjg*Lnyyd+%FOI;
z%He>})3PeNmOn?)8}azM;ckj_q7^Erbotxw?%fEo?|)VG>eiEt)TcGQ^63=pcRDha
zim&)eNguO*J9}vG$)$k!{JI?V|AjHH_x&Eu3q!tl^LX=Xr<(us=LYX^MJ!F~cF7$J
ztm{ovL~S-x&N8soPXV`oJw!u6V<1PhXDq=2Bu|)gJ(|o%A~BT__GbtJ0Z|wc07Qv{
zrsEcOYgE(ba62Jn_3w7bwQ~4BUNba1e;K2@g!th$Jck*wHO}hsbGknL`VV`)E#JD2
zZGdz`GnzUGotMP>m=wF{!s3;Sf_hf0-hr7VGx1?H@S5JWCjFdv+a)qk#wMY}K|Np5
z)z<2EJDr{7j~-u=0nHzN;%t}SOWpbnZT)r)FQp%tCQ|3G_~;JDWN4Fq=CpL9rBa;f
zV-gUp_xIhF{&Um(j#YX4zC}YI$M?v&l>UWiuK>joEACL~du>`raJvJ<!nWX|r=3*=
z!}8e*==yLW?>eb8Q6XR;4Ff^~&>~k0Wwt$E(_0^^-P`~fh!3+>`@5>#UFThTdR{+M
zpIx!b)}wj5T|XX{YJ;yEbk%hq_d6R*oK4<q{H>4hx#hqwsd9e5e#MUi(VF6L76G_n
z!Tw)8w`v%k|Ks7$OT*2({y(1@&lm6X@zU9HYSHWS7vVi#f2UIqmBHU{U&lVqx4)9?
z{j;Ox+V*^Y{&Mtq&x&>K-oJl_pZm+{tM_R0o?kv^_v`Zie%_D2^9fVy_3XX7?A<rJ
z<)r%Rz2MzK0@Of%>}kL<1Y}De_3ZbzU(eskm(zi~`hLH^z5d7dS;qbF|MULyiT$kO
ze|UAA51DamE_lFd8Y!*&)l!_RM8ED`gHr%w17dnP2^$9pf3?eBoBnZa&#Yi$T-viA
zE34BwhB3G4xi+E<00QRA_@ute8-|5xU(v^5n^`$cXP7ANx54LEF2ik)e`vtymL}LC
zGOr!zRrZuVS?z5D4y@<RU|X&sx{t>pcpn&92d~hRvOq?L7WF%>&xyrG_44u8k`I!4
zlr!4-Y^r90|D`9~6Y61_+Tm~f`xIp7%2Q_4$#}CbcyjJ^VKg$b9{xl+DZ~p7*t)tU
zeU<xP{hp6yB+(@2H`e^OtZiw9;69QZHwn*E$Z&F+&$>BTWLNYUDjwaW!@IL{*ULW}
zU9RSnw%jlgHOkwaiiU1qPWwHb$0}-SHGdI@4igObD}<`6HQH%QTYDSRokZLF)|JtP
z>WYTs>aoK08vT5Fv{?Cq2Ge+o4#wJoA%2p!X^wY0Ha?H~b(-pG?4|An?gBmylNd2H
z7EeZBoZM+Kl&T6?_T3KPK{Lo!I@cg26+i898D-(wu0SPv+)!z)GpS6O!F}qzo2^L2
zG*h{`;iLB08S2||`e*k0R7|%v$z;b`8*COj{o*z^9wKqAS8fe@-hja0>EVUGjvleD
zRfY!3%&_8jYUq@0yMNmLM-xtnZf(gj(!kp8vHM$OMawYVEo)f=f0JK8q*djgB>$43
zo?o|X8K$}T+tW2egsl|)nN|Y5OPY^$c+0%uB3c$&Y%HuwIbZLVYc>kB&?Q~msFD#c
zml^w0lfu{B9D}^Wt9ADXozk^Oe1)Xvwzfptax{<kCdZ(avgHegqZj^Yn*zXKKpP!R
zoxGt>h58_6M5w>^4J^>iCII7IrE}<;U2@tjXQfOAVliN#X1!?`7zBtfvXm1Y3izP7
zD##K^mKzl4uVv$ypnX~gKc`gkt=qTe`!cAC`lI-MET91aBT`T6-+BeNk2a6{U=*~%
z0RS{a-+#FlCi`{N<>S?uu>)C*N6zAZ*R_RfM9mlKsq=m(*9iyakYGQpgv0^^Qo})!
zpvZDmp?a+WjyjM_zp)_u+5fF!RM=zQX)Z$O7;ng%YhByHRT}-|r|16HRiE*`g&-Df
zJRX5)pj;*e*w*%{&LkAEBmcjjxci8rfmX$m)&LG#Cl()i?{sz(pdk43&G@{#5U`tb
zpvlQoM&IRh1LTn6<!V6c`0$1Qj0oRz%y!&>E|_PrZ2rFE>-b;E$?>oLo#3C_mySE3
z8mcMdRVqK-K%o=5DdJBVq`axZuzgY$rnlM*oh0|akFnlNJSGamN#McoVgeYE;xwn$
zX=Q#sX%HceungVt@_PKO$K|V1G$OhfccWf~)D7;ck+XjIKLi?6<K1;p9yRRci}-AO
zzaEB<0INnu6r^afC-c6w9_$<L1jDg!vR-qryZ!I9`jq3%ml&?Zj-SLjJq>)l%)e=I
zVgT23(e|Ec9Zd23;-s99D;{Ry?VoQW+b@$(GwM1hZaoh}*;xoD&Ygj+=4$*-kJjYZ
zqeoTH+v}zn-}1Vt)GeKwOT756f++|Bv_vfs6$pmN1GN`WDzg@|74sQB=ACEGzlH?M
z4iVyXXZx6VpR?=864ouNRhmt~5Rh!~Bo|K)GE4pndG;7xOmnZ^9FD97|2OCjj!5^t
z>>u&f!>plLygDNEn!S0w>>~!4SS9oaUh~KF`lsLMH#3#o!xOzps3?nVfuB3yVdb9A
zp6&P^!dv@uJ5}^zh^|w=0(GD#0J|7hOGYmNpiMJ4Qn_r~xP;lU%3tMO-=2nBD)oxV
z?6NTVpsSbBVeCqBV*Pif%1Azf1RB^xzA)fO(MQ?%j?3a@GVUMoqyEoWxz)S=t93^i
zQNCMWp9ZGqj@^11U4Ctl7FyRv*Y-|Oe2P>{98t_3&~pQX0mSel809O=;?X@{72)`N
z-_K9M#^^IN7j72t?Z@)d>T%bdm&u1^x`m1K&EW$_@ZHfw;Di>?A6`bNlAf<l;a`d?
zTTg|7vkQ%rzvlU2keRdG!!`u~>!8N0v@~og5>~mQqPpZAB1mQq*-z|Ci!q{QieIAa
z!F8+qoKKO%xvh!zdA1%Wy;mns%<6SK81Gyz*Ja_DeXYmK_+O&SDpe$H&ga44jz~xB
zIH+ofe*L{`Cs)_w;^|^ImTliM#r6NHzMGB)+xOx9@H{>aCQrrP@OnJHuk-cm{`tQh
zFTF1>!-Mhjd%rH%XZzykb#ossrF*sS{^&mc&##LijO6k>o~@tHY2?9pyT5ABkK6pJ
z^LxEoC_g_3vsdl>{3@_`4L{rK_xSz&|G)3Y_w)W$?LQyC)~>U&S67Gq|2KRZy2{Ls
zI=V(J0n7{xZP@?|haD=PlWoZgW?_~Nu8P~F`G2{*Wczn8w5K_jqe9ZPwU&EY@9lAM
zLptRjcd<Dx+aRpI%-XLPvH#~^OIX@9_!?UO-XE?meRw`2ud+5@w0l&$g)pO+sZNx*
ziRI~p4>rryP7ZBIpGD6?wC?ah=axhcrLeEzP<)Bm^L^ghn_JO(1<e!(Az+Dp3h`<H
zpha6@kULFkb9JNQ;aVTHagDmb`1F9F6{TMhTaa;5f(y%Xi<6Dk&MRry-7t+x-6Zq-
zPHZ0@Dh1K_&MfH3lMUOGT63@~2%0io6G}5Hj1sq@DtEW(;P|*hELgXrUEC1B9l-%e
z8>oKlEV2??<-VE=X8KhEML^A;Vi%cqaDD-hPa8h>TCZ!N7C%U}naGSEm=PQIm4eCS
zJ@_gSqzu4|WX3NblYigXkWt#sFFhwD)6qRB-tJmw0l&j$kO82oB))b_b3H3_2-1>T
zZmWN4gP}Jx<vn#;{@{$4$Z?v@y1UJz&E&HpAIt94aak^&r<Cjo`9qgAW3V3&RoN_g
z)`h%cO1E_TzVeNFmP+~bE@}3MWEd?`iOcOj4!wj2%`hMRy<LTYS@;%X5v9%GchX0o
z?&+(ZV#ceZtE*sd+0FI(UTo06A(F9;r&4{R@akAROAbHq@s_k)E%+Xy%e=orD6f&@
z1!@EUDL~f01%QKw0)t9dFdWf{(V=0w_wcMR&9L3S?U0BABx=8p2t2F1`BKDqY!*gD
zBEtm@8mHv{HSY=i$^Llkht_K&F2&EqJp50SnV)hl^De&^Yun9uJlRZ`_MH0E`1Df#
z#;0L{&+e+(-OB0h6KOIekqw5vzsZ<l&LOC$+6Z;bZ#Tn_ec|6z0`5kcoV=i5XyO1F
ze{wjYfG@o|h6=l|FqIhlZT%D92E0wO!;wS0Z2>Vj@QzB|?wbKtnqx{DdD#;KqgY@R
zt_MgOfR4Ry#ESx)`HqSTn>K72@xBT-Wml=*_Ckg`DglKQ=>*oWzMjjVuqcZYpLrfD
zMjIj`h;eU);+Ybi<teV;E|nZuvRwvMxf?(FlyfK-8e<;&@6=I0>;A=U9uf0H+Ehja
zW3ydDnGUY%=$phc^zTRs{W6(BnV}z3ug}N|tYRY$XfE22-V_7sEl63qZtrsxc1$RS
zc(Af84hjmi?!t;0h(cOKApZE6IG@^rwBcn$Crh;xRwI@r7Wft6>q?&JZgY^sU_2z8
zq8X+wXyZ{2a<T%MM#74Bvf|dJhNM<vn;7bFOQj^OQvr->dHY$M9e3@nn0|xXpql~r
zIDuXzGIiRly$uF2#pS-;TVIS5vko=LI&4c|R@54*AbBlH8_LxE30$W}jAD;{N6+(o
zK30}d#HDiQ4yDW2GQYe~o+sR&)m-0tzI4HJvi#BzwV|cPwkBJdi*Ly0-PyBik;?s=
z$<kQCvE*JpL7_C5GXT5djFEk+s})y;^<~g^YIdaoG<HsCt3p4DD{^KIF|XMaOe;h;
zg7!ukWdinZ>OjV?8B@~2S?%64-{wzZhxU<S=d(#X_w2;#d^;ri&y=K!n035LBo|k3
z0pB|<2E^*fLDaNyU&3L*cNi-J1ll`>h{S^#f#IBP+n0r(r1#xUT)K824Xux{i|;I+
z8V86@M$<`jkmdHNH`P@=y$=#=Y3$GpTZA2N|7&5Ppj@_h?|<Lh{oi*ZE^*zyrsi_-
z%=65erYz0~1Dp^!07OSVZ&Q-%S5n~gy&i7Ihw!A4o(-q20w6>Picp9Z9eET#nzi{T
zoer1h(fVN4Z7bQrW7u2ZQ}Uz(C95ny>iA?~7c(zd^HXP}{a&B?9RG>$JNjq5+y6Uf
zS?6GN`mVtJPsa08FE1@#Tg2+F+0{7Xm$cjOkH-m7KXK(jLfwcpkbk;Jp|Jpjm^tr9
z=^|u<;&(zdL@uhiX*jpi$3fyG!@`-&s=TK&W0K~y8A5Ei7!Qx)LK_XL;$d<X?atPv
zi;gQ`3gm1<r|Og8vGaZS4;f0HMrn@^?Vt7Tt0MfIE`EaN)%tL@UCsSYvir%8^4oZo
z>)yXvQ+(Ib&~Rou+v)F(DnkFftKaq8f19r^<C!ys@a|}Lo9;gf*YNCXZTz2oXP2dO
z_wlkl+-zJ$S3@=P?Bc#%|JH8>`21(Ol{J1UtdCE<lkWAq^;utjvsv(~%l@$$Z0%Re
zU9bIpHeYYA!^`d4eZHE1x6|9|{pG$2aBBYFPlaFhuj}&pZoU7izwhJs!2DKzx%GeA
z%~fS~v*TH@rt<Q$RJ9|LOHOkbj&NHunBsW$A{eqUfK3u<)mJzT)SMY^au^);8x>8&
zy<9FJ!Jv#|Ea)v`mP3Yy)g(GepG=j?Y;7&YTEXIr<$4s{xNzPa62iy0si2GwTZkW_
zEJ_UP7L%&Wm-uxSC1SMCGE+_JD1<g@nn5sVm+it2;QU_O(f;o$J`es|2EGmt;ouaJ
z_F@xtH^lIUYfMLR2G>z%p^4xO$GL;(W`?GecUClpNG&w4=w(wT(NMHLXY$8*GRH46
z@_)?t6{&dtK)&bx1Q*lJaHyw!o~X0^4Fd0iq|{@bdl3wctj<$pL|W|o{$sQT36&~Z
za-L6+`CDnzU3DMEftW1-hZr!{5(Qy2>L}8dG_~afQ?>qntErD^u=uGg>2j4KX;n^W
zai;mR*w}pDHz}kLf-lr)ya=-%a=Xq2DFUk!+c0vVZ0x{9R=f$HS3qmWU2ILj`hN|q
zaTs`Ra$Spi{uPGWbJf^^TQHbeFP^@={oiu>Iuy){s6f1G-Sy;G09CVw_|U^11phk`
zr)5bFCkTexQ7VWJxb|%vjrU9YJ-ievKZY|M>=xKIWasSuOBtGQ*uI}%2jHSH+W9w%
z?X7k!Y;o~qsjczL>4j@mMR|nf18ES#8m!22ZNNR(^E{k^$>`pXOT^@3$z`ERQsxyy
zNI)vfi2+xjUBOj!3KSxc<-OF4wv^D?y#BF6pg!l2G2KlKL(J5HqdFbh)W|H8v-!G)
zyB^~^)hd7ER`u3^N&&4^Hp(aZTE|ZI2ch>OI?JHQgh1sTw+67T6m`;twj#@2ZI}&f
zM0}m}mUjLCpkmHxWgyr@AA#$7`#qEt!vxzv%JmHjYhm}1J<eXT9%Nr75Vm`yQ7r*-
zjCNcqJYUiAQdJJy?WR@(znd}=<)2e|gE<K3PYc0ps{~*hre|19i5DGVtVVH~#bK9|
z5Bu24=CMi<U2Gr3iK9>kI=CzRx++xplO`S9sEOA4Z>?vgk0;7)tUf^j=waXcY8@dN
z6xpw@fl$0|wh8!|5J!=3^GGKj!70kZS>|ZC!5_;l9jtR0riXgK&$Ih1YX4c+GuP_p
zvH$vni~9osG#xr?n9jSQ2r<7=?|(d|7;F}~fbd{H#f#)KI%jdEq}d7>FGrIKJfTIw
z+IfF-U~^&id#<v>r0l74G_;a3EQ<OVq0hv@y8CTF0Nw*R1K*FYeu(C;`K!dvUNE)%
zJwDGdanIy56}B^G;860dlkgS1MZTPx-h{jr9rr<Z^XPE8%-yo9ZMSN{_<OnRe&<_D
z>$1HXLAib-S6h|77A%i{JgNZ^5Zhb%5;Eo`43i0QA<6@A_P}_)-}8L$OXhmsXKTf&
zq0;ym7{(H08;Zd>kTYllJY3E4I{d~K&90}%;e7V0zTN$ydNc|CUB0O@ol}P2mHsJ(
zy6!0wNhFX(qosgr-}SSu_<0EVHphZ{7lyAj>3?T&+SCUvVM@B)mgrGr0Zdm+abRL}
z3p*#1v8<oV`MecNFr;TAoTrc(V&hA4P`$oC|Lo@rm85^&X0>mX8y!Co`Q<1qAD(YF
zVX)RmP3O0@d@a_)g|5-E>U%dIolce?UC+1Abah=y&L;c0(xi-<lHmNfy?^%m+WOFT
ztY1a;9_Q9~C&TmlyFVYt@6pw-@jib#%pOCx;K+HpwAMcFN9m{SX1%>S&m~?``}EG}
zGBqE6uj|Xqi}>lcg5l}<cfT1Ach+mqqw{<`Q~z9l>-FdN|0;9?)$gE-_WbGgHF__H
zwy#HJ5kGCO-%oVi{j?k(p3y(k=g;~0^!|UGI=C;&?B5fO@2ma&Z&CSQ+xp)__`k$&
z>i=)^^REO?bcH{&m|_U~>torrC<uZi4nz?-%>kS7r!m!lS>ZZlh|wxQQ9$aA%y&7g
zT%IzgD>%K^7wsiDEl&;!<R^Yu20WFlkzDJkZfaL<aAWgDEwy!WrW5W?gm2$R?{Rj=
zu%>)zLzmEGRb*ymZbAHG*Y&U%R;5AeE9O3YK?o0D$g}vjb^#WK#K2#b$-e1u_m~rI
zfqT_#sYW|{m!~B!>&E|G1D`<Z-FT{+sjLPO7OM6Z>HR8==!^??cd_-u4AoI&KmsC-
z?RQ3gTz`YC_TOrVQkUew1WA|_5u1J$4Q2sJ#XOOBc3CySI&cO{igI=3B~Vs6WOOad
zL&DLOgZ^92&RlS)7-qL-W{=%wS8E)5m)YO?_B!gWxR6xP@;5TOec6`+Q*^=nG2w*s
zOe%afB&=4U5(8v3EBCidN8F?FNove(v!KONmjk1goA-7&^{feWO>0h`w!d|ZaV-@_
zv<6C;pb}Z`_ok9W^0jU%{9nmTb6z@ZEsy3Mm4QCb{=R$Ta8IpHDQD*#pnDxv`Dfiv
zfm@J`_ZTO*_c(cpDw@8x4n#3M)u{><D8RE4q$u!RyEs*Y{2O$<SGlO#KyV5CBL;^9
zWFVnJKu=<P7hEl0n68lh;wxX+{z&-B{5%>4PnNL8rE|KJiG9#MRJrye{yjx&<OrSe
zO7#kOhAKEUf_J#wZh!fp76!_p7_UYCHsIoZeGkc)9exdVV!PH7;%(F-?~MyB<kNj6
zpLN<5Oc7f{9XnBf$d;hx`?(sAFX9ppM*oNAPUK)3raChHuQ#GT>+SnGda(V+ewRz$
z`{~Ks-stT9o5Q}g<l$3)k^LK2fu*x$Z2laUNvEi^Y(5VnS}Tm=a}i1utac}DC)2Cq
z)JuJ<?K1Xno~P%bo$uT9&5)42bN`(>N)LAfZU1{d7jD~o7xE9_hGt~pEb9}-UAs4Y
zW>-Z?Ut<)&ef{<CK6mA_-S0Pkf3`<S&C_WARJpPqB7+6|{QAAV%(mZsw9It#p6b2k
zpR=avQSY_YoI1;H`@iIr<njC(%Fa&*OVX;B>hd<*o%dRU!)o5u`T3roR?82*viSVo
z-jpv_kyqZ9{{B7u?tK>pUmwf;{CfUg9_Kr))b9QJSP$>V$K&Z${_wi4*I(7-@cX=<
zZ!d$}{PR|PzkiIc=Qrp0{=T0tulM)ytp4nAzYp(s>Gu17K40BrUf=8c{nh^eb${RG
zWnE^9-e2UUlAWJDbDFb3*~qLUcP&-##bclFTVq(3d2Z+=xswAK$JN`;+fv(jS=MI~
z1LiBu9)6-uZy)3mA-J$yH~xKbE+CMBLq16s)v1|LcvL+2;us+GE2%bvRlBW&4L#(U
z5?18dF4cLP*O6~i>Y}l+nIKEf1gnwxWv5neutQJ#If8PGLyug*{N;*OSIF0k9QLIb
z9mI>OhCKg<?`;OzbUAR{<Y;%lE8`eA9_C<_f9DT@e$&FAQFX!gkF38B|EE8#8-Crk
zna=yeaHG!l?4Q1rH^aluYPV`(DD~FJ*nOv~rJu9?ei9L!2c54?qoq;T-TH8vIXXwt
zEP=?uy>aEib1WM!g{Eqr%?+x)cX?f{|L1o>x$)vA2HM3q&uIBWXZrIUYVF|;$3uBh
zyLOr5bUwak{s(iT9Pw^wy>C|I-r6@1E99q{W#L!Zyt2F-Msf|7qNC~0Xrje3;%h&Q
zGwT~_Rd4tZE1|Ld9R3#V;)=S|TrM8yxpuy<U8f@t<C))MaWTz&os~HGA@f|>OXOLT
zx9vW+5upf<?a=149OZ^58dO1~eX)=q8veVnTae?$@pmGl`H@1rTkWK7zd_XL{jgS_
zomU3MVDRof7B9zVuQBwMu<@y@y=tC?zTLa}^7^>HM0WB2wT;bDaWD}4&M&){=%@eM
z8;?V~bCB?J9Q^lwJ=-JyaVWlAyJw@D<FNa)eqN{h?ZEW&c5i=|Z<^}-J^8NZ#-qWI
z?p1wrdhd64)olHF>a$tDpPL!)XZm~UyuP1Dvr+u{eXO3Etxc2n!K(WEzxKyt{j2?d
zICY;o&-01;g!}&gogI!ViNxvtt0B3Sb#--~I?d;m@0tu=96)_^ML;)S^0uN^$3T{r
zaTp7uv0rFz%d{(4v}bDBIi?dbOm#JvZ%>(fVy0b&cby><2LRy4H4nlLXp=5J>bGcm
zfS3kh#~?&Ts02dpTqXDhv&9e%<GmOwAAh{~Gx&e_?xI>;x;+_&TiLXiwHSYEJ`*$8
z_gVaj<(`XPUXRC@wAp#GBTHgPunj!dWb`9@_wIjGU3{;Lf?oIH1Z`!e$VtNpL(<6i
zUmA0uBVkExlgW?m(M#cEzt>GbzmQ2)<!F|aVe=ZnL}BUqu*iNF@;f~G{DFi%$~Ce<
zXe?g^{h=vQKq@4dX=Z+AFGG>F{_k3gW;fW!F^wWdOpIekkTjVD3W&8?tBMBdko-UE
zXLFj!Z{{Zx!}Ic?rM$fc?EZJ+y{VS1uaN1*h~1OFg->^)c4p^$$3=NJUH|2}$lbc2
z%f?{4G0;{IWeqn5GD^$7tuo4NuuoKP+#Q4d(tkf*!n|K^l~egC&kT37C7j0XZqYgC
z=}`1w@Nh;12#z9sb)Cx<hbgfBW%t=k_EYsQ=w%Soow+^zU-^{3>PVuJ2q1-WaTID!
zbx9(cA$`WlaJQhfqia*D{d({m&Zl{rK%jeV7CmMIX@yk~Ud|Oq&(n?1Wb#`6?M}Pv
zwfA?jpXT?eVZ&=MJSQ9nd-c8T{yZ8T4p+aJ>i%>Rc<+bqt8>1D-~Zi8jW&PF-1tuN
z{QKSxqh~MEtpC0nE~e`nv#I^u`<+=WZ!Wvf?R|Z>&-=xE<YxVUn`gV1@7!_ey4785
zPe-lF`ur;VAKt%%=j7|;YdT*l%_loA=<-#6y)1X1_2KmUzTVFLUvnwt!+kt{A7{r`
z`SE$GzCLXqzy8_#zrP=^_u=&T{r{DpZ?#|J^;hJp{WgC26_cOZ%*9=2Pge>UZU0C%
zd$B~E1BG;}?j4PvevO@;%zx(t+syehwO3)waM^9JHd)mfjvuG_=V8QrP6?@C4#Z$E
z`b$y<8Jd%w;SjftO?P#y^SqCF*KF_@vzd}qd~c(dVDf$+Ctw8E#Kr*<F@PJD8;pUB
zKsWYWM3cM9F?HB(biXmaM)7>P{(2J5`L9LNZ&d%nltVn%=A^VKgkNJ5=k-1*f4{NZ
z;7~dkJwz54*Y}3--sl5+sy0@Wtsa6BB=ZD<2Cf^{b7Y3>^!?f&$}^2(6q`PVNubn#
z;<iQz7?_csu%{N%1V-!=_}vYe|K)<T=%KKGUFN6#YWHSflz+choxL>_^^)1%jmu?i
z?e3r$<h9JsZ~`H`fyjvdR1RS3M<4(qQIHydNQFxD91p3}cAwAeb3FnK^R@ps+3Zuq
zB$kLEfx<xKX^b7i^1EWSZ!N#yoI??`;KDTS7<{qL>(}k(moD6TpnEJktQbttMC4hy
zzRI5x)t$u|<Gjr{t@msD?f+LUm}I*%hiR15<KbW0gFItBBeQ3cb@meEvV-uo{(Yr<
zEDZajPxIA-(|zJxZ|TlR%t=g4Pf9ph)moK%Gd{WlOmW!J^Q99W0X2_6b}iji*jroW
z<`%lo3iTyU>2v?nGq^Tw9BgN!2Wy<xd|vFj&+<**HTkNkiMUT$HW(jum!a{`e4=_*
zDtgInECb)0)xh+2DD^&Qoc3cSg5uwOI6Kc4bG2;U^l}k}VN~$~lC7c)X+TZMS!0Oi
z1g@TWw}*#U^zy`6Sv_qQE?Rn`WdURZG*Yq}l2~BaXFJn)RAhAVo8Hll_!rz+1J)RM
z*hbK<Wk2X!hD0U5>BvGgB_mDA+%Zc$mZXC^Ii?p!YQk9-u8#EHyHl@KZeGl$K;ZZ0
zY2c0Irgx3#3&jqa>2i-6g&Fuq7luD*Sel}sV}5sDvt1R<F@8~cnpKUj?rvh0j{N+k
zW;@3a8?Kt!rPEV$WU5!lqYs^XgGuOXe7!e{Oyg18uu0o=R(24B-rm!o@*F3vytC(u
zrdQnDwe)?T&)BeS&5BGD4Wik4z^(w7fod)a_J6wDJ78jxk)#L?rb#6s!`I4eop7VR
zof09PYf>80de5fT?r7FL^ROTg&HcW%{mzj9@%+6SI&m=Kftje)_}&PDcs{cg?IdRI
zNemHQ^kz-m(g^^YpVb~4!jnppBN)gSlp*jVXrQ@BS1jz;g<)#ZZwdtFXh0Hi4bkZ0
zTeDddblBt^(O9WncQcboa$7wU1T#2wEh?2{P-fP#a)i3WI^lF0Ob`1l5r?w8Kwf*X
z&}|=%Dji;hlM5Y*txUC-DbJbXq@ZS)ATyaWx%*f%{J)pG{9MXK`d;a(@9Ave8}I(1
zA3faEdUfY{d(4-+O)n99I6nd-f(dkF9V`&3(fS^C&y@kcF0eo?{E~#jDgZqwc5+am
zua8$1R1F+O?4SvW9po0LR}K6I(MPuQTXw*P+9GVA(UX<9=C48TeebHbBRMFZ3ltN{
zfwO>*D+F4M+S2C21Go6}Z2jJ$v0tLe`J6uyY(zp(?>{P+@%!l93q}EdN5D|cMo761
zC1n23d~_NU+=)TQUar#`wL||eJvaL_J_TRXP8<&RQ~It^o&IL`lVZ=DyjLM%t;(Wx
zovF<_w1}j;xuA-?$p$ZwS~IvSqnuk8PzNN7TnQ}FCGBoHAtFp_7o<}KbuD2+woI|n
zSa)hRlX>J`qFZC3(I_amBxCoA79886E7h}T$>t+HUhHyYWo#Uptqi`-2PFvGeC;xA
zBTzIu+hC;AO9uDEGkHk1Kde)vocib{e#_tchL^Fl&-d%rHO$azN;y0g`VQnwA5_-L
zYHN;6iBgIy7Q#wINV-}m%GUa*&0p|6ZhOG25+SXo#w43;<blrXUP8%;&<q3`r{59N
z;`<%W$VL7!0x*~3CPv?UEeturf<c=nD2Yx;pXQ<`$)t*KMvd1ksAV2T-&)i9ZPEpH
zn${?sGsII!vR*oE&vb1A#+}dKHA<MRbsQh-X@zAEwpBTtzYTpUe{i^az`9uw1Iknv
z00#!J5oC3{UeQy32_O)jlU=UdUF3fi&8qiV+jZP?X9!NLJG9^8Zob$EamBCQwq*Mp
z0#&c>w>yg;{jF1++A@ciB22Bq;Z<bN_!5JY=(}<L&4FP4mi8(X;+-U0R+6{=RB8*m
zNvNt0SdmJoCs=vL&81y^8#2V?*-VP++(Pbs)8@A+-cOrEISmw*bkab^?$Fx2HCp>h
zf(wj6DF#1HKs!2$Qj&T_UKmZqAzp%GbSSE8s-<qG^PD1b!yrj3SMhhV?wu4&pmMGD
zUlX0L#pg=>Q41mFNnfHbalDu?2z@MjG(WdSIoPxKEhZhq$$pj<S^?Y9Pz<^ZZyHvm
zZoXVbz5|fsFCtuv>-<?@%Y!b1c=1Hox0hkJjk;=tHoRx7IN`^PDn{hFVi~TR&_20=
zr^5wfzpF5Ty4(Xo;?QfBuM<}G8o0RZno^rO_lr*z@7D717F=k`2Xspqba~KD88vh|
zy;Z8yH9Bhc^EB5h=}zNw!k8;v=hJTX(5~ILZ{lcBxc*DexX9tPg7}$EQ!EK$p7{#5
zB2rPgcQ`<0neY=JNg(f{1*SIy2)<y2H(24wlkA}em7wHy+8GEt<{uq`#9}*Exz5f1
zZy;DrFDZrBTlwUUoag4duA^<?&bzw(9kV^#-DZg7QVWT&#nJOV&+v6svjBtijDrdh
z22>6fxAN`FL#~Kw<|_@PEjTwNK%MPTzVQ2<wcGC7Wo*Qoj4ke2OLR<#q0B)}-!sYB
z?{5&@MaF`mxL}B47jDsoC>7I2ae|kP3O*{@A0lZL7m%-H8bjje_Hzu+{|+s)`j1!s
z<d3C)AEi`T^`U5JgFg^9JSdKZ$r3*Cr;9}3nh&f<%X3+eA5kJ~);M@h3l0#(g1}i7
zVyOWbBNS0lSVf8{`Dt0tYKW37Sg}GZMi5j%XL|o1v;WRXvO!=YAhI!4AU}**P(}+P
zkw~#o0Tfh<DGvbub0K~%rXMQzS=&t@qJoO5MUhCNg2f;y6cr!MXGij>G?7IhpsEoO
zMUYqm|DVZZn5-g-MFe6h3Ic$k-hQ`5`rL<yx*O0NGrPrwZ;P9!Wy+_4HDSAmYH~k%
zU)8UQc;0^ZL3NQ=u#dg`8@N*H_&nGjqx$sn{&oEq-F`Lo5379-cVd&t3H4{&MHVat
zS^U!5YXn49Sr`f^DHcd9QB^?&6h)Fn1(9Jys;DZ0sH+7Q3Nb_lMj|MvqA+5psti?F
zh^VkpNfc3Jiv<)^7$_o&iosZnRY;;FRT!{~Af!<dRYEa}D#(ci0Z5>tsEVu=NfC%5
z!B#|r1VmvJSgN4KL{u2b1r&-e<Cd{&T1qKJYF4yXYzE`OEAVPjACeQg@;d8xrDqPX
zzn|^g_*}o>;mM@yA^F|(g{S34?iL?%poVEcbLyZ(o}KaKxKa{H3$vFBUw)_yuK3-7
zFIs90vMpjFILfwcVu)5s1TvFr<On7Kx;_e1@uFCw!6D+LD1tNP+Ytr+^Ll&xQR|tN
z5Gb(xhGvPe50|eRw=;KFs<CJ?`8};OAN?}h61ihTmVov$>=S_#ZMW>RUiwpV{o{Yj
z`+w8!Z)=?AU5@|zJ?9JPY52f|C5XTQ-P>YHRXE6C1)AoYx43j&Hea^G+^_#v>yd}l
z+~;nhSW&GE#?53jd&vb;x9hYvA1}@P*uNjGUFzi5kIC`&(oHUy29yPA*4FWNcY-;H
zjR+9T$fjUiRKm*1QI?XRsw#^JR8o8Np4E{??DG^`xAnDHrIIQphBu1J&oVW6%Q1|6
z@qy7n6hK5`(ZsSG4D@fGcbq^kL2CN{W$yUyCn^5#&^SlGupmXP1>F*ufe%S`ctpTU
znY8{rE?4h;j>ALkDf!7Ef3yC#mOl%~L7<!<jQu=wySBy94%!JbS+3^Y&eS0;-x8QW
z9l}sSSdUs<Mv^uSC12uFV<#~sLk7bi<Cj2OyD}BAYBE*2HwHEH6ho?ys)LUgebit#
zZNQ(qVYxS<>~hIH_N)#^NN{A6Oc9gKw3L8sBnTN7W^=yB9DIq!6H^k6NAl8PF||0+
z5LX|EZh^nWd1(C~r(K=jk@@}Sb^dsMm!+$d)<B`W7l+D^D>qD-+d#$*Fm13@Q3PVF
zo;St)ul0S-!MRZdih`)WNvfzSpA+-2!9|M&6rbg`ef)k`>U%Gny|KM)IjBuhl+B9N
zuXzKC?o>l8X!U!Jn<;}g!d5>J{(dDiRM5Iv#$$aBijWQkD(Hw(u+s8VFzmrL2l+A?
z!)31^^Nd6tt}y{!3d}?fVj?m?$X(Gf?|N_dL-MI`i<qxd++O14FKzg*?z)Ssje?Yp
z+V5kpk`=q;q{CFUU$)_u50-mjz$@~{77{)+N(E1_dj_~&Tv^fqv7=UM);RwoxzYDJ
z%@w`Z9pajw%wa?5#^R(G7iYL+^Crxw?LrtYZBK=Y=BR4hBBt4V$#`%@njp{Av3_1b
zdQ0nC%ob>1;JGRc6eQdh(Z^ATgT>FU){%ym)N=qDwaFj|5Hqww#=wZWIr5P9z_s{9
z94bHGe$5wXryN~U198VxcDQY;tKr&1^3b1v$Y}yr0ti(82d$uJWL9zqAUotCDGz?T
zD1fQr@`il_`jZKrG>DT-$4Q%2$!Pv!3+<T$b7Kd#k=xv6E>!dv$)5LbLp{~edNz&`
zw}~hnW}8zTAu;;zE;0XUNZe8ezmc<LXCTebi9qxB1O}eVXkpTH#&dMa$55p9ui0Jv
zqr4tjT)_iLl!Xb%Hy+_-qg3p<RS7BpOqPmb0@#Q#mOVqb-}Bn+$5Q}EtG|v|`?MF}
zCXg!BVA>3?`of=quAs~enc+V+Y}t}1;O6sW)BLVKsqq_O?oky{6Z;!nZF);>po7r&
zQLP&SKEDa%`m@?m$l;#^RsW01M|r1H6sooj6+~X(mQz`Z>os)s*DeetajEY1<%F(U
z=eS!<yJpuJwxEtu;a|nlZm=c*WS#&x1|ISde@ZC(*n`hQg%@=cQ=hRwpJo6%zC9p7
zSv6W1zxaPvEI|}Fqm$4g>YiSJj1CWd^L>v8&4`O9Y&1AP5HHt1dCw1mqEpZT5tJ`-
zEoXI`{$b+O^EaHjQGb>Yn<e50&cxnJ7-1&Vp@6_<q}OA8{8Y~Z(ku;vKV}gaTx~(Y
z5G+_CA_3oPpR1C?YC8Nb0)3Tg(?%=vt5V#Zi^QgxKauZ0rr(i2F17I~AD84;_prkI
zKZp3R^WT4u&C=fI<KFhZcwuZO<<{2Vk7es6^TKDh$I=K95qIzG`+xIv&e_(oGwKwF
zR<*%XiuG2Vg5Dy;xiyrG8L?9<@eA_DFB2Y4IpywnzGgntAE)>;G|%;4>E8Q3ztrPT
zr*13L3)98M_x>%j(^9y3-y!~~@4fo}$>*KAeq<L<?VFA(knsMrlK<{M>W!;BSfh#v
zqJq4C%Lny8FNxm46fybT!|%Zius{6HJ9yve_c%|y;^+U_#@uuBxaQ;N@Orv7I9+4U
z!NjEVTtyRGNHDlK`<CimYyXzV%HsQQ_n$=0Rqw$P?TC1o*wAe6kvH4yUaPqmi@qeM
zca(*yv@hxsEvmVzAO2Q4d3m$g^3-kLT2KZIjJRQmsI;@^@5%)A&1o3|>^ON==8{VQ
zematJfWRY(8b*iWFae{c5Z-7Shx=}4<wItb<sg{bgcC+w#Azdh&}g%agK3<SBGKx#
z*o1%53K#%yQQpWPPj^N^0xo8QOy^sp)2&)YCet!V2&5r7A6qm+e{~Z}wvtMd{wn;x
zCZ_#QYH1{uQi{IJm41Hte)Z<v+|$)p#<mvv6~fo_SX=1UZBLJWqO`StcKpiPp0eK~
z&r|pM>QnRnH6peB`&!ff`p2fU{W*#ApUn#&%Fz+~j_paGn*J007yhSszJJJyiJ{S}
z;;gVJsW_EQ(F&6OOd^8k|1xBX9{R3bZZaY<1Y(kogpd&AJmfJG`rV6;*Xr_@9W!Q*
zn=!`>wFX^p*<Ff3B?m?tAVjk=L{);JBo?I|=v7LC6j(B<3@H+@V2VW@T$4pbA&L=2
z0)?Sql#T*u93qH81TxmW*!XxVCTyNeYr|)%>5F>T;UQW$)EfjPl;`l|_Lfb>)zn(6
ztrPtbhU0D+R;T%av{Shiv6>y60`%_bwtF3-tJiA?%WIABJ?;NK3@`q{;+`n)ve3PW
zWK0~)lC%tgzB0w}Ng0&#NSz5(ks>1(T;Z1UI|Zaue}yGORiQOS5HYC_p$s>^rmwrx
za&?-??zG!YJOB{`{v$0Xz|Bjt&bHT!J@GBqN5vvX(_+5#FTBie%lkz_GpVtq|7IEQ
zI^?S5!Q)oMwZ)Ir(w7`nUw^m|Iq%@ngS7AYm37`0PUt?qPsjvf8vsIIBo<U?SWb>E
z(q?>I9r6C(A**1i{XaL|<lW2J7sIBq52&wZ!Qjv?FD|>8TaK3U*Ic>Q*DGBW-S;O|
z0dc?3&|dsKO#MgVQz@%w&%wnPOtW{OakZVoZ&4F;E1o=fOHGg7{j>MtTA{5Epf#?A
zM&oB|x5i4`T(h=uZ)nk(&9QZ|wO5zu!yMVvsle-zW&I7Y1G}HQo8X}2vjftODfD#W
z;5;sGVMnczgpC)UciCYe3J^E!<@LU{iI2hRx|`StZiuw~fneCoK<3qc_vHM2+2*wY
z3V%)2HjxgLQT|N2pNU>*@P5n>Pn!f$^N~$0jFl5xVv4}UEp2mI$CT=P^wC%iboJ^#
zb@=C7qP%{5t#-ueWU)=nS{AsQoz6I%v*O)6ex8eZps&w-Nfbd_Wsfyrx&|+WXOePl
zp|wu5O4_pYQ<KzII@`mGYh&m9=*)3(Rn0I*;d*=;A8-1B06$lGdwf5*84#aHf+6xB
z%fWF?(^KmoQtq^W*6v&i*8n6Ym`NdyRbYT~DvY_Eo`0d~|6}X?h3pCcZ}l?!7ieYw
zw8@b0sI;R;XjMp30Vaz`5FM)CVXa4pQeG=2i&av<sQ@f8xke~{#cCo3n?2SNav1mn
za(K2gh^{!@#$!|J%hpb|Vj$ryH&RxDK+4vc1Eh3`5x5M|r@QgHSgO{-_2=qt>|buy
z#ro;r$W`X|&mz4^J%mI?PNpI=kqz%+8|=QX()GK|HA=&4pb-GmHGeWvm&w?Cx+eO6
ziSDGB_?*4}RK`YJ?Sp^N?e#qFM_0-BINeWIc`B)<s}@p9rjfI`5X1DePd&8uHo4kB
z&Vxq(`(VT@F`^RVuxtebOOD9o<Q_cF9n4{%Xw35<62Jvqfi!}UO_*2{&T2qdAKi4=
zN&1?hzINED6QE<5jBpV#kp~k`5{&fI`br5*Zzu7r<Z8Rtjm-tG{ONx9({9dh8hn*<
zBRhIg>ir`*^b>P5K~Nj)2@*pUe&DMYb`wM)z+12*4Zgh)5YafrI5W3Au(bxuu+lx)
z*zDZ9V}SJNuw%NjwSma)+wV8-n~QC?99S!s;_}>@C2l=gU$d))np&>TjEv!Mk{iX6
zgoA$8ipIu9OgM@MhOcxXY$Kc%`oaXnL5ni{opr_9Bbg#ViwQ{<jvY)8Qo!RW0_SO3
z-_G4LTs|%kJ`VN{�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
literal 0
HcmV?d00001
--
1.7.6.5