From cd79c6a8dfc07d451a8b38cd0a57608f01b65fa9 Mon Sep 17 00:00:00 2001 From: Your Name Date: Sat, 27 Apr 2024 03:18:07 -0500 Subject: [PATCH] wip --- can/SConscript | 28 + {opendbc/can => can}/__init__.py | 0 {opendbc/can => can}/can_define.py | 0 can/common.cc | 246 + can/common.h | 102 + {opendbc/can => can}/common.pxd | 0 can/common_dbc.h | 77 + can/dbc.cc | 258 + can/packer.cc | 98 + {opendbc/can => can}/packer.py | 0 {opendbc/can => can}/packer_pyx.pyx | 0 can/parser.cc | 326 + {opendbc/can => can}/parser.py | 0 {opendbc/can => can}/parser_pyx.pyx | 0 can/tests/.gitignore | 1 + can/tests/__init__.py | 8 + can/tests/test.dbc | 27 + can/tests/test_checksums.py | 42 + can/tests/test_dbc_exceptions.py | 36 + can/tests/test_dbc_parser.py | 28 + can/tests/test_define.py | 35 + can/tests/test_packer_parser.py | 386 + can/tests/test_parser_performance.py | 55 + opendbc/can/libdbc.so | Bin 6648072 -> 0 bytes opendbc/can/packer_pyx.cpp | 9741 ------------------ opendbc/can/packer_pyx.so | Bin 709720 -> 0 bytes opendbc/can/parser_pyx.cpp | 13645 ------------------------- opendbc/can/parser_pyx.so | Bin 1151272 -> 0 bytes 28 files changed, 1753 insertions(+), 23386 deletions(-) create mode 100644 can/SConscript rename {opendbc/can => can}/__init__.py (100%) rename {opendbc/can => can}/can_define.py (100%) create mode 100644 can/common.cc create mode 100644 can/common.h rename {opendbc/can => can}/common.pxd (100%) create mode 100644 can/common_dbc.h create mode 100644 can/dbc.cc create mode 100644 can/packer.cc rename {opendbc/can => can}/packer.py (100%) rename {opendbc/can => can}/packer_pyx.pyx (100%) create mode 100644 can/parser.cc rename {opendbc/can => can}/parser.py (100%) rename {opendbc/can => can}/parser_pyx.pyx (100%) create mode 100644 can/tests/.gitignore create mode 100644 can/tests/__init__.py create mode 100644 can/tests/test.dbc create mode 100644 can/tests/test_checksums.py create mode 100644 can/tests/test_dbc_exceptions.py create mode 100644 can/tests/test_dbc_parser.py create mode 100644 can/tests/test_define.py create mode 100644 can/tests/test_packer_parser.py create mode 100644 can/tests/test_parser_performance.py delete mode 100755 opendbc/can/libdbc.so delete mode 100644 opendbc/can/packer_pyx.cpp delete mode 100755 opendbc/can/packer_pyx.so delete mode 100644 opendbc/can/parser_pyx.cpp delete mode 100755 opendbc/can/parser_pyx.so diff --git a/can/SConscript b/can/SConscript new file mode 100644 index 0000000..7e8fd27 --- /dev/null +++ b/can/SConscript @@ -0,0 +1,28 @@ +Import('env', 'envCython', 'cereal', 'common') + +import os + +envDBC = env.Clone() +dbc_file_path = '-DDBC_FILE_PATH=\'"%s"\'' % (envDBC.Dir("..").abspath) +envDBC['CXXFLAGS'] += [dbc_file_path] +src = ["dbc.cc", "parser.cc", "packer.cc", "common.cc"] +libs = [common, "capnp", "kj", "zmq"] + +# shared library for openpilot +libdbc = envDBC.SharedLibrary('libdbc', src, LIBS=libs) + +# static library for tools like cabana +envDBC.Library('libdbc_static', src, LIBS=libs) + +# Build packer and parser +lenv = envCython.Clone() +lenv["LINKFLAGS"] += [libdbc[0].get_labspath()] +parser = lenv.Program('parser_pyx.so', 'parser_pyx.pyx') +packer = lenv.Program('packer_pyx.so', 'packer_pyx.pyx') + +lenv.Depends(parser, libdbc) +lenv.Depends(packer, libdbc) + +opendbc_python = Alias("opendbc_python", [parser, packer]) + +Export('opendbc_python') \ No newline at end of file diff --git a/opendbc/can/__init__.py b/can/__init__.py similarity index 100% rename from opendbc/can/__init__.py rename to can/__init__.py diff --git a/opendbc/can/can_define.py b/can/can_define.py similarity index 100% rename from opendbc/can/can_define.py rename to can/can_define.py diff --git a/can/common.cc b/can/common.cc new file mode 100644 index 0000000..37b48fa --- /dev/null +++ b/can/common.cc @@ -0,0 +1,246 @@ +#include "opendbc/can/common.h" + + +unsigned int honda_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + int s = 0; + bool extended = address > 0x7FF; + while (address) { s += (address & 0xF); address >>= 4; } + for (int i = 0; i < d.size(); i++) { + uint8_t x = d[i]; + if (i == d.size()-1) x >>= 4; // remove checksum + s += (x & 0xF) + (x >> 4); + } + s = 8-s; + if (extended) s += 3; // extended can + + return s & 0xF; +} + +unsigned int toyota_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + unsigned int s = d.size(); + while (address) { s += address & 0xFF; address >>= 8; } + for (int i = 0; i < d.size() - 1; i++) { s += d[i]; } + + return s & 0xFF; +} + +unsigned int subaru_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + unsigned int s = 0; + while (address) { s += address & 0xFF; address >>= 8; } + + // skip checksum in first byte + for (int i = 1; i < d.size(); i++) { s += d[i]; } + + return s & 0xFF; +} + +unsigned int chrysler_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + // jeep chrysler canbus checksum from http://illmatics.com/Remote%20Car%20Hacking.pdf + uint8_t checksum = 0xFF; + for (int j = 0; j < (d.size() - 1); j++) { + uint8_t shift = 0x80; + uint8_t curr = d[j]; + for (int i = 0; i < 8; i++) { + uint8_t bit_sum = curr & shift; + uint8_t temp_chk = checksum & 0x80U; + if (bit_sum != 0U) { + bit_sum = 0x1C; + if (temp_chk != 0U) { + bit_sum = 1; + } + checksum = checksum << 1; + temp_chk = checksum | 1U; + bit_sum ^= temp_chk; + } else { + if (temp_chk != 0U) { + bit_sum = 0x1D; + } + checksum = checksum << 1; + bit_sum ^= checksum; + } + checksum = bit_sum; + shift = shift >> 1; + } + } + return ~checksum & 0xFF; +} + +// Static lookup table for fast computation of CRCs +uint8_t crc8_lut_8h2f[256]; // CRC8 poly 0x2F, aka 8H2F/AUTOSAR +uint16_t crc16_lut_xmodem[256]; // CRC16 poly 0x1021, aka XMODEM + +void gen_crc_lookup_table_8(uint8_t poly, uint8_t crc_lut[]) { + uint8_t crc; + int i, j; + + for (i = 0; i < 256; i++) { + crc = i; + for (j = 0; j < 8; j++) { + if ((crc & 0x80) != 0) + crc = (uint8_t)((crc << 1) ^ poly); + else + crc <<= 1; + } + crc_lut[i] = crc; + } +} + +void gen_crc_lookup_table_16(uint16_t poly, uint16_t crc_lut[]) { + uint16_t crc; + int i, j; + + for (i = 0; i < 256; i++) { + crc = i << 8; + for (j = 0; j < 8; j++) { + if ((crc & 0x8000) != 0) { + crc = (uint16_t)((crc << 1) ^ poly); + } else { + crc <<= 1; + } + } + crc_lut[i] = crc; + } +} + +void init_crc_lookup_tables() { + // At init time, set up static lookup tables for fast CRC computation. + gen_crc_lookup_table_8(0x2F, crc8_lut_8h2f); // CRC-8 8H2F/AUTOSAR for Volkswagen + gen_crc_lookup_table_16(0x1021, crc16_lut_xmodem); // CRC-16 XMODEM for HKG CAN FD +} + +unsigned int volkswagen_mqb_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + // Volkswagen uses standard CRC8 8H2F/AUTOSAR, but they compute it with + // a magic variable padding byte tacked onto the end of the payload. + // https://www.autosar.org/fileadmin/user_upload/standards/classic/4-3/AUTOSAR_SWS_CRCLibrary.pdf + + uint8_t crc = 0xFF; // Standard init value for CRC8 8H2F/AUTOSAR + + // CRC the payload first, skipping over the first byte where the CRC lives. + for (int i = 1; i < d.size(); i++) { + crc ^= d[i]; + crc = crc8_lut_8h2f[crc]; + } + + // Look up and apply the magic final CRC padding byte, which permutes by CAN + // address, and additionally (for SOME addresses) by the message counter. + uint8_t counter = d[1] & 0x0F; + switch (address) { + case 0x86: // LWI_01 Steering Angle + crc ^= (uint8_t[]){0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86}[counter]; + break; + case 0x9F: // LH_EPS_03 Electric Power Steering + crc ^= (uint8_t[]){0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5, 0xF5}[counter]; + break; + case 0xAD: // Getriebe_11 Automatic Gearbox + crc ^= (uint8_t[]){0x3F, 0x69, 0x39, 0xDC, 0x94, 0xF9, 0x14, 0x64, 0xD8, 0x6A, 0x34, 0xCE, 0xA2, 0x55, 0xB5, 0x2C}[counter]; + break; + case 0xFD: // ESP_21 Electronic Stability Program + crc ^= (uint8_t[]){0xB4, 0xEF, 0xF8, 0x49, 0x1E, 0xE5, 0xC2, 0xC0, 0x97, 0x19, 0x3C, 0xC9, 0xF1, 0x98, 0xD6, 0x61}[counter]; + break; + case 0x106: // ESP_05 Electronic Stability Program + crc ^= (uint8_t[]){0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07}[counter]; + break; + case 0x117: // ACC_10 Automatic Cruise Control + crc ^= (uint8_t[]){0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16}[counter]; + break; + case 0x120: // TSK_06 Drivetrain Coordinator + crc ^= (uint8_t[]){0xC4, 0xE2, 0x4F, 0xE4, 0xF8, 0x2F, 0x56, 0x81, 0x9F, 0xE5, 0x83, 0x44, 0x05, 0x3F, 0x97, 0xDF}[counter]; + break; + case 0x121: // Motor_20 Driver Throttle Inputs + crc ^= (uint8_t[]){0xE9, 0x65, 0xAE, 0x6B, 0x7B, 0x35, 0xE5, 0x5F, 0x4E, 0xC7, 0x86, 0xA2, 0xBB, 0xDD, 0xEB, 0xB4}[counter]; + break; + case 0x122: // ACC_06 Automatic Cruise Control + crc ^= (uint8_t[]){0x37, 0x7D, 0xF3, 0xA9, 0x18, 0x46, 0x6D, 0x4D, 0x3D, 0x71, 0x92, 0x9C, 0xE5, 0x32, 0x10, 0xB9}[counter]; + break; + case 0x126: // HCA_01 Heading Control Assist + crc ^= (uint8_t[]){0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA, 0xDA}[counter]; + break; + case 0x12B: // GRA_ACC_01 Steering wheel controls for ACC + crc ^= (uint8_t[]){0x6A, 0x38, 0xB4, 0x27, 0x22, 0xEF, 0xE1, 0xBB, 0xF8, 0x80, 0x84, 0x49, 0xC7, 0x9E, 0x1E, 0x2B}[counter]; + break; + case 0x12E: // ACC_07 Automatic Cruise Control + crc ^= (uint8_t[]){0xF8, 0xE5, 0x97, 0xC9, 0xD6, 0x07, 0x47, 0x21, 0x66, 0xDD, 0xCF, 0x6F, 0xA1, 0x94, 0x74, 0x63}[counter]; + break; + case 0x187: // EV_Gearshift "Gear" selection data for EVs with no gearbox + crc ^= (uint8_t[]){0x7F, 0xED, 0x17, 0xC2, 0x7C, 0xEB, 0x44, 0x21, 0x01, 0xFA, 0xDB, 0x15, 0x4A, 0x6B, 0x23, 0x05}[counter]; + break; + case 0x30C: // ACC_02 Automatic Cruise Control + crc ^= (uint8_t[]){0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F}[counter]; + break; + case 0x30F: // SWA_01 Lane Change Assist (SpurWechselAssistent) + crc ^= (uint8_t[]){0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C}[counter]; + break; + case 0x324: // ACC_04 Automatic Cruise Control + crc ^= (uint8_t[]){0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27}[counter]; + break; + case 0x3C0: // Klemmen_Status_01 ignition and starting status + crc ^= (uint8_t[]){0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3}[counter]; + break; + case 0x65D: // ESP_20 Electronic Stability Program + crc ^= (uint8_t[]){0xAC, 0xB3, 0xAB, 0xEB, 0x7A, 0xE1, 0x3B, 0xF7, 0x73, 0xBA, 0x7C, 0x9E, 0x06, 0x5F, 0x02, 0xD9}[counter]; + break; + default: // As-yet undefined CAN message, CRC check expected to fail + printf("Attempt to CRC check undefined Volkswagen message 0x%02X\n", address); + crc ^= (uint8_t[]){0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}[counter]; + break; + } + crc = crc8_lut_8h2f[crc]; + + return crc ^ 0xFF; // Return after standard final XOR for CRC8 8H2F/AUTOSAR +} + +unsigned int xor_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + uint8_t checksum = 0; + int checksum_byte = sig.start_bit / 8; + + // Simple XOR over the payload, except for the byte where the checksum lives. + for (int i = 0; i < d.size(); i++) { + if (i != checksum_byte) { + checksum ^= d[i]; + } + } + + return checksum; +} + +unsigned int pedal_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + uint8_t crc = 0xFF; + uint8_t poly = 0xD5; // standard crc8 + + // skip checksum byte + for (int i = d.size()-2; i >= 0; i--) { + crc ^= d[i]; + for (int j = 0; j < 8; j++) { + if ((crc & 0x80) != 0) { + crc = (uint8_t)((crc << 1) ^ poly); + } else { + crc <<= 1; + } + } + } + return crc; +} + +unsigned int hkg_can_fd_checksum(uint32_t address, const Signal &sig, const std::vector &d) { + uint16_t crc = 0; + + for (int i = 2; i < d.size(); i++) { + crc = (crc << 8) ^ crc16_lut_xmodem[(crc >> 8) ^ d[i]]; + } + + // Add address to crc + crc = (crc << 8) ^ crc16_lut_xmodem[(crc >> 8) ^ ((address >> 0) & 0xFF)]; + crc = (crc << 8) ^ crc16_lut_xmodem[(crc >> 8) ^ ((address >> 8) & 0xFF)]; + + if (d.size() == 8) { + crc ^= 0x5f29; + } else if (d.size() == 16) { + crc ^= 0x041d; + } else if (d.size() == 24) { + crc ^= 0x819d; + } else if (d.size() == 32) { + crc ^= 0x9f5b; + } + + return crc; +} diff --git a/can/common.h b/can/common.h new file mode 100644 index 0000000..cfc63eb --- /dev/null +++ b/can/common.h @@ -0,0 +1,102 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include + +#ifndef DYNAMIC_CAPNP +#include "cereal/gen/cpp/log.capnp.h" +#endif + +#include "opendbc/can/common_dbc.h" + +#define INFO printf +#define WARN printf +#define DEBUG(...) +//#define DEBUG printf + +#define MAX_BAD_COUNTER 5 +#define CAN_INVALID_CNT 5 + +void init_crc_lookup_tables(); + +// Car specific functions +unsigned int honda_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int toyota_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int subaru_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int chrysler_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int volkswagen_mqb_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int xor_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int hkg_can_fd_checksum(uint32_t address, const Signal &sig, const std::vector &d); +unsigned int pedal_checksum(uint32_t address, const Signal &sig, const std::vector &d); + +class MessageState { +public: + std::string name; + uint32_t address; + unsigned int size; + + std::vector parse_sigs; + std::vector vals; + std::vector> all_vals; + + uint64_t last_seen_nanos; + uint64_t check_threshold; + + uint8_t counter; + uint8_t counter_fail; + + bool ignore_checksum = false; + bool ignore_counter = false; + + bool parse(uint64_t nanos, const std::vector &dat); + bool update_counter_generic(int64_t v, int cnt_size); +}; + +class CANParser { +private: + const int bus; + kj::Array aligned_buf; + + const DBC *dbc = NULL; + std::unordered_map message_states; + +public: + bool can_valid = false; + bool bus_timeout = false; + uint64_t first_nanos = 0; + uint64_t last_nanos = 0; + uint64_t last_nonempty_nanos = 0; + uint64_t bus_timeout_threshold = 0; + uint64_t can_invalid_cnt = CAN_INVALID_CNT; + + CANParser(int abus, const std::string& dbc_name, + const std::vector> &messages); + CANParser(int abus, const std::string& dbc_name, bool ignore_checksum, bool ignore_counter); + #ifndef DYNAMIC_CAPNP + void update_string(const std::string &data, bool sendcan); + void update_strings(const std::vector &data, std::vector &vals, bool sendcan); + void UpdateCans(uint64_t nanos, const capnp::List::Reader& cans); + #endif + void UpdateCans(uint64_t nanos, const capnp::DynamicStruct::Reader& cans); + void UpdateValid(uint64_t nanos); + void query_latest(std::vector &vals, uint64_t last_ts = 0); +}; + +class CANPacker { +private: + const DBC *dbc = NULL; + std::map, Signal> signal_lookup; + std::map message_lookup; + std::map counters; + +public: + CANPacker(const std::string& dbc_name); + std::vector pack(uint32_t address, const std::vector &values); + Msg* lookup_message(uint32_t address); +}; diff --git a/opendbc/can/common.pxd b/can/common.pxd similarity index 100% rename from opendbc/can/common.pxd rename to can/common.pxd diff --git a/can/common_dbc.h b/can/common_dbc.h new file mode 100644 index 0000000..ef4c98c --- /dev/null +++ b/can/common_dbc.h @@ -0,0 +1,77 @@ +#pragma once + +#include +#include +#include +#include + +struct SignalPackValue { + std::string name; + double value; +}; + +struct SignalValue { + uint32_t address; + uint64_t ts_nanos; + std::string name; + double value; // latest value + std::vector all_values; // all values from this cycle +}; + +enum SignalType { + DEFAULT, + COUNTER, + HONDA_CHECKSUM, + TOYOTA_CHECKSUM, + PEDAL_CHECKSUM, + VOLKSWAGEN_MQB_CHECKSUM, + XOR_CHECKSUM, + SUBARU_CHECKSUM, + CHRYSLER_CHECKSUM, + HKG_CAN_FD_CHECKSUM, +}; + +struct Signal { + std::string name; + int start_bit, msb, lsb, size; + bool is_signed; + double factor, offset; + bool is_little_endian; + SignalType type; + unsigned int (*calc_checksum)(uint32_t address, const Signal &sig, const std::vector &d); +}; + +struct Msg { + std::string name; + uint32_t address; + unsigned int size; + std::vector sigs; +}; + +struct Val { + std::string name; + uint32_t address; + std::string def_val; + std::vector sigs; +}; + +struct DBC { + std::string name; + std::vector msgs; + std::vector vals; +}; + +typedef struct ChecksumState { + int checksum_size; + int counter_size; + int checksum_start_bit; + int counter_start_bit; + bool little_endian; + SignalType checksum_type; + unsigned int (*calc_checksum)(uint32_t address, const Signal &sig, const std::vector &d); +} ChecksumState; + +DBC* dbc_parse(const std::string& dbc_path); +DBC* dbc_parse_from_stream(const std::string &dbc_name, std::istream &stream, ChecksumState *checksum = nullptr, bool allow_duplicate_msg_name=false); +const DBC* dbc_lookup(const std::string& dbc_name); +std::vector get_dbc_names(); diff --git a/can/dbc.cc b/can/dbc.cc new file mode 100644 index 0000000..7abe6b6 --- /dev/null +++ b/can/dbc.cc @@ -0,0 +1,258 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "opendbc/can/common.h" +#include "opendbc/can/common_dbc.h" + +std::regex bo_regexp(R"(^BO_ (\w+) (\w+) *: (\w+) (\w+))"); +std::regex sg_regexp(R"(^SG_ (\w+) : (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))"); +std::regex sgm_regexp(R"(^SG_ (\w+) (\w+) *: (\d+)\|(\d+)@(\d+)([\+|\-]) \(([0-9.+\-eE]+),([0-9.+\-eE]+)\) \[([0-9.+\-eE]+)\|([0-9.+\-eE]+)\] \"(.*)\" (.*))"); +std::regex val_regexp(R"(VAL_ (\w+) (\w+) (\s*[-+]?[0-9]+\s+\".+?\"[^;]*))"); +std::regex val_split_regexp{R"([\"]+)"}; // split on " + +#define DBC_ASSERT(condition, message) \ + do { \ + if (!(condition)) { \ + std::stringstream is; \ + is << "[" << dbc_name << ":" << line_num << "] " << message; \ + throw std::runtime_error(is.str()); \ + } \ + } while (false) + +inline bool startswith(const std::string& str, const char* prefix) { + return str.find(prefix, 0) == 0; +} + +inline bool startswith(const std::string& str, std::initializer_list prefix_list) { + for (auto prefix : prefix_list) { + if (startswith(str, prefix)) return true; + } + return false; +} + +inline bool endswith(const std::string& str, const char* suffix) { + return str.find(suffix, 0) == (str.length() - strlen(suffix)); +} + +inline std::string& trim(std::string& s, const char* t = " \t\n\r\f\v") { + s.erase(s.find_last_not_of(t) + 1); + return s.erase(0, s.find_first_not_of(t)); +} + +ChecksumState* get_checksum(const std::string& dbc_name) { + ChecksumState* s = nullptr; + if (startswith(dbc_name, {"honda_", "acura_"})) { + s = new ChecksumState({4, 2, 3, 5, false, HONDA_CHECKSUM, &honda_checksum}); + } else if (startswith(dbc_name, {"toyota_", "lexus_"})) { + s = new ChecksumState({8, -1, 7, -1, false, TOYOTA_CHECKSUM, &toyota_checksum}); + } else if (startswith(dbc_name, "hyundai_canfd")) { + s = new ChecksumState({16, -1, 0, -1, true, HKG_CAN_FD_CHECKSUM, &hkg_can_fd_checksum}); + } else if (startswith(dbc_name, "vw_mqb_2010")) { + s = new ChecksumState({8, 4, 0, 0, true, VOLKSWAGEN_MQB_CHECKSUM, &volkswagen_mqb_checksum}); + } else if (startswith(dbc_name, "vw_golf_mk4")) { + s = new ChecksumState({8, 4, 0, -1, true, XOR_CHECKSUM, &xor_checksum}); + } else if (startswith(dbc_name, "subaru_global_")) { + s = new ChecksumState({8, -1, 0, -1, true, SUBARU_CHECKSUM, &subaru_checksum}); + } else if (startswith(dbc_name, "chrysler_")) { + s = new ChecksumState({8, -1, 7, -1, false, CHRYSLER_CHECKSUM, &chrysler_checksum}); + } else if (startswith(dbc_name, "comma_body")) { + s = new ChecksumState({8, 4, 7, 3, false, PEDAL_CHECKSUM, &pedal_checksum}); + } + return s; +} + +void set_signal_type(Signal& s, ChecksumState* chk, const std::string& dbc_name, int line_num) { + s.calc_checksum = nullptr; + if (chk) { + if (s.name == "CHECKSUM") { + DBC_ASSERT(chk->checksum_size == -1 || s.size == chk->checksum_size, "CHECKSUM is not " << chk->checksum_size << " bits long"); + DBC_ASSERT(chk->checksum_start_bit == -1 || (s.start_bit % 8) == chk->checksum_start_bit, " CHECKSUM starts at wrong bit"); + DBC_ASSERT(s.is_little_endian == chk->little_endian, "CHECKSUM has wrong endianness"); + DBC_ASSERT(chk->calc_checksum != nullptr, "CHECKSUM calculate function not supplied"); + s.type = chk->checksum_type; + s.calc_checksum = chk->calc_checksum; + } else if (s.name == "COUNTER") { + DBC_ASSERT(chk->counter_size == -1 || s.size == chk->counter_size, "COUNTER is not " << chk->counter_size << " bits long"); + DBC_ASSERT(chk->counter_start_bit == -1 || (s.start_bit % 8) == chk->counter_start_bit, "COUNTER starts at wrong bit"); + DBC_ASSERT(chk->little_endian == s.is_little_endian, "COUNTER has wrong endianness"); + s.type = COUNTER; + } + } + + // TODO: CAN packer/parser shouldn't know anything about interceptors or pedals + if (s.name == "CHECKSUM_PEDAL") { + DBC_ASSERT(s.size == 8, "INTERCEPTOR CHECKSUM is not 8 bits long"); + s.type = PEDAL_CHECKSUM; + } else if (s.name == "COUNTER_PEDAL") { + DBC_ASSERT(s.size == 4, "INTERCEPTOR COUNTER is not 4 bits long"); + s.type = COUNTER; + } +} + +DBC* dbc_parse_from_stream(const std::string &dbc_name, std::istream &stream, ChecksumState *checksum, bool allow_duplicate_msg_name) { + uint32_t address = 0; + std::set address_set; + std::set msg_name_set; + std::map> signal_name_sets; + std::map> signals; + DBC* dbc = new DBC; + dbc->name = dbc_name; + std::setlocale(LC_NUMERIC, "C"); + + // used to find big endian LSB from MSB and size + std::vector be_bits; + for (int i = 0; i < 64; i++) { + for (int j = 7; j >= 0; j--) { + be_bits.push_back(j + i * 8); + } + } + + std::string line; + int line_num = 0; + std::smatch match; + // TODO: see if we can speed up the regex statements in this loop, SG_ is specifically the slowest + while (std::getline(stream, line)) { + line = trim(line); + line_num += 1; + if (startswith(line, "BO_ ")) { + // new group + bool ret = std::regex_match(line, match, bo_regexp); + DBC_ASSERT(ret, "bad BO: " << line); + + Msg& msg = dbc->msgs.emplace_back(); + address = msg.address = std::stoul(match[1].str()); // could be hex + msg.name = match[2].str(); + msg.size = std::stoul(match[3].str()); + + // check for duplicates + DBC_ASSERT(address_set.find(address) == address_set.end(), "Duplicate message address: " << address << " (" << msg.name << ")"); + address_set.insert(address); + + if (!allow_duplicate_msg_name) { + DBC_ASSERT(msg_name_set.find(msg.name) == msg_name_set.end(), "Duplicate message name: " << msg.name); + msg_name_set.insert(msg.name); + } + } else if (startswith(line, "SG_ ")) { + // new signal + int offset = 0; + if (!std::regex_search(line, match, sg_regexp)) { + bool ret = std::regex_search(line, match, sgm_regexp); + DBC_ASSERT(ret, "bad SG: " << line); + offset = 1; + } + Signal& sig = signals[address].emplace_back(); + sig.name = match[1].str(); + sig.start_bit = std::stoi(match[offset + 2].str()); + sig.size = std::stoi(match[offset + 3].str()); + sig.is_little_endian = std::stoi(match[offset + 4].str()) == 1; + sig.is_signed = match[offset + 5].str() == "-"; + sig.factor = std::stod(match[offset + 6].str()); + sig.offset = std::stod(match[offset + 7].str()); + set_signal_type(sig, checksum, dbc_name, line_num); + if (sig.is_little_endian) { + sig.lsb = sig.start_bit; + sig.msb = sig.start_bit + sig.size - 1; + } else { + auto it = find(be_bits.begin(), be_bits.end(), sig.start_bit); + sig.lsb = be_bits[(it - be_bits.begin()) + sig.size - 1]; + sig.msb = sig.start_bit; + } + DBC_ASSERT(sig.lsb < (64 * 8) && sig.msb < (64 * 8), "Signal out of bounds: " << line); + + // Check for duplicate signal names + DBC_ASSERT(signal_name_sets[address].find(sig.name) == signal_name_sets[address].end(), "Duplicate signal name: " << sig.name); + signal_name_sets[address].insert(sig.name); + } else if (startswith(line, "VAL_ ")) { + // new signal value/definition + bool ret = std::regex_search(line, match, val_regexp); + DBC_ASSERT(ret, "bad VAL: " << line); + + auto& val = dbc->vals.emplace_back(); + val.address = std::stoul(match[1].str()); // could be hex + val.name = match[2].str(); + + auto defvals = match[3].str(); + std::sregex_token_iterator it{defvals.begin(), defvals.end(), val_split_regexp, -1}; + // convert strings to UPPER_CASE_WITH_UNDERSCORES + std::vector words{it, {}}; + for (auto& w : words) { + w = trim(w); + std::transform(w.begin(), w.end(), w.begin(), ::toupper); + std::replace(w.begin(), w.end(), ' ', '_'); + } + // join string + std::stringstream s; + std::copy(words.begin(), words.end(), std::ostream_iterator(s, " ")); + val.def_val = s.str(); + val.def_val = trim(val.def_val); + } + } + + for (auto& m : dbc->msgs) { + m.sigs = signals[m.address]; + } + for (auto& v : dbc->vals) { + v.sigs = signals[v.address]; + } + return dbc; +} + +DBC* dbc_parse(const std::string& dbc_path) { + std::ifstream infile(dbc_path); + if (!infile) return nullptr; + + const std::string dbc_name = std::filesystem::path(dbc_path).filename(); + + std::unique_ptr checksum(get_checksum(dbc_name)); + return dbc_parse_from_stream(dbc_name, infile, checksum.get()); +} + +const std::string get_dbc_root_path() { + char *basedir = std::getenv("BASEDIR"); + if (basedir != NULL) { + return std::string(basedir) + "/opendbc"; + } else { + return DBC_FILE_PATH; + } +} + +const DBC* dbc_lookup(const std::string& dbc_name) { + static std::mutex lock; + static std::map dbcs; + + std::string dbc_file_path = dbc_name; + if (!std::filesystem::exists(dbc_file_path)) { + dbc_file_path = get_dbc_root_path() + "/" + dbc_name + ".dbc"; + } + + std::unique_lock lk(lock); + auto it = dbcs.find(dbc_name); + if (it == dbcs.end()) { + it = dbcs.insert(it, {dbc_name, dbc_parse(dbc_file_path)}); + } + return it->second; +} + +std::vector get_dbc_names() { + static const std::string& dbc_file_path = get_dbc_root_path(); + std::vector dbcs; + for (std::filesystem::directory_iterator i(dbc_file_path), end; i != end; i++) { + if (!is_directory(i->path())) { + std::string filename = i->path().filename(); + if (!startswith(filename, "_") && endswith(filename, ".dbc")) { + dbcs.push_back(filename.substr(0, filename.length() - 4)); + } + } + } + return dbcs; +} diff --git a/can/packer.cc b/can/packer.cc new file mode 100644 index 0000000..87fa0a8 --- /dev/null +++ b/can/packer.cc @@ -0,0 +1,98 @@ +#include +#include +#include +#include +#include +#include + +#include "opendbc/can/common.h" + + +void set_value(std::vector &msg, const Signal &sig, int64_t ival) { + int i = sig.lsb / 8; + int bits = sig.size; + if (sig.size < 64) { + ival &= ((1ULL << sig.size) - 1); + } + + while (i >= 0 && i < msg.size() && bits > 0) { + int shift = (int)(sig.lsb / 8) == i ? sig.lsb % 8 : 0; + int size = std::min(bits, 8 - shift); + + msg[i] &= ~(((1ULL << size) - 1) << shift); + msg[i] |= (ival & ((1ULL << size) - 1)) << shift; + + bits -= size; + ival >>= size; + i = sig.is_little_endian ? i+1 : i-1; + } +} + +CANPacker::CANPacker(const std::string& dbc_name) { + dbc = dbc_lookup(dbc_name); + assert(dbc); + + for (const auto& msg : dbc->msgs) { + message_lookup[msg.address] = msg; + for (const auto& sig : msg.sigs) { + signal_lookup[std::make_pair(msg.address, sig.name)] = sig; + } + } + init_crc_lookup_tables(); +} + +std::vector CANPacker::pack(uint32_t address, const std::vector &signals) { + std::vector ret(message_lookup[address].size, 0); + + // set all values for all given signal/value pairs + bool counter_set = false; + for (const auto& sigval : signals) { + auto sig_it = signal_lookup.find(std::make_pair(address, sigval.name)); + if (sig_it == signal_lookup.end()) { + // TODO: do something more here. invalid flag like CANParser? + WARN("undefined signal %s - %d\n", sigval.name.c_str(), address); + continue; + } + const auto &sig = sig_it->second; + + int64_t ival = (int64_t)(round((sigval.value - sig.offset) / sig.factor)); + if (ival < 0) { + ival = (1ULL << sig.size) + ival; + } + set_value(ret, sig, ival); + + counter_set = counter_set || (sigval.name == "COUNTER"); + if (counter_set) { + counters[address] = sigval.value; + } + } + + // set message counter + auto sig_it_counter = signal_lookup.find(std::make_pair(address, "COUNTER")); + if (!counter_set && sig_it_counter != signal_lookup.end()) { + const auto& sig = sig_it_counter->second; + + if (counters.find(address) == counters.end()) { + counters[address] = 0; + } + set_value(ret, sig, counters[address]); + counters[address] = (counters[address] + 1) % (1 << sig.size); + } + + // set message checksum + auto sig_it_checksum = signal_lookup.find(std::make_pair(address, "CHECKSUM")); + if (sig_it_checksum != signal_lookup.end()) { + const auto &sig = sig_it_checksum->second; + if (sig.calc_checksum != nullptr) { + unsigned int checksum = sig.calc_checksum(address, sig, ret); + set_value(ret, sig, checksum); + } + } + + return ret; +} + +// This function has a definition in common.h and is used in PlotJuggler +Msg* CANPacker::lookup_message(uint32_t address) { + return &message_lookup[address]; +} diff --git a/opendbc/can/packer.py b/can/packer.py similarity index 100% rename from opendbc/can/packer.py rename to can/packer.py diff --git a/opendbc/can/packer_pyx.pyx b/can/packer_pyx.pyx similarity index 100% rename from opendbc/can/packer_pyx.pyx rename to can/packer_pyx.pyx diff --git a/can/parser.cc b/can/parser.cc new file mode 100644 index 0000000..3ed9f02 --- /dev/null +++ b/can/parser.cc @@ -0,0 +1,326 @@ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include "cereal/logger/logger.h" +#include "opendbc/can/common.h" + +int64_t get_raw_value(const std::vector &msg, const Signal &sig) { + int64_t ret = 0; + + int i = sig.msb / 8; + int bits = sig.size; + while (i >= 0 && i < msg.size() && bits > 0) { + int lsb = (int)(sig.lsb / 8) == i ? sig.lsb : i*8; + int msb = (int)(sig.msb / 8) == i ? sig.msb : (i+1)*8 - 1; + int size = msb - lsb + 1; + + uint64_t d = (msg[i] >> (lsb - (i*8))) & ((1ULL << size) - 1); + ret |= d << (bits - size); + + bits -= size; + i = sig.is_little_endian ? i-1 : i+1; + } + return ret; +} + + +bool MessageState::parse(uint64_t nanos, const std::vector &dat) { + std::vector tmp_vals(parse_sigs.size()); + bool checksum_failed = false; + bool counter_failed = false; + + for (int i = 0; i < parse_sigs.size(); i++) { + const auto &sig = parse_sigs[i]; + + int64_t tmp = get_raw_value(dat, sig); + if (sig.is_signed) { + tmp -= ((tmp >> (sig.size-1)) & 0x1) ? (1ULL << sig.size) : 0; + } + + //DEBUG("parse 0x%X %s -> %ld\n", address, sig.name, tmp); + + if (!ignore_checksum) { + if (sig.calc_checksum != nullptr && sig.calc_checksum(address, sig, dat) != tmp) { + checksum_failed = true; + } + } + + if (!ignore_counter) { + if (sig.type == SignalType::COUNTER && !update_counter_generic(tmp, sig.size)) { + counter_failed = true; + } + } + + tmp_vals[i] = tmp * sig.factor + sig.offset; + } + + // only update values if both checksum and counter are valid + if (checksum_failed || counter_failed) { + LOGE("0x%X message checks failed, checksum failed %d, counter failed %d", address, checksum_failed, counter_failed); + return false; + } + + for (int i = 0; i < parse_sigs.size(); i++) { + vals[i] = tmp_vals[i]; + all_vals[i].push_back(vals[i]); + } + last_seen_nanos = nanos; + + return true; +} + + +bool MessageState::update_counter_generic(int64_t v, int cnt_size) { + if (((counter + 1) & ((1 << cnt_size) -1)) != v) { + counter_fail = std::min(counter_fail + 1, MAX_BAD_COUNTER); + if (counter_fail > 1) { + INFO("0x%X COUNTER FAIL #%d -- %d -> %d\n", address, counter_fail, counter, (int)v); + } + } else if (counter_fail > 0) { + counter_fail--; + } + counter = v; + return counter_fail < MAX_BAD_COUNTER; +} + + +CANParser::CANParser(int abus, const std::string& dbc_name, const std::vector> &messages) + : bus(abus), aligned_buf(kj::heapArray(1024)) { + dbc = dbc_lookup(dbc_name); + assert(dbc); + init_crc_lookup_tables(); + + bus_timeout_threshold = std::numeric_limits::max(); + + for (const auto& [address, frequency] : messages) { + // disallow duplicate message checks + if (message_states.find(address) != message_states.end()) { + std::stringstream is; + is << "Duplicate Message Check: " << address; + throw std::runtime_error(is.str()); + } + + MessageState &state = message_states[address]; + state.address = address; + // state.check_frequency = op.check_frequency, + + // msg is not valid if a message isn't received for 10 consecutive steps + if (frequency > 0) { + state.check_threshold = (1000000000ULL / frequency) * 10; + + // bus timeout threshold should be 10x the fastest msg + bus_timeout_threshold = std::min(bus_timeout_threshold, state.check_threshold); + } + + const Msg* msg = NULL; + for (const auto& m : dbc->msgs) { + if (m.address == address) { + msg = &m; + break; + } + } + if (!msg) { + fprintf(stderr, "CANParser: could not find message 0x%X in DBC %s\n", address, dbc_name.c_str()); + assert(false); + } + + state.name = msg->name; + state.size = msg->size; + assert(state.size <= 64); // max signal size is 64 bytes + + // track all signals for this message + state.parse_sigs = msg->sigs; + state.vals.resize(msg->sigs.size()); + state.all_vals.resize(msg->sigs.size()); + } +} + +CANParser::CANParser(int abus, const std::string& dbc_name, bool ignore_checksum, bool ignore_counter) + : bus(abus) { + // Add all messages and signals + + dbc = dbc_lookup(dbc_name); + assert(dbc); + init_crc_lookup_tables(); + + for (const auto& msg : dbc->msgs) { + MessageState state = { + .name = msg.name, + .address = msg.address, + .size = msg.size, + .ignore_checksum = ignore_checksum, + .ignore_counter = ignore_counter, + }; + + for (const auto& sig : msg.sigs) { + state.parse_sigs.push_back(sig); + state.vals.push_back(0); + state.all_vals.push_back({}); + } + + message_states[state.address] = state; + } +} + +#ifndef DYNAMIC_CAPNP +void CANParser::update_string(const std::string &data, bool sendcan) { + // format for board, make copy due to alignment issues. + const size_t buf_size = (data.length() / sizeof(capnp::word)) + 1; + if (aligned_buf.size() < buf_size) { + aligned_buf = kj::heapArray(buf_size); + } + memcpy(aligned_buf.begin(), data.data(), data.length()); + + // extract the messages + capnp::FlatArrayMessageReader cmsg(aligned_buf.slice(0, buf_size)); + cereal::Event::Reader event = cmsg.getRoot(); + + if (first_nanos == 0) { + first_nanos = event.getLogMonoTime(); + } + last_nanos = event.getLogMonoTime(); + + auto cans = sendcan ? event.getSendcan() : event.getCan(); + UpdateCans(last_nanos, cans); + + UpdateValid(last_nanos); +} + +void CANParser::update_strings(const std::vector &data, std::vector &vals, bool sendcan) { + uint64_t current_nanos = 0; + for (const auto &d : data) { + update_string(d, sendcan); + if (current_nanos == 0) { + current_nanos = last_nanos; + } + } + query_latest(vals, current_nanos); +} + +void CANParser::UpdateCans(uint64_t nanos, const capnp::List::Reader& cans) { + //DEBUG("got %d messages\n", cans.size()); + + bool bus_empty = true; + + // parse the messages + for (const auto cmsg : cans) { + if (cmsg.getSrc() != bus) { + // DEBUG("skip %d: wrong bus\n", cmsg.getAddress()); + continue; + } + bus_empty = false; + + auto state_it = message_states.find(cmsg.getAddress()); + if (state_it == message_states.end()) { + // DEBUG("skip %d: not specified\n", cmsg.getAddress()); + continue; + } + + auto dat = cmsg.getDat(); + + if (dat.size() > 64) { + DEBUG("got message longer than 64 bytes: 0x%X %zu\n", cmsg.getAddress(), dat.size()); + continue; + } + + // TODO: this actually triggers for some cars. fix and enable this + //if (dat.size() != state_it->second.size) { + // DEBUG("got message with unexpected length: expected %d, got %zu for %d", state_it->second.size, dat.size(), cmsg.getAddress()); + // continue; + //} + + std::vector data(dat.size(), 0); + memcpy(data.data(), dat.begin(), dat.size()); + state_it->second.parse(nanos, data); + } + + // update bus timeout + if (!bus_empty) { + last_nonempty_nanos = nanos; + } + bus_timeout = (nanos - last_nonempty_nanos) > bus_timeout_threshold; +} +#endif + +void CANParser::UpdateCans(uint64_t nanos, const capnp::DynamicStruct::Reader& cmsg) { + // assume message struct is `cereal::CanData` and parse + assert(cmsg.has("address") && cmsg.has("src") && cmsg.has("dat") && cmsg.has("busTime")); + + if (cmsg.get("src").as() != bus) { + DEBUG("skip %d: wrong bus\n", cmsg.get("address").as()); + return; + } + + auto state_it = message_states.find(cmsg.get("address").as()); + if (state_it == message_states.end()) { + DEBUG("skip %d: not specified\n", cmsg.get("address").as()); + return; + } + + auto dat = cmsg.get("dat").as(); + if (dat.size() > 64) return; // shouldn't ever happen + std::vector data(dat.size(), 0); + memcpy(data.data(), dat.begin(), dat.size()); + state_it->second.parse(nanos, data); +} + +void CANParser::UpdateValid(uint64_t nanos) { + const bool show_missing = (last_nanos - first_nanos) > 8e9; + + bool _valid = true; + bool _counters_valid = true; + for (const auto& kv : message_states) { + const auto& state = kv.second; + + if (state.counter_fail >= MAX_BAD_COUNTER) { + _counters_valid = false; + } + + const bool missing = state.last_seen_nanos == 0; + const bool timed_out = (nanos - state.last_seen_nanos) > state.check_threshold; + if (state.check_threshold > 0 && (missing || timed_out)) { + if (show_missing && !bus_timeout) { + if (missing) { + LOGE("0x%X '%s' NOT SEEN", state.address, state.name.c_str()); + } else if (timed_out) { + LOGE("0x%X '%s' TIMED OUT", state.address, state.name.c_str()); + } + } + _valid = false; + } + } + can_invalid_cnt = _valid ? 0 : (can_invalid_cnt + 1); + can_valid = (can_invalid_cnt < CAN_INVALID_CNT) && _counters_valid; +} + +void CANParser::query_latest(std::vector &vals, uint64_t last_ts) { + if (last_ts == 0) { + last_ts = last_nanos; + } + for (auto& kv : message_states) { + auto& state = kv.second; + if (last_ts != 0 && state.last_seen_nanos < last_ts) { + continue; + } + + for (int i = 0; i < state.parse_sigs.size(); i++) { + const Signal &sig = state.parse_sigs[i]; + SignalValue &v = vals.emplace_back(); + v.address = state.address; + v.ts_nanos = state.last_seen_nanos; + v.name = sig.name; + v.value = state.vals[i]; + v.all_values = state.all_vals[i]; + state.all_vals[i].clear(); + } + } +} diff --git a/opendbc/can/parser.py b/can/parser.py similarity index 100% rename from opendbc/can/parser.py rename to can/parser.py diff --git a/opendbc/can/parser_pyx.pyx b/can/parser_pyx.pyx similarity index 100% rename from opendbc/can/parser_pyx.pyx rename to can/parser_pyx.pyx diff --git a/can/tests/.gitignore b/can/tests/.gitignore new file mode 100644 index 0000000..192fb09 --- /dev/null +++ b/can/tests/.gitignore @@ -0,0 +1 @@ +*.bz2 diff --git a/can/tests/__init__.py b/can/tests/__init__.py new file mode 100644 index 0000000..3bf02fd --- /dev/null +++ b/can/tests/__init__.py @@ -0,0 +1,8 @@ +import glob +import os + +from opendbc import DBC_PATH + +ALL_DBCS = [os.path.basename(dbc).split('.')[0] for dbc in + glob.glob(f"{DBC_PATH}/*.dbc")] +TEST_DBC = os.path.abspath(os.path.join(os.path.dirname(__file__), "test.dbc")) diff --git a/can/tests/test.dbc b/can/tests/test.dbc new file mode 100644 index 0000000..05104fb --- /dev/null +++ b/can/tests/test.dbc @@ -0,0 +1,27 @@ +CM_ "This DBC is used for the CAN parser and packer tests."; + +BO_ 228 STEERING_CONTROL: 5 EON + SG_ STEER_TORQUE_REQUEST : 23|1@0+ (1,0) [0|1] "" EPS + SG_ SET_ME_X00 : 22|7@0+ (1,0) [0|127] "" EPS + SG_ SET_ME_X00_2 : 31|8@0+ (1,0) [0|0] "" EPS + SG_ STEER_TORQUE : 7|16@0- (1,0) [-4096|4096] "" EPS + SG_ STEER_DOWN_TO_ZERO : 38|1@0+ (1,0) [0|1] "" EPS + SG_ COUNTER : 37|2@0+ (1,0) [0|3] "" EPS + SG_ CHECKSUM : 35|4@0+ (1,0) [0|15] "" EPS + +BO_ 316 Brake_Status: 8 XXX + SG_ CHECKSUM : 0|8@1+ (1,0) [0|255] "" XXX + SG_ COUNTER : 8|4@1+ (1,0) [0|15] "" XXX + SG_ Signal1 : 12|46@1+ (1,0) [0|1] "" XXX + SG_ ES_Brake : 58|1@1+ (1,0) [0|1] "" XXX + SG_ Signal2 : 59|3@1+ (1,0) [0|1] "" XXX + SG_ Brake : 62|1@1+ (1,0) [0|1] "" XXX + SG_ Signal3 : 63|1@1+ (1,0) [0|1] "" XXX + +BO_ 245 CAN_FD_MESSAGE: 32 XXX + SG_ COUNTER : 7|8@0+ (1,0) [0|1] "" XXX + SG_ SIGNED : 22|16@0- (1,0) [0|1] "" XXX + SG_ 64_BIT_LE : 159|64@1+ (1,0) [0|1] "" XXX + SG_ 64_BIT_BE : 80|64@0+ (1,0) [0|1] "" XXX + +VAL_ 80 NON_EXISTENT_ADDR 0 "test"; diff --git a/can/tests/test_checksums.py b/can/tests/test_checksums.py new file mode 100644 index 0000000..93ddbe0 --- /dev/null +++ b/can/tests/test_checksums.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +import unittest + +from opendbc.can.parser import CANParser +from opendbc.can.packer import CANPacker +from opendbc.can.tests.test_packer_parser import can_list_to_can_capnp + + +class TestCanChecksums(unittest.TestCase): + + def test_honda_checksum(self): + """Test checksums for Honda standard and extended CAN ids""" + dbc_file = "honda_accord_2018_can_generated" + msgs = [("LKAS_HUD", 0), ("LKAS_HUD_A", 0)] + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + values = { + 'SET_ME_X41': 0x41, + 'STEERING_REQUIRED': 1, + 'SOLID_LANES': 1, + 'BEEP': 0, + } + + # known correct checksums according to the above values + checksum_std = [11, 10, 9, 8] + checksum_ext = [4, 3, 2, 1] + + for std, ext in zip(checksum_std, checksum_ext): + msgs = [ + packer.make_can_msg("LKAS_HUD", 0, values), + packer.make_can_msg("LKAS_HUD_A", 0, values), + ] + can_strings = [can_list_to_can_capnp(msgs), ] + parser.update_strings(can_strings) + + self.assertEqual(parser.vl['LKAS_HUD']['CHECKSUM'], std) + self.assertEqual(parser.vl['LKAS_HUD_A']['CHECKSUM'], ext) + + +if __name__ == "__main__": + unittest.main() diff --git a/can/tests/test_dbc_exceptions.py b/can/tests/test_dbc_exceptions.py new file mode 100644 index 0000000..1f13f53 --- /dev/null +++ b/can/tests/test_dbc_exceptions.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 + +import unittest + +from opendbc.can.parser import CANParser, CANDefine +from opendbc.can.packer import CANPacker +from opendbc.can.tests import TEST_DBC + + +class TestCanParserPackerExceptions(unittest.TestCase): + def test_civic_exceptions(self): + dbc_file = "honda_civic_touring_2016_can_generated" + dbc_invalid = dbc_file + "abcdef" + msgs = [("STEERING_CONTROL", 50)] + with self.assertRaises(RuntimeError): + CANParser(dbc_invalid, msgs, 0) + with self.assertRaises(RuntimeError): + CANPacker(dbc_invalid) + with self.assertRaises(RuntimeError): + CANDefine(dbc_invalid) + with self.assertRaises(KeyError): + CANDefine(TEST_DBC) + + parser = CANParser(dbc_file, msgs, 0) + with self.assertRaises(RuntimeError): + parser.update_strings([b'']) + + # Everything is supposed to work below + CANParser(dbc_file, msgs, 0) + CANParser(dbc_file, [], 0) + CANPacker(dbc_file) + CANDefine(dbc_file) + + +if __name__ == "__main__": + unittest.main() diff --git a/can/tests/test_dbc_parser.py b/can/tests/test_dbc_parser.py new file mode 100644 index 0000000..5da41d4 --- /dev/null +++ b/can/tests/test_dbc_parser.py @@ -0,0 +1,28 @@ +#!/usr/bin/env python3 +import unittest + +from opendbc.can.parser import CANParser +from opendbc.can.tests import ALL_DBCS + + +class TestDBCParser(unittest.TestCase): + def test_enough_dbcs(self): + # sanity check that we're running on the real DBCs + self.assertGreater(len(ALL_DBCS), 20) + + def test_parse_all_dbcs(self): + """ + Dynamic DBC parser checks: + - Checksum and counter length, start bit, endianness + - Duplicate message addresses and names + - Signal out of bounds + - All BO_, SG_, VAL_ lines for syntax errors + """ + + for dbc in ALL_DBCS: + with self.subTest(dbc=dbc): + CANParser(dbc, [], 0) + + +if __name__ == "__main__": + unittest.main() diff --git a/can/tests/test_define.py b/can/tests/test_define.py new file mode 100644 index 0000000..6387ef9 --- /dev/null +++ b/can/tests/test_define.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +import unittest + +from opendbc.can.can_define import CANDefine +from opendbc.can.tests import ALL_DBCS + + +class TestCADNDefine(unittest.TestCase): + def test_civic(self): + + dbc_file = "honda_civic_touring_2016_can_generated" + defs = CANDefine(dbc_file) + + self.assertDictEqual(defs.dv[399], defs.dv['STEER_STATUS']) + self.assertDictEqual(defs.dv[399], + {'STEER_STATUS': + {7: 'PERMANENT_FAULT', + 6: 'TMP_FAULT', + 5: 'FAULT_1', + 4: 'NO_TORQUE_ALERT_2', + 3: 'LOW_SPEED_LOCKOUT', + 2: 'NO_TORQUE_ALERT_1', + 0: 'NORMAL'} + } + ) + + def test_all_dbcs(self): + # Asserts no exceptions on all DBCs + for dbc in ALL_DBCS: + with self.subTest(dbc=dbc): + CANDefine(dbc) + + +if __name__ == "__main__": + unittest.main() diff --git a/can/tests/test_packer_parser.py b/can/tests/test_packer_parser.py new file mode 100644 index 0000000..8c3653a --- /dev/null +++ b/can/tests/test_packer_parser.py @@ -0,0 +1,386 @@ +#!/usr/bin/env python3 +import unittest +import random + +import cereal.messaging as messaging +from opendbc.can.parser import CANParser +from opendbc.can.packer import CANPacker +from opendbc.can.tests import TEST_DBC + +MAX_BAD_COUNTER = 5 + + +# Python implementation so we don't have to depend on boardd +def can_list_to_can_capnp(can_msgs, msgtype='can', logMonoTime=None): + dat = messaging.new_message(msgtype, len(can_msgs)) + + if logMonoTime is not None: + dat.logMonoTime = logMonoTime + + for i, can_msg in enumerate(can_msgs): + if msgtype == 'sendcan': + cc = dat.sendcan[i] + else: + cc = dat.can[i] + + cc.address = can_msg[0] + cc.busTime = can_msg[1] + cc.dat = bytes(can_msg[2]) + cc.src = can_msg[3] + + return dat.to_bytes() + + +class TestCanParserPacker(unittest.TestCase): + def test_packer(self): + packer = CANPacker(TEST_DBC) + + for b in range(6): + for i in range(256): + values = {"COUNTER": i} + addr, _, dat, bus = packer.make_can_msg("CAN_FD_MESSAGE", b, values) + self.assertEqual(addr, 245) + self.assertEqual(bus, b) + self.assertEqual(dat[0], i) + + def test_packer_counter(self): + msgs = [("CAN_FD_MESSAGE", 0), ] + packer = CANPacker(TEST_DBC) + parser = CANParser(TEST_DBC, msgs, 0) + + # packer should increment the counter + for i in range(1000): + msg = packer.make_can_msg("CAN_FD_MESSAGE", 0, {}) + dat = can_list_to_can_capnp([msg, ]) + parser.update_strings([dat]) + self.assertEqual(parser.vl["CAN_FD_MESSAGE"]["COUNTER"], i % 256) + + # setting COUNTER should override + for _ in range(100): + cnt = random.randint(0, 255) + msg = packer.make_can_msg("CAN_FD_MESSAGE", 0, { + "COUNTER": cnt, + }) + dat = can_list_to_can_capnp([msg, ]) + parser.update_strings([dat]) + self.assertEqual(parser.vl["CAN_FD_MESSAGE"]["COUNTER"], cnt) + + # then, should resume counting from the override value + cnt = parser.vl["CAN_FD_MESSAGE"]["COUNTER"] + for i in range(100): + msg = packer.make_can_msg("CAN_FD_MESSAGE", 0, {}) + dat = can_list_to_can_capnp([msg, ]) + parser.update_strings([dat]) + self.assertEqual(parser.vl["CAN_FD_MESSAGE"]["COUNTER"], (cnt + i) % 256) + + def test_parser_can_valid(self): + msgs = [("CAN_FD_MESSAGE", 10), ] + packer = CANPacker(TEST_DBC) + parser = CANParser(TEST_DBC, msgs, 0) + + # shouldn't be valid initially + self.assertFalse(parser.can_valid) + + # not valid until the message is seen + for _ in range(100): + dat = can_list_to_can_capnp([]) + parser.update_strings([dat]) + self.assertFalse(parser.can_valid) + + # valid once seen + for i in range(1, 100): + t = int(0.01 * i * 1e9) + msg = packer.make_can_msg("CAN_FD_MESSAGE", 0, {}) + dat = can_list_to_can_capnp([msg, ], logMonoTime=t) + parser.update_strings([dat]) + self.assertTrue(parser.can_valid) + + def test_parser_counter_can_valid(self): + """ + Tests number of allowed bad counters + ensures CAN stays invalid + while receiving invalid messages + that we can recover + """ + msgs = [ + ("STEERING_CONTROL", 0), + ] + packer = CANPacker("honda_civic_touring_2016_can_generated") + parser = CANParser("honda_civic_touring_2016_can_generated", msgs, 0) + + msg = packer.make_can_msg("STEERING_CONTROL", 0, {"COUNTER": 0}) + bts = can_list_to_can_capnp([msg]) + + # bad static counter, invalid once it's seen MAX_BAD_COUNTER messages + for idx in range(0x1000): + parser.update_strings([bts]) + self.assertEqual((idx + 1) < MAX_BAD_COUNTER, parser.can_valid) + + # one to recover + msg = packer.make_can_msg("STEERING_CONTROL", 0, {"COUNTER": 1}) + bts = can_list_to_can_capnp([msg]) + parser.update_strings([bts]) + self.assertTrue(parser.can_valid) + + def test_parser_no_partial_update(self): + """ + Ensure that the CANParser doesn't partially update messages with invalid signals (COUNTER/CHECKSUM). + Previously, the signal update loop would only break once it got to one of these invalid signals, + after already updating most/all of the signals. + """ + msgs = [ + ("STEERING_CONTROL", 0), + ] + packer = CANPacker("honda_civic_touring_2016_can_generated") + parser = CANParser("honda_civic_touring_2016_can_generated", msgs, 0) + + def rx_steering_msg(values, bad_checksum=False): + msg = packer.make_can_msg("STEERING_CONTROL", 0, values) + if bad_checksum: + # add 1 to checksum + msg[2] = bytearray(msg[2]) + msg[2][4] = (msg[2][4] & 0xF0) | ((msg[2][4] & 0x0F) + 1) + + bts = can_list_to_can_capnp([msg]) + parser.update_strings([bts]) + + rx_steering_msg({"STEER_TORQUE": 100}, bad_checksum=False) + self.assertEqual(parser.vl["STEERING_CONTROL"]["STEER_TORQUE"], 100) + self.assertEqual(parser.vl_all["STEERING_CONTROL"]["STEER_TORQUE"], [100]) + + for _ in range(5): + rx_steering_msg({"STEER_TORQUE": 200}, bad_checksum=True) + self.assertEqual(parser.vl["STEERING_CONTROL"]["STEER_TORQUE"], 100) + self.assertEqual(parser.vl_all["STEERING_CONTROL"]["STEER_TORQUE"], []) + + # Even if CANParser doesn't update instantaneous vl, make sure it didn't add invalid values to vl_all + rx_steering_msg({"STEER_TORQUE": 300}, bad_checksum=False) + self.assertEqual(parser.vl["STEERING_CONTROL"]["STEER_TORQUE"], 300) + self.assertEqual(parser.vl_all["STEERING_CONTROL"]["STEER_TORQUE"], [300]) + + def test_packer_parser(self): + msgs = [ + ("Brake_Status", 0), + ("CAN_FD_MESSAGE", 0), + ("STEERING_CONTROL", 0), + ] + packer = CANPacker(TEST_DBC) + parser = CANParser(TEST_DBC, msgs, 0) + + for steer in range(-256, 255): + for active in (1, 0): + values = { + "STEERING_CONTROL": { + "STEER_TORQUE": steer, + "STEER_TORQUE_REQUEST": active, + }, + "Brake_Status": { + "Signal1": 61042322657536.0, + }, + "CAN_FD_MESSAGE": { + "SIGNED": steer, + "64_BIT_LE": random.randint(0, 100), + "64_BIT_BE": random.randint(0, 100), + }, + } + + msgs = [packer.make_can_msg(k, 0, v) for k, v in values.items()] + bts = can_list_to_can_capnp(msgs) + parser.update_strings([bts]) + + for k, v in values.items(): + for key, val in v.items(): + self.assertAlmostEqual(parser.vl[k][key], val) + + # also check address + for sig in ("STEER_TORQUE", "STEER_TORQUE_REQUEST", "COUNTER", "CHECKSUM"): + self.assertEqual(parser.vl["STEERING_CONTROL"][sig], parser.vl[228][sig]) + + def test_scale_offset(self): + """Test that both scale and offset are correctly preserved""" + dbc_file = "honda_civic_touring_2016_can_generated" + msgs = [("VSA_STATUS", 50)] + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + for brake in range(100): + values = {"USER_BRAKE": brake} + msgs = packer.make_can_msg("VSA_STATUS", 0, values) + bts = can_list_to_can_capnp([msgs]) + + parser.update_strings([bts]) + + self.assertAlmostEqual(parser.vl["VSA_STATUS"]["USER_BRAKE"], brake) + + def test_subaru(self): + # Subaru is little endian + + dbc_file = "subaru_global_2017_generated" + + msgs = [("ES_LKAS", 50)] + + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + idx = 0 + for steer in range(-256, 255): + for active in [1, 0]: + values = { + "LKAS_Output": steer, + "LKAS_Request": active, + "SET_1": 1 + } + + msgs = packer.make_can_msg("ES_LKAS", 0, values) + bts = can_list_to_can_capnp([msgs]) + parser.update_strings([bts]) + + self.assertAlmostEqual(parser.vl["ES_LKAS"]["LKAS_Output"], steer) + self.assertAlmostEqual(parser.vl["ES_LKAS"]["LKAS_Request"], active) + self.assertAlmostEqual(parser.vl["ES_LKAS"]["SET_1"], 1) + self.assertAlmostEqual(parser.vl["ES_LKAS"]["COUNTER"], idx % 16) + idx += 1 + + def test_bus_timeout(self): + """Test CAN bus timeout detection""" + dbc_file = "honda_civic_touring_2016_can_generated" + + freq = 100 + msgs = [("VSA_STATUS", freq), ("STEER_MOTOR_TORQUE", freq/2)] + + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + i = 0 + def send_msg(blank=False): + nonlocal i + i += 1 + t = i*((1 / freq) * 1e9) + + if blank: + msgs = [] + else: + msgs = [packer.make_can_msg("VSA_STATUS", 0, {}), ] + + can = can_list_to_can_capnp(msgs, logMonoTime=t) + parser.update_strings([can, ]) + + # all good, no timeout + for _ in range(1000): + send_msg() + self.assertFalse(parser.bus_timeout, str(_)) + + # timeout after 10 blank msgs + for n in range(200): + send_msg(blank=True) + self.assertEqual(n >= 10, parser.bus_timeout) + + # no timeout immediately after seen again + send_msg() + self.assertFalse(parser.bus_timeout) + + def test_updated(self): + """Test updated value dict""" + dbc_file = "honda_civic_touring_2016_can_generated" + msgs = [("VSA_STATUS", 50)] + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + # Make sure nothing is updated + self.assertEqual(len(parser.vl_all["VSA_STATUS"]["USER_BRAKE"]), 0) + + idx = 0 + for _ in range(10): + # Ensure CANParser holds the values of any duplicate messages over multiple frames + user_brake_vals = [random.randrange(100) for _ in range(random.randrange(5, 10))] + half_idx = len(user_brake_vals) // 2 + can_msgs = [[], []] + for frame, brake_vals in enumerate((user_brake_vals[:half_idx], user_brake_vals[half_idx:])): + for user_brake in brake_vals: + values = {"USER_BRAKE": user_brake} + can_msgs[frame].append(packer.make_can_msg("VSA_STATUS", 0, values)) + idx += 1 + + can_strings = [can_list_to_can_capnp(msgs) for msgs in can_msgs] + parser.update_strings(can_strings) + vl_all = parser.vl_all["VSA_STATUS"]["USER_BRAKE"] + + self.assertEqual(vl_all, user_brake_vals) + if len(user_brake_vals): + self.assertEqual(vl_all[-1], parser.vl["VSA_STATUS"]["USER_BRAKE"]) + + def test_timestamp_nanos(self): + """Test message timestamp dict""" + dbc_file = "honda_civic_touring_2016_can_generated" + + msgs = [ + ("VSA_STATUS", 50), + ("POWERTRAIN_DATA", 100), + ] + + parser = CANParser(dbc_file, msgs, 0) + packer = CANPacker(dbc_file) + + # Check the default timestamp is zero + for msg in ("VSA_STATUS", "POWERTRAIN_DATA"): + ts_nanos = parser.ts_nanos[msg].values() + self.assertEqual(set(ts_nanos), {0}) + + # Check: + # - timestamp is only updated for correct messages + # - timestamp is correct for multiple runs + # - timestamp is from the latest message if updating multiple strings + for _ in range(10): + can_strings = [] + log_mono_time = 0 + for i in range(10): + log_mono_time = int(0.01 * i * 1e+9) + can_msg = packer.make_can_msg("VSA_STATUS", 0, {}) + can_strings.append(can_list_to_can_capnp([can_msg], logMonoTime=log_mono_time)) + parser.update_strings(can_strings) + + ts_nanos = parser.ts_nanos["VSA_STATUS"].values() + self.assertEqual(set(ts_nanos), {log_mono_time}) + ts_nanos = parser.ts_nanos["POWERTRAIN_DATA"].values() + self.assertEqual(set(ts_nanos), {0}) + + def test_nonexistent_messages(self): + # Ensure we don't allow messages not in the DBC + existing_messages = ("STEERING_CONTROL", 228, "CAN_FD_MESSAGE", 245) + + for msg in existing_messages: + CANParser(TEST_DBC, [(msg, 0)]) + with self.assertRaises(RuntimeError): + new_msg = msg + "1" if isinstance(msg, str) else msg + 1 + CANParser(TEST_DBC, [(new_msg, 0)]) + + def test_track_all_signals(self): + parser = CANParser("toyota_nodsu_pt_generated", [("ACC_CONTROL", 0)]) + self.assertEqual(parser.vl["ACC_CONTROL"], { + "ACCEL_CMD": 0, + "ALLOW_LONG_PRESS": 0, + "ACC_MALFUNCTION": 0, + "RADAR_DIRTY": 0, + "DISTANCE": 0, + "MINI_CAR": 0, + "ACC_TYPE": 0, + "CANCEL_REQ": 0, + "ACC_CUT_IN": 0, + "LEAD_VEHICLE_STOPPED": 0, + "PERMIT_BRAKING": 0, + "RELEASE_STANDSTILL": 0, + "ITS_CONNECT_LEAD": 0, + "ACCEL_CMD_ALT": 0, + "CHECKSUM": 0, + }) + + def test_disallow_duplicate_messages(self): + CANParser("toyota_nodsu_pt_generated", [("ACC_CONTROL", 5)]) + + with self.assertRaises(RuntimeError): + CANParser("toyota_nodsu_pt_generated", [("ACC_CONTROL", 5), ("ACC_CONTROL", 10)]) + + with self.assertRaises(RuntimeError): + CANParser("toyota_nodsu_pt_generated", [("ACC_CONTROL", 10), ("ACC_CONTROL", 10)]) + + +if __name__ == "__main__": + unittest.main() diff --git a/can/tests/test_parser_performance.py b/can/tests/test_parser_performance.py new file mode 100644 index 0000000..2010fa4 --- /dev/null +++ b/can/tests/test_parser_performance.py @@ -0,0 +1,55 @@ +#!/usr/bin/env python3 +import time +import unittest + +from opendbc.can.parser import CANParser +from opendbc.can.packer import CANPacker +from opendbc.can.tests.test_packer_parser import can_list_to_can_capnp + + +@unittest.skip("TODO: varies too much between machines") +class TestParser(unittest.TestCase): + def _benchmark(self, checks, thresholds, n): + parser = CANParser('toyota_new_mc_pt_generated', checks, 0) + packer = CANPacker('toyota_new_mc_pt_generated') + + can_msgs = [] + for i in range(50000): + values = {"ACC_CONTROL": {"ACC_TYPE": 1, "ALLOW_LONG_PRESS": 3}} + msgs = [packer.make_can_msg(k, 0, v) for k, v in values.items()] + bts = can_list_to_can_capnp(msgs, logMonoTime=int(0.01 * i * 1e9)) + can_msgs.append(bts) + + ets = [] + for _ in range(25): + if n > 1: + strings = [] + for i in range(0, len(can_msgs), n): + strings.append(can_msgs[i:i + n]) + t1 = time.process_time_ns() + for m in strings: + parser.update_strings(m) + t2 = time.process_time_ns() + else: + t1 = time.process_time_ns() + for m in can_msgs: + parser.update_strings([m]) + t2 = time.process_time_ns() + + ets.append(t2 - t1) + + et = sum(ets) / len(ets) + avg_nanos = et / len(can_msgs) + print('%s: [%d] %.1fms to parse %s, avg: %dns' % (self._testMethodName, n, et/1e6, len(can_msgs), avg_nanos)) + + minn, maxx = thresholds + self.assertLess(avg_nanos, maxx) + self.assertGreater(avg_nanos, minn, "Performance seems to have improved, update test thresholds.") + + def test_performance_all_signals(self): + self._benchmark([('ACC_CONTROL', 10)], (10000, 19000), 1) + self._benchmark([('ACC_CONTROL', 10)], (1300, 5000), 10) + + +if __name__ == "__main__": + unittest.main() diff --git a/opendbc/can/libdbc.so b/opendbc/can/libdbc.so deleted file mode 100755 index e7e8517ef164915fc3865da040c66ab8a460a2a2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6648072 zcmeEv349Yp`~Om|f~e(CQBlij5rrhZL9`sfmU6_lVpTLv)3gnwO-NHHDq0Y=DnbPm z@GPF3TJXY?a%oY(qJa2B}gyMk&FNiaSq3yN*g${ zP)$iypZgGmY}+OKNM-9b>v}~U+|jGLcXy>r_UvB6Tc>=}QHg9bDJJs%G^H}^>hM-=l(?kw zei1t&j7v*0>cReER4edT9Fb*p`-Lo201H>*`yWJF|ED_wZxx$~dyue3XFR?n)Q z?NUs$hg}+GZJphvG%2F0YdfWF((naJL|9m_)?g1^!iQy6w~J81MufF74}0!iI9R~NGt?N4nz$j)gk!8xT@Uo=v%+v3wNShTN-nuGkR=6_kyza{U zU)6oi($bDfd6$k##Binmp5=qawSE7!9m5{Z|3>-K_{*?v z^Y4oKrhT`*FNP_tB9pJm=-Kmu>efm9Qc5FB+eEeRQ#vqwc=>r*ZHJW`+dR-piEP&@ zs=ac((ylbAO`FsERCInNswyNX6PVILnBbDmiQ4u|Rg(a;GQ@Xoc%0{IuvfGVHnWAh+ zd9flT{QjP87lxa@d0y!|OzEOTB(=+p=y}n5_TLYVOb(k_-O5n4Hlj`2PRo?AzB9{{ zE@>0lme~S3*5e5nD#|7Zn<2adp&G(g2-_j-gzzB*c6@{Hld<4Q#2!BEN8^XU3gxd;(LeLsQ8wlYLIzc!c z!Wj_GgwPd2HwfoI5Jz{oJ{Q9Igk1pV3n4^8=uKE3I*Vu6ISR1;5H6v6m%&*FK~KL8 zbOyszV(2;!&hd0Tn9f7sJd~~(-z({QIGl|TQXq_mFa`oU#?qNxkAv&+(r*)7UoHJk zqw91yXF#|X!gUa?hj0Ugn;@7WSRk+?8_qcpav|hF$cNzXm<)IU1Q&!UMB}D&5uA(Z zdMcc!L%0RP?GQ>KsE?U|%_4j@o$rM6-4Mzk+ymiW2=gHAZ=~?B2U@T@7I? zg!dr44`Dk5aqOV$58zxQ;XC2_LkJ%cwujCi!}&iD_Cfd*!e!=cKr=p ze+%KDgnbX!KSKB~gr5mN4CmkI`gb@VfpC<5{|V>6A^bzX8DD-t{m=?RYY6OU1LyV- zSiQlHj&ME=LMI4kLWqFS8A4YGXF)g{LU#z~L%0CKMG$&HU`KB__k++M!X*#}Kw!tE za2^O@5Cj8+Xb7Q{2=gG6LwEp! zI2OY7gY^3$I4_2<1i~W_9)-Y;$Kd=pU9;a$!1YoHPeOPK!qX6*h437N7E z68;Tbe+%ItghLR%hwuZ0|3df)f;fJL>t7)J3gI^hze8ZhA9Own=RfKCFE}5A@Hd2i z7zT~ARuIBiBaQupb6W`E^t%I`PlFIazZp#zxb6y}8-%kUoDJa|2;Cu^3xOTy!TEd$ zJs?~}7~WBop70wQSq+Zffc2H|i{Uy7!T<@ol&+W6?mBch^^M0OK8SqD@a*TuE;{<$ zfQ!d}e0}@JQXctX`_WD-*KMe)8kSbQ`U7R_w|AzFj~g_vq*|B0^QKo9=N$dMqV>ZG zk1zjh^l2AVC2W2uwcDVdhbAx2DysQ*cf<`>>^5I=pZ>>V?e?$Qc+X9HuDoK#bysv< z)idks;!BRT|LV=O2M6f({}DB@aBJ%A|9&(+dPc^kxONki9Pn{?LU>YM*v{^uX%r3ZdFly=Wo8HSIurs>{TVHuQvP4_L n_}ddD>z zqArqA7QMx8|cUZ;f2n_o@XqfBQ=D&fQ-Z{9af6 z^j*m#iWe8G)jhuAt*}80p1x7PYtW#}j~-b3(TauU=BysP%zhuhera;wjK z=aXNDJ@ojo^X|}{z5dU=6?gpJezg9lYddx>J!f72xUG-IruLZg#WRIhT%fN#xTwJS zNA+b-T~c;>%J=<2L46TdfaO5CvH$G2wRQhHJR+sWyB68@>Z?>6H@uMX%R zmwo$(hmH2WmHYSHHug=UC*{Fkvif||YSw{%7rl7IQ&ZdRJjbE3MV9Zo_x`71$c*m` zPP=PphjmA8+?-O7JfnY1#WNp=Er|RhFaN)T$KU#faoA;t9`C%~`K-OS$DBPRKK$EJ z*ZlkQE#-gwu(IFly9Rmg`Kw)Y;jp-<`)^Hnrs#%G)(;l0koMyYyB|*DJ~+ZhT>7N=(hS zu3@c4fB)XFO}i(2n_`_YFlFy``ipj4J7w!tvmQu)XXdftLzFA8T5;#3tq*VAaP?X9 zU$_7C_u)$i?EZaybg!>#dtLq7xAR;#IzPTCIt@;6VEHvo6TXNNS%r@0+7v z|Fb>ruQ?Atn9(P??C_S@drey|y6fiw(Pq#2x1ZnPCHv{wC`c7Rl<*FNYoS6~VZQQ7~cROCHxGJ$M zcei!(ffP93uRC&1RZN?Iv%bpxpxB-N?s&kI54Qi}Uir=|@%yju`}xy_U%&KQ_jbp2 zuAb1*`2EFCcb@26*9ey^l!+H5cHu+}xG%_U!T{i4eYX=k*1WoM_nSvj}# zpZVQ)7j*k3@7-HF{XM8`oPFq!N1pf~x#0Q5rEgyQpG&$aEB{z@!)G@@Tss~df6-YF zjT^jj-FFvvd+qMCB0r6|H+)jj&L>86x&Nu#O9$TJx&M{Kd!~Q0;nO`|CA$Xoo%ZSG zm*47itmmSneK&uSvv_ESV~cJ$r~ea|e%k$)UVS<|apCiycX|HkM}O?PXJ}dOy%6GF z`p?ZrYs~q}w=ci%v)@kNy&=**t9ag9S6;N>Cgq#?t-hTLG{(H2ijQqA%gr15%+!(d zJ?~l$wz>EIJ!h?7VA}t@yYGZYt9lqQXb=N0#z3-o}&Gho%9gn}cd_(!8@N8<2 zzh)|He!BXZ%;dFM&*%$!AA0e&yC1u2^^^NH+|>W`kAKjQJa47>?c0Z~`s>9vcYN`R zZGda}kYT&iUOIb)XX5&2pUwQ~ma%ykKDF^CdyLZdwb)~KEgrw@)j2mz-*@dX=UK13 zf0Oz9Ic>k&dSKa*2fm5=;E|i#pBt0l7+602%L{M(=ik2{=;o*#|5~SRb>}AZm~q{} zN4lGreLUd4!rdR8wK8|l&xZH`AC&A{yTNK6KD5oh59qGDp{(7DYwtY&(*s8aI#TcW zc>6Dz7yLft*fSqKJTv@{>mM1FR($U=*Wdk|;mfwn=(ctL!mwWtw%$7JgYrv?p8I3q z(bUzmHw{^;|HG9Yzvk+Vm#$vkVMc_N^Slls?>U>B<{UJ8OOH`vWY$Z-4z7NACv~87ALaZGG9kyj_nA(|6A6 z{{6i88*3_4@_Hx!@I%_#s*mE`KlHrv*@c(4`TLgvug$sV?L*E_woK|3ckZ#)u|Gcc zYvJ@emaRN*_`SW)9Q>8%^5K17O?|rc^{?JEFTQW-wC%5M_~+ubGw$ynvE+;!>)N-u zuJ^KW>j(aLKsjXCaC+JAk0fMuUi{wruK1svTc3OK!3DX4&U`X1`S~Ruuh@CXm(Sn!r$5(( zExZ56r#rmfZ>x1V{H}|b>%Q}|C*MxE_smO1{~7nwl`lQ=^yeAhtT=Yg5AB{hvU<*o z3vY`^Pyc$~pN~(Oc+b@XA3n6dcGdbf?(CSmvyy!!KWtTiSQq3mj0-G7T^|0AE)?F(WZKtV`@Oz(%=XD! zjxN6Pr`Esx`^vdx>qlm9KX=~C_8AW+CysY!US^&*__;oHkL|yI@6sDyGv~A#_shmF zuJOE?{KSO(?`M6|r^nrWCdR(|&N~$gXZO9}&iurg3kJq7+w#^uJ72is`w884?l|9k zbYJ+)oZ9@!XFPWQ(%+V>*uFEldiM*H`+fMz!hi0I|GZtQv%*wxUCB+I7wvg})dk=8 zzj1l~WZi?NQDe>;a`Oc@{@m62+ZO{Cp5a)2rG3eY9{qb=vFzzLE_4`^tCLq=I%Lb{ zJI=oRk&O#)x%;u}pE=a}wW3>={%iZ}t+(FFh=1jiR~~rwvXZ0gTYo-l-L-W+e;w4Z zOWWm17gs%-x@PQ=j63E%(k=1*a@&)suN}DYyj$jut?XS{`)r$+|NZ>s|sNY}CT}SC6^=&rZXthIT42Tx0pP+v_hiX#A;w)=CGZhIMFFM{DIArFJz8 zo=HbtIkZWo-{SJ6h5qq#=ljPW+UOsjd9#1K%e~Og6p=~i@89-M|J57*@nf(1$KQtG zU4Q9%0mgUz;hS#tk9*qt#|MEPdP#DN%gGw@J2mvS?Fs+Q@M$;L zKc8b7<)w>8{?5?AXKBQHGZfD*!kDD<+ZuLqmqxzFCi>@dw9t>?%w{|NS)l)m#leQ#8uaMveS( zXy{=!*t5TKH*lK&bS>1#m%H!r&u8%v|9rY>$eFH@UXzCY^%{15wTA!6)1ZG=L!Uo` za{QH-JsNyI((v;?L%Je`QA%gMMtM2=P5<$puc7Bd8h#^Nga5S}5ZK4pU+4Qd6sLmueNKXcd!PZFE#9NwMMyk zUqjE4pZJ&m9S#3hprMC#8tIy?p`Uj&>}s4wdhgNj10QMF+f^EJPSoK4w1ywf*O327 z4Si;6@E@ijPr8Pl=V-*+UxUw3jrw|=2K{CYJZ!ChdswN_-X461|N5@BqkleYG~zAP z(A#MmdU&RXfBqMB@sBUi@EapE@^QZgev5|uw`s_~SEJtlQbV3t4Lh&YkY}ofe(uz$ zU-oE}Q-enTYYDW6J4^MnxQu{{Nby5DTW0yEAFH9aYv5VPvIfVK8v48?(Leoq4g6*e zz1^qLZ*6m_fB83QlrO7BeUYJ&-U1E#WTOa?4YUAla}D`-Y2?dGfBDxBB+D=Vb{h6G zOQYR*gGT+bU8CP**RZ!@4LjMR!GEKMpTAIp|KUBXUvrw0^buR(1#^S^FU%#I5s#b@ z#*uJ5DXYFhykaNP<6lL2ei_r}X^O55A}7 zr8IGUInh6N3CVdq@)7A8_anwz_7KL~o#;znMLDakMaq$cUvQYwpRTNHhwJ(J5dPc! z$lt^!o8j1oC*`d75ZAqreDE)UF(s)g81Jx9`USY$apd7t@{;-R}4hFhUmY7{vgYj8d_H=@@4W)q*t~f z|87J-As+FX$54K@PKq6a4kBLlAEfVuu(Bu`@rY}Yem~JK4+ooPXU8qzh?)IVvV{Y12>twL zGU7>Wp#&T*qMs$~XR)vTA11w3sr1&7_+-uZ<@0<2@~_K80omFCc0BhS;;y5J3wxOH zIpU`Mm|pw~>$sr3!Q_vakMwN)7CUOmPWC?ND`!j<(nmUwgIII6N{@IcEiR~KOyC$& zhxV|H*3F9YGGs5>b43aADMxZ8buIB9i}*ysqp5tEu0wnz;j_U(Gx@W|qx@eH{$qc{ ztJq>2IG}mJkDWTiO$&*h(mSOu@!5d%B3-k-AU?Y=Ui^z|K)8SFN&Jb=nMYYY*i}h- z0QFW%@gCbjeBMJ2;e107%XG8wo(S0aa-h{Yo2IAc)-m_OAUOJrQ zBzzJSK&GFniAaAd#rxGv%$JICloQDKk$x}Y$z+EKgm3wS=*ezN2`>b{#Q2wwz<7l` z6}Kb3PUW9l_ayn*f*?4AA9(aL#IwjgV~GFUchF8Mi;=(Z|NB8tO#fLIBA*&ODN&$j zhS%MK^cBSCsb82prz>~2MMa)N_}_Cd-bz|z6h(Zh$#3s#jr2kfpZ|yCr}|OYNv97H zuicID3cKyJh2&AyUw{7>^;0(Aw|qs-MmZn;4f%{BIcv6(ekfkNt0(r3u72!ELJy`X#whT#_YpTyy)XRp1j_eFRlfH< z3+W@5q97n1KW<4yynGbOSxfl&FCku=it!3PfBP%yXCvj~wM2jPF{H2g1o^NvqwM(i zOvH6D7;iY?6>h?(AU#`;%8t+OK>isj{r`F~@n;M5;1Kfs)e~_OTigam6920xdvXyk z|1aVZm<;7?!s}=;SS{h_JcaaGhf$t6_?R*p7_xkcn1T3y;=i;O@fz|=;0F2eH=~v9KLS1ioMt(pTPt>Fq)GP?v;w-OY%LeBbsS;z=Zr@aOl< zLjL9CKf6=BN9Us+D%K#MM+tv=9pW`PO)GAoVn_Yq%5>AjuGSFNhP*h}qF-CIalL3+!5 z9nKBOo?KuGPQdPg;{)do% z)fVJaO7TvGd|~Z@y{h)Wdbr8@n0MLUcn`kSVaJdY!vV}zS#qFt4${PtOUF$C$X}G-i#H>^G8OexMe#1Y1MTVzl|P);i}be ztDZytARa$jy^Xjj7x`zBJzTqo@QsK=^Nb(uD7`LKdiPN~Hc8cvedu)LQ{l#Vml6Nh z@)57O6Ejx$&w;Z@pQ`ruAJoo|nC(k{CA8~UzovrP!wDqk6;zMA$e(m4e9J4O{|T5b zlc0wLvhq^10_7C_m%A=P+_eKOkQB1@aN~)E@HBF1DB&j<1OR1+ssIzeNUX z-3cE}`B?oc@&R|p59|5J-?Rt$h;mx{1>%*ecJDh>kC&62qWnI15a}yELH@#jUbYNz zf74ZK$6bvNusLJiQC)b(@e+AIirMpx*Bc?Y9vM`nPVx=l92vzV;*Je<{&- zCO%ozpB3fev%Arrour3B#Ai30S$U~oFFU{?>K%7F@~;_){8#b2&_BHe@uY_k7kYc2 z=&PtfD)MD^B+^%q-l z#Zn%94bxRR9{D6wygxv`F#l8X3i=;nqohzf)3q7tV~D=*^T@xH`el$E{CJQ03#HWF zt0R2sB8)e39SWiY`Pk8e^kcdNanaw8_!{|FQGJ?^pLU;M zyt?Tqe+ltvQ-OHhA&hq+;b%RA@s|IH_&VbM`}>HS_8=c&KNo{~xnKPo=_`rP{Tqk#W?{OXC<)30c9whuB@=LlqDBlU+2?dJrFHb>v z;3q#uQTxP1_K#A*`wdjj>bCguul@<^DIL{QqC6h%Me@Ia^nHjwbo;pdB&q7JAB4T# zh%rXsV@fK?>ADK#6yp*Tp?+k3wT}F1De;e_c17hQNYCD}W5=PDC{L9U`3pbO4l;=8 zq4rgbP}pHF%Evltw+MT_2p(tlAE}am3Giq6>vAK1q5mw%XvRMx3GrPhjrS%sa#cHa_-|O=f1~!>wZunRf$>HTMgAtjH&DD0B&I@ zCe`@i6{``~^+7(Oe#wUlnx(gt+7IQ#=jcYHuOvSp{Cwg!h$m5dyA#pxq4uFp)jo9I zh3VSx2gW;s=zs2wd?Kmd=|lK)Um~8RlD~30s$FM_A~|nB215U9!LXTqX5EB%KJnMx$I^R_ za!{=Mcs}7( zR39a+#dvqM#T%D;kY2e1aVX~eXafmn`gDDXd|o2_uVu_{oTJpO!E}*2m7e6!Bi}@N z(H^LMisbo&(o1??um$z0Zg0Q(E8~BVJ^X6={+kUG0ZbmZlPfEaeCz716Wg}jG z2F5G;2n0(JFf)Fy1OE7sm+iwh8eps>eqX zK9<^DdsY41UE3&MsN4ZtepG{DFng#|`TspPA+8KZ{VR0JpmeGI^ZC%=WPBo*qJADF z{!)xBcbX61n;}wXT79;&cJSinqzw16mdQm@q#_bc@b>y$aJjmd;kWW?t($^6G zbzm?o-lQ8*@JPz9PFaY%G7w)y_zb9zm>;O2_T;aW-b!jeR8jk(JMnk*A^ud3;3q#? zf#YKF>MD?dNbh9Qe}qc^Tgm??sqlQ#v)cdM@*(ms-Hqub^HjbD!C1WI)NdV0@;rPL z{gsQ_;lf{KQ~#oFJ1TxL(JusjFg-+)KLoM)aW9l#R=+$;^L)bUvoHt_|X| ziT|e$B5vA@dK3Nbhe>Zo$PWv>&32$XS=4c)=`m%>T*OO1Lpk?Ty3Scgdd|TJt0-R{ zvmkv$HWG#t{XWu9Z88G8P%NeFLZq*y@i$@TpTGsP^C}v@-Aw##WvHL(!x(Q7>0#Io zq_3m=N+LX!>M6C}?t#Zy`_@E$M#MW|I`T0sLIH&zeyEPo!#J2~-gz|TSGg*`k|q(K zS(x7aB+utxBVMYqpIhySmzVm|-$(hV+lcb?Abl3aBYhRM6DmkQ2cMyMe?ofEPdRh| z@g!Bd^b2Z7MbLO7xKn;?_z3AEs!-3}2)~N_4}TdRu#toxIfDABqjFtJc!w{D5Baft z!k?Rm`FIhvV<}n6?8}h8E*0fZqI5m_Bl0g(jZ=Lo;-z{}#QWkVw9oQeQGU@*OCkGt zoW@TeIsAxi%lLO!Tq=9$F#+YNjYWAxJNz{p;rF5BVqWIo9KzYg1aN%C|H2*=2{Fr%*|`|O0U^4l+%UxQTZK-{FCtidRcLZ^Mue_{1Y)~5&v zzuM+kh-1Ug0NyB|opDbr&%dZ`>A4SCy*`NA?mv2nsmoPx&kKwh0o* z{KhiXe9F0xB7OM|j91uCJF1Ud)L#~QJ3@LWpN8~QZ78z`As?Lq^YIwz;g5AFXYDwY zb1}(T{s+oaM}Dl7@bE{FPt8u`-;Ma(PxceJ0r?2M4FH9(^d?P0dNGbS{eHwF-$8j2 z@V2sUAkp8Afau??68$VHzX>GIUo<{hLlY??U3XEsN-164iN4Eb|M{|fC&f$cXCZ$W z;gPEKJcFoxuI~SSM*i6~6VoO9`FVs_-j2A)uRG2qJv@W>NRsp3ml3ZViTV`%tb~V9 ze$#r?Pc1&CthgBIBc4KB*!l8v5HF{BCBZ*+6Y?p29Qlj-dc`W@(+}|;l)q!h&+Ev~ ze?@Zc2LopLTbG0Jius8C-yEwlQM+*r#T)Y(%3neAP@M>W!49rdQ9{mxg%xCgdaf-36rQ zEVlU#9D@Jm$B;f^H}WYV{?Q;FtH+a6_4pN3-s`A-6n2;iY?=ORkC8mY$0+=ON^k97 z#CU5*p&mqkXSf4#(g&qYi0dv!`b^?K$s;|2e zA2tlg^qi&AbNT}0qk9kaSwr+ADIZl&)_{ zZ*|nJ5bg7cN0@%PDv_#rfz|h+-V#V}#9kSih4EI6!FXMCqx@aOYgOYvPf+`z;sZ>t zC>IZJ#&oI2m!7y9`DFD#`bUZXw-&_t#$b>p>V7B-wj-ZfmA}gS1nG63p&mrOq`i*x zbvDFxq#sK;+Rr*_ZwozNGY9pMsnWxM^~66P`79$jcRY@G#lwkDAv2CcIDwRGXC||1Brc`hUzsI@{Y<{P7Z99%f^1pzM#CR)~A-%BAQI{j` zT7bA{pFF$gGgUP>z{@H=?i*beyoDpUExGuY9f3iGX9G2fxwp0C&eNz>RE9#a8( z5tgDnF4g+IYpDNnF7;o|CjL>e$cJzI1y~)W>&S0tw}YrX1Igz{-gQVHX-EACdEO@e z$H-4c6MZr$mdRhc9VHa)iisl#Uygi0jr>@%gK*WjldCh~G*4PX^ySOYt|ArUPl|YO zFXCA=-YE3!d>Z*g{D|@1N_@V%7V#=-u#0k3Qi}S_Qt9*YZ;)Q6vj46iKlA50)i~!7 z@*7F}P{1P;Z|5@9^APe6F@(QQ{Yt(;9bjJ(elxXyDyaQ0=yye-JQdet238RLJ(Mre zG%qRg{V~el{bUc2e12@TBA?Phs2|b4PFjxXDnA$He+lX{cErvgdYW$%`Mcsx(oZ4M z3w?eak9f^xC}%aYQTCpRcvd3fBE3T?-z!J^=2y}UNN+MBz7C^N`a%86^k2Rj@iv6N z`zqo!Rs=v@{HXgF@rV+{%L%_B1NpmHg9MJ3$PaAELcH=WlvDUg1GV!@shwZRpMpI? z$qp;0BmWY@&s>D@s^_z252bhqA^(LGuktYBbswTUKMnA{Q2qND7b&44J1W-^2fPYE-p}wkFoIyp1*&gJYz_H=7$)rbi#OrUwUCa;+3nA zem}{R|09#9tCC6Mbs!l(Zukq!d!%X}!2=G5$*H4pq;R7D7czq36>np_BHw?Yc1tC- zTP`K~0j(7~^ zmkSck@bdPE*Af5r7a`6!9tEri;Y)tPbd{;<*=|&>l?kZNTB5(=OXTCC{!S;tcTu|~ zLglx=yB+x_sr3BE3&_XR2l)&8U-1Xh*O5G>#D5^=ORXwj25mwb5ROHxRlJ1|}c<;%su zhn0&;TDMtBd{$qD^fmV)y%<+N(3NmnXDj?q2Kk>lS_r?F_}_aI(wB}xI~3*gUnrQ& z9$YkjDD1E|)jKu4QDa#oPhU|FUWfQG!gm}Z{+}Q&^xT2k=UL?cbBMleB+0)N<(WhH zfKh|d#0Ag=ogB{Y$Kwl70J zS@IILClwS+Ib#U%e-!zM{*G-OmdCm*^wqc=UvIJs>r{2NX|d0 zyeGYb@iPC*j_ub_x<1AT7vpW%4B4Dl;4Cy3c`R;^*{qmTGRB&7Y;Iegy~ty8XN(=; za2DD!EZGhl-t&LQY%Q^vbM1u|hy7+CyryuPy)eg|W-BT#fS=dvbvfBqv%~3}T8I$iU%&`Q{DaK{Xfnu`dEtx?A4v(Q@nX`tuM{SG1)qAFj^f(t1;GWE-ZFHOfAAyZ)|Cfm%v14zRybIjIcA5Y$YU;q^6tzvno_L=1(d#^*~N2q zxpsHU@QY#Wnk7-Z)mZ?p$Htg6NR+CW=|Qcmt~FahA4M!jQs610aa_9Itk*%k40Y&O zOVMOwhB-aX%-jyMfqEUO*~LS3Tv(LrbQhRiZhL{nJzelK2V8?gRKuWs5kgE{@Sq|} zY&xO@p&_Tk0TrXHqoAT{I!&=qtrgphR#uBPs^&zmmQ%(hLc6RGDqCnILADfv=AmvB zWk1Da9hV-sl+b)Kg6<&$Ml`7xNd{9(=sgBa$t!tN2}=z!Wk{~FSEJE3#RzS*kqwd? zD>pZ@i*vPGoY7FXd%ct>83rB2iv z=K+Nb8p}=${nBmbp8{{STTme=E#`NK4_^%cx(QGWSS&O+CO%yMd zVUjzPjYivISShnW3S-TQ&{RhGQ$P;D8K^g?t(3KejQTiMF+zQA&UO|SK6U*D>7x;%DgVUf|q7~0%! z*6VZTu&yf@LZD4DmkYDb{}Vi3ZrRwyu@<;IMNK|{O}G(y=FSYLLcj7z?L8poEyG5{ z;L3oufOh&gzYzxC0vljC0LGBBsTpQgXyaI`!Qv6Qr8keXO)0jSft8Ihmu#GOP}6Nw zeB)FX8eYhtID!4K7NZq9U>+M(kU2KUJrmqW$I2g4-;!~~bF;O3?0kd+3b)J1o0jTm z9N+@L;{D0yNRJi@_mNCI(pVIz1#Xy-cg!YZ5we2SdMt&WB4M_yy)BxEOgQPuk@bcV zjakXs>l(G7aiqa(M$zu#LXW+`W<~*+F^1wF$=X!h43f0IwLwNTGH{A=8-KB9`EpJc+DVYtFHFEKv9o%%IH#^H_}0>~yhi7|273 zI^F_;zddyYr1r$AE#N7uLDU{^44j%86at>o8a$XnQkVlXPAQ|Zt*pu20xeAJ{7!|@Bi5gj z8kpnxkS@q{yrSp!dvc=pTIb1&{v@RyQ%)_r6Q6n!{YgyyNz8i|H3n$aw2bnDs&{do z^W??dg1H`4x?4EQgO0le(;aLz*TPvIO7tf&^(~z7!KOa&vTo3s&BcXm8X8CQU;&8J zH9ZA~w(f^SQ7*OLeYouWOmNbvB|fQV*V}N)1neI*4)urP9=$( z$i;;z1}-i;qqr&N^kf>ZY*BI3JutRxS4{6O4|>gu;mp_j;SZ zaWE1JWA1EOo^0M=M+t&=v^gEt9>9E-$ChJudE7AL<8oN6z9arI=5eEj1vuD0MlOd2 z^BAXfvf1Ty*sarz1{ySj2>_4VNwa5A#7>F~_9BRDGfq1CvOjS!ah<`lNv=HJrRiD4JgAv6R5DIv?ZblNjKSU~$Sw*La#CJmFb7 zQYU6WPPESI=U$>=rpdRA1n4SF(IbbC0ACAh$%<0gd>M0<Yz~{MYwj!^n zn1SRof_x=ax`)ytCieVl0453j2_>FsggX@^oD(LGTaVGyF9G#aXarc&nNtu?(Guq9 zu|;{zJamvLFaqICmzby@&1985u)ifq@HEtAU{du3RxFW@o?v0=I&S<$MR($&fELkM zvp4TyoG8H7qEHg6I(6m(@0z&!MvW>hm|tS%Unn%BCLd^rPn-M8V6X`+kxk|@c@96h z+~Pu=WRcjI0bhOu#Xxiwz!~byAvX?rf}qK#^V{TuG6wbl&2H!(z@mw17FZJ`mYA76 zmOQM!Tfzhqz5bXvgIJX}Xih%j!jkwF<#;@GJ{8*7Oy{76xWXawzyz`JV&f{ z@ne1`MkaKG#)g^XuV2Elgw;iUvxMIXAVUnSv*b5JL^~>^k`jkaG1mO@FCK50HC^4t zvz1QARXi-rVmXz_d69T4e>aP-_41z%whAl&HN%VyDc>11G!Dhz2ay+al!s2a^It)?d{C zT`0bMA6ymWy68!P^##_E!ipoP80$MA-p2w|qTT@2CSR52F1C7%1vIf0G#l2Hb=&x; z0qZmv3kpJI1&g*|;TkL#10E_>1ehk)5+FCo-YIDYlOpzx9;?^=8RQ zN=^MTVy`3#awV=k{SA%=2IcD4|9YQK#OL8f!-4B6HOmQ|BVKkekQc z`N=8uH^q->1plnzEA^~|;QKQ0Dl)i`B51^jahy{_MAiZ0FTtVF`nr>ot39mp@x7TA z84VAn^3}-Erc1Xyl;VAI6SqaimW* z>c@NiY`_BFyD+Cf{Sym|^M`}0G!J6~SbY6FYxA%LC?t-z@5y98|GPH zcs32DUC@fXByxkTMnUV4YbTY@Psf*JdflaYoaiciC-L+cZ18iBw-3 zd0_s>Q|xlsfQXNdq>nSFuo)E1>Xk*yCO5UL2k!eVn%_$C$Af}pADW@AZOAxqG zVa3>(GZV{-?>5X9z3Fe(E3NEO=L!(ogOI;(y=qy84Ss2K&j;*pk{ z@~w3WER$idgKw5#r6E`E#0b2M9MT&(+`cS1Y=0~ZdzGJUzQy*Ff$mFC+cD6ph!&Iw z_iQmk3%>yRy}`=ULVD+|Ri++TC1Zy@UTlTXNC-(mEhG@LTv(Bk<6Q&SY>ne^kQl3O z9y?f>e0(ew7@ty>>Lbs|w^Sw$8;Lk&EENQ5VM_&$Eo`ava~q)>J*|g_5d~B}^P{7L zA9+r`{WEb+Df0$8_2& z4d#O2zq%a?vr)M4&Em*&n(Z(S7SL9AExB_V%nAD4It}KEVGV8?+sIPv>Sn_CLBvaV z*|@NeKM$+u`DSu_G8mS_rMp-KBTPTEMgmu>pLrKTs!DF6 zc?9f~3_IJY-Z53J;ii_U$32~oZ#57ua5l^cU|0+aFYE``3_i>Rrxe3xe)e3ujW(Z^ z%s6m?cpJ?D<8_6wMcvefwi6tu9DC6uav;q}95*>Aq3}8y+rz$=30hGUjs8krepVbgE~wKvJ1%YU5sdzF72`8QL3sXc0etxHMwW>&vT&bArW({u#Qw4lZ#@Mb~iCAaAa znwbKr2`=XWZvnMTCIk?}@l8VuWJ42aU@q!T{Er7^(8zYV~87E*uve?w^IVGAtK zafOZpe1*uG4+Aa9Y+>zKJ_yJ5T4d{6;$Z=$Ezixqaz=ZYr)2YX+5bi=nf>Ahk=_xT zhRI}~wE~lr8knb|nXwGZ$u07eP5&G6gCoH4Yv{a*HDGMFEh8)m@-xC~<*#-6^%PBw z@1CL`;`pC)6HpcMuZK_pqOsHe$@0UJ^8br3fVBKi`vQ=kjXM_EEN-ZE8uk$a{K5zu zBC@j2o_bl>okje0Cz{LS%X&w!T8q8o?A=xgTuSioZ^6n^wmlYm>3^yzgKu}mU#5aM zU@JlxXLmt**qba(Hca5-slxkN#aohW3kdkYqSI9b18OO31s~fFioclv@xcrk?An&d zCc~hjf*9k>FrE&(s1-S3A_5v7u=P|E^OF7|bp#MAL+d>?*~cAm zt*a2I{w{tv6Q56HTcbFFJ*V-l%s`>=W|qTV2%A!Z75e>xwB$b6Yw+;d zUg19AjaMm4R4=Q-Mh&n4f$77Ddp1C89{M%#$tB#)QaJpRo|Cv>p?<$8{C+k}nCN43 z?76w{MQ^q|nHNO1R|yq!DCPV+r}o??ivzTzy>_colBUw3pC_s$sNvXq3w(1Mkkwl) z#bLDsYp5-bA~V=n3Tz_^M!;^LE07zUc_MYN$~k` zj}0vI7DA@!hvFm{Xt~`eM1*toU)%+jnGdriSv7)+2+q6gJ$Djnh@WZ@l!%V;nXrR zX)7sMnS5-BRj}r<#U5J;?-HdnzBMzq7xswMQWTi)*Zu?wOS0~}hN@s{z|&F3U+sCk@Z8)`nM=F5cg)ceNJWfGiPMy8h06XSvbU7K&} zf^u!LziuWQ{~8KP8g2Ci&Bnhp!Fn`p^@PHyWn|J;Qm``l*ii8PIvpMf#S63NU_8kM zvp?`MY7xBd1iSy^#UyN7;=$t3ZUy&3`|*s!{V5P0##=XWmb=m-m$eOcxevrYXi*)aV;j}c;pEhOAF zAIuH2e$e|R%x&W%==4im=S+vx!0Zg0=7L)=4^!xbc{`Acf0^E#S5jhz57ier3t{Zu zGu=E@2UIS28eZQqPqx9E4{+tNDcRNnmjXlRw!*1Ofvtf3Vkg&hb}DdAwXrj7y`_j} zVf$d{|3gfZRZwvu2Z5G};jk$%)^5#r^Am7|U$9RGJ9(Trcyizgsv?iG81|ZXL+@Z#o|JihcKALU9=C({@W5vZbK7vc1G0BGk=6p7=OWQC3wZXtP zT7_g<`8q17{XLd!m;zJWA)w2Pl&Qdp2ea%sr)yi?hOfj>QoVoJEG}C`Y4V z4F?LP=BP($z%t+qPka+|NmK*uV+e0TffnF1YHY4u%-iVo>9A$F#la1V&ET-9F!j^X zRCJ(R!~W7x0_AR(dKYPp2|9cQP!cJ|hbiAQ)hksf{F(5u+5!@%Gp9627W;Z2U)WzS z0pz|tw4}&xLA=;B$<8d(P23>(q>YVe2Jq?PPS0h zjr44udAP%wUGGc54`i4{i8G~6ZSrvzIrklUiZLDbDTj9-y`H79_!H~JRX-sOJ;Sho z$!#xSyPtz%^65*7(4B;x(QPm$gD|UTSX|IL)0sh2`MhdOk#?2ztsuGi!nTI+Kz(mf z+CP)MY0Rf_%^oM)L(>z(B8Mx!!WsGsPKcT9PzLK}i(oU&JbnXY9Z6rB;Wu;mU2)4# zGLT(-y~MD2w#Du#@~-B`HwSQs5K;jDfP`k(3@X9@kM$tGB~AO)vOTfcryqF6VBX^< z+OUcW$JWU(*!WVzH7s1yOuuvwT1@cy+@@BFv8i@ysO5kw&fyCxm`4_V*$7)IGyjZB zk&NtvxtJ}%NC8Vl)UmMb&ygoAK~R6?sX;w(yuN`aZ4Ig!1ymdCUH~7>fnvutsgO2a z6sd-9W1u zwv>i7P0WWutCFqb#pO$|+rfDFfey^OVzikNizr9{sA8e!*4XEsgksH2{#EBXBFfi9W-$yNz#3qf0oT${X+dz$w%)+bxW=4^)xxpB%QMC?2- zJ`aA9^~y%A@q1tzA3{(UTB$|MzLeXb*g=~Z918!?GVbcl_Wo{Wp`)$ijZG9f9(5y| zGsAtqg)X!tHOC-95`X(Mha^bjIS4T|l7p;c;_Ee`A?2HWtYy_Q*>}A5)|RvuXnLBH zcc73a@-9Fr8qYY01~SfIfPvQrBev#*d=m_{UvGf%0Y7*3aUPRLfni=)xZr>n1WMRj zrUeX0;J*{{4Y|sg@mHBMQpOt7Glq>dr7Ppcn@6P$8w*8jBrt|m<6_9!(_qZm-@Qpt z8}k9_`1%K-Cj`Ugg<{B>k+4nTp$%qsK)0WnrQVPXa{%yhUt5OVYENKw5S!ek`DGlj z)Em;LS@K}?n-5G!!-Wx9LYr65KXNBcbK~*?9C_1TlFW;QFJE|Vl7_+M*u=nSjLG83 z*XxT=5VPH7^${_q*kgCF!4sG=U>i4u(vV{6;CvFHF`WYo(H*vCH0|Oh!8C_nA2S+G z(9|3sszfS2_@2W!70Q~wyd@b*EZi#Sb41ik^L{Z0+K;>o$aJHMlMnW(upB>he7ZtK z$1_@bl?&E3c%0@EvYJp50ZZsJ%%)Lx6LhWNBa+Z)k}cg>0B_{7(lIVomLw*pxWL8s zcM8pZo1t?bWqSQRtiI<>cdz>C>*j0^P^c#2>OcGqFV3-%clI$!$a{ESCDl7T5waZw zDU&FfCr%5z6C*wkj@xsEG_voTP}*Qsd{?+7`KF`|gStJ{3iB7(&x8DAhUxq5FZS7F z93+Hq*Nq4JWp)ZgE{mPd@C0w14H5`~#GE2>#DW}P=f^+6aV)_m>+z2$o<(Fo{_!M0 zJUPcdnnbQQ@RuhjDu0@*Uo{t4a{@}4_w&qbB-#5_xZ$^ZbaG^GW}jm`tIdwzIL%4YNn-;w4ae6` zl90{mT!9T9k8cBpR(u-opn<3gbat$h+0dB>CKwgA%1N1ODWZ|*sYQi!b#uWKSm)@3 z^-KK93ExMudhps)0x#M_%hNgC`@7IKjb9hRDk{406hS;r7e2$TVfB&dFX(mjIw%Zx z8|}Qk%li>}U6Cah-uraAY=wL`SzOT~-?KZd9*5Chz?Xty??bO+NnzvUur9*j;ZtAq z$TT;+P>UTCaB(oZTVUtI;doomdMvQU3mS&_O{Cx(4)saWqv*Mg;-Y+`DZ!iqz0;I2 zyxT^xApsW&5;qmRu3svT#qEK`gLY4Th@B}Kw#HZu)_fb}H@w^JD#i~jH7AkLlyBJY z5FJWM0ZB9bytCmMlW6(+!&@=fa!Nut*LX{$ggx z4#WC(oE%1NBv8!)F@rff-F9238DDQk20asjO($_Pgz^J?L5zB{HgK(QV}pWYb=zI+ z)n|vj!0y47I9xcXGoI^Bp9I$Pi_f=}u#T9}zbQ4pJ`3ROb~hi9Xs&Ac&<0Bqjxul= z6Iceqd-{``%RCVrMN1etbmQ4Ne{A$H4a2M9@%AFvFaZh=Ju1xlVTh_#+S7@DA22Wy8>zvoNIq$Y8$j)Q}jK?4_~o4)`80I#|4FDZsrT zxT!Q_D2si5-nSJl`q9uDRBC=%bTi7E_4No6yD@ka(UyFy-48Z ztrI1$fVXMf3U78R1-x=%bt_}w!v2Aa{Z?FVXqPLjdSkalGeIeW=4TFUfaVdcvwDQz zDu%B-C~%wN1NU3VUS5D*pxEw0%(>C|rWpWTB);@BB(LhM_~802yE3GG`q4k{fKD%lc^6GNT5J0*lh%Pe+Cpnu7v9 zCtBA$O3@2yOxOIQEe))rIV-e$a)4L9&1jvl>DOQ<+Az+*65nu2&R}dfB?rsp{iuld zF67jT`5nSy`BFOA`~==OVWmGNW4g;`jE3dUK{sMxp{TFRYgyhjkKCx-F;cf0=CE1e zWiOHhCYa{Kfy5jOF^4=w$3ztt1k*-LY;XG(UTNe>2rLaJKn!1P#51EwDO6W!@oY_j z-C87O|0&l5tTMs`#$;Tv!=W-DULWC0Y`&JoZ*a@?_XOS`Ii>07Xczz#i-4W**(MSS zD{ZWPVQW{uq7ZjnHJC@ILBE=gGT|Jc<0%NJ$#0-LA?HJ6&=)A@Xi%;B4A~(U$W8I%w-@#kig?(Ycm@y zse!X>-G4ztwkxp zMQe>$Kqo+&5VP(CNEWCO9Dh*)F(=VSYOISOXqxUG2+Ck$*6J42cd+!@&E$F_bsMd| z8>ZbxmuQ-Zg7<_P(~-og=`M^+++@SNp14s>aS2 zm>9mm6nYLVH+dv_$h?6Li@sFzNU%`HJ8VHqoB=Y57qP^;DOfBgwrS*>-ZZh(?g)db zXO7)aJ}LsSu+Nx;KGHG{)P$+=Nb z@|h}J{R6sbW-_7M!gecQgFl$eP`Y_1PH1kyd~8M%xqcj5QZyt8rgnnXXCoVVictb- zwuK7;17(fx6U`Tt(z3An$$rf(otqgCZoG6{;}J8JIk1fvEK}ek2Z^k9gp~rhPBsF= z-voU|%jb+;chLs|BiZhSOGoDN+o(9VhNIb{9Bz$wwSlBM3g8(2O9ccv{j3 zf{8eIBM6Fn&_*D6(Bo7EQ|3Se-NuV z_!e5QcCUpt4TH75e3Bjan~TM3-t*AfV@Ryc2&IGWn{ES*JIKsR6sb-BYD8ia>=!wDzi8o=;0~OyiWmDbtIE#dT z@QFVV4I2YG;LRti6TaZ?%D2O6OSbm~8}l;T*H zzT^2f{}R04hjn<^w!6VEdh!*(n9YW#@EvdZZmba#-`p?xfr4Y%egJ&x9=_Q}>6Vw4 zuvH}LJJjRybBCJYzIS}uWj?q3&(-;vcK4OS|6^<-I50YVF{(aQ{`s*9&_MWwI2RWP zYpwaFK%PDR(-gi^cpG9qIb2^;`@oVLZ-{$WFJ`S(9sZm@~R zyl${bI&yI%(Ee0?*<$H0-3)` zJ8)w^er_-bse^TcfwA@}a4oA5Z!Whi+j=u;S-z5;1|8B53ex(W4jrx@)o;^W+#Vdu^;(SzAZ!kWvl-~{UdcOi6#ycJpqCCpLSqC$J z6C~?k{Yqd8@v-2*%Tpj4@#b>NvaL6hmgOtiS%8fBcdJ~*(AS=7cYBI04#i>5=HLIh zOg~UJ&@iyb$&ksDe15`4EO29BEV~6;gj)v;U_ay7&pfNuT*Q9qIVZ%g8Zp8gJy54y zH6~^F2(w|JJ{~VKGXahnXrMdvQ=i~-H__)8d^mALX6CTrDQ5k^Xx}?AK0gg{zCZOo zKlQQlPh}8%uE{cpy*}!)JDi?Do_sreT?@t_JktkRtd<;S(IAHfzCINfGYHZ+cu;YX zdl3IB75k~+5eBE$@GnehqqK#;VM;sr7Y5g@d0_Y2!aas7oT5Fy3g^$TXWJ_58hJ22 z>`C^I9j$?uVG4wB&Nm#cJ18CDH$&?&q-1oABYW~R9viztGz^|%*C;Do@GBN~N8pGt zi?|tghOoPBffKvNXHVl-_?yXsXltbtTrpav1IC5jVZT`F7#Egy{KcMSH0)>tcTT5! zm=;EZDPT`w3{0O4V^6Wr>i_=zp9cO<1OKOi|4%i*JR|dQt&b^61YAc#F!h^$ngYJ^ ze8AYj?st~%FM8l1s9;(vy}kE4D!=}P&og@0kws8pbW#S=Gx_}YY06Ogeb4Rv;eJPD z4E?t7`yG_)>Gwx3Oa_-7uGr~!4!_@C@zC$7{C7L$4*ETX|8A?yr{6aIyN$AxetY`Q z2j?E9RKjm|M9pROBcz}WKPlzkwBi>!6<%`y@dOoK{x#xBDm{`h(4m+7ypa!NEP0S z_~=x4d%}}ccxD~OYf|B-6MdEn?@D;>YF~N8?}IAbK>X`ecpTwJRQO=RmFIo=UqN`d z3Lj2*gbE);cy|>(n(#;!K92Ax6`n!3PK7%OPf+1E5uT*Na|usY;YEa-RQL?SGgbKg zglDPna>Daf_yWRRDtr;)B`W+8!b?^76NHzk@TUkbSK-eQzF38?B)md}zd-mh75*aO zl`8yI!q=(r*9osu;cpXOt-?1FUZcX_A$+e2e~<856~2S;gDPBvP^!ZTI4lkhAR-uD;uWBDq4D$%=C_$`E&sPNkfFIC}p5MHLj?;*Tgh0i5?u?k;6 zc!dgIMEEil{utqvD*P$J*QxMTgjcEXWrSC&@U?{3sPGMh?^WU339nV*pA&vih5tx+ zoeKYp@FOaGjj;bpU;D2T_OHUP{|ECuLWMs_^xakX-xP183jdezC>1`F`0G^o1H?Z; zg|{L*Oj6;?i9T6{KX8cZUlqQN=rdLL%Y zRQLeG_p0zD!fRD{D&YrJ_yof1RQR{lemkPVUucaZCdwLL`(N`NrYl^9i}r1V3ZF>% z+g*jPCH|2r{8_@IRCt-Ne-+;Tdz2?Zg8Bxi{VUq}2)Rk-LEl&SDHh`wBf>nL4|Rd^o7TcN^5e`J{o-$?u` zRrtz-sQ+~;+)n(fRQP1Vt5x`Igx9F>IfU<3;T43}s_mKmWzf98S6e)kpCEN}9C-QNb z23{rcm+3R-*T*a4E)Bd)1K+EGyB7H8U#5ZY)xcc~HTY=Ydmr>q?_$G6aIo?yr?*T4 z->ZSU7HRO&!1rq4uEiRBH1NzN{^^%#;EN@D_(1Xl6%syCva3o7?<~=;lkixH{-Bia zKDd;RKDd-GKDeZ3A6(L#jOR<~mGN~Nc(o*dt|b3n2~U^sgA#s$gddUc(Z=sbp6&eW~OJd~nIGd~nIGd~m7U$#|6{|61-r@K3b{ zUZa8U)xc{de7vL|m*lr)JY3R`j7LiP@xdki$aswgZj#EWOdl!fN5*S3@PksiswI0U zkjPKRJ>!ft8lk%%nN|%gxm(nHUIw@T; zUMtBj<5`mYGOm;C+y|HJ+y|G^CF8Xk_z@|+&q?VmlhP~Wky3hPJV8pY4=$xw#t&-X z`H~)F`UFW2KDeX@89ykcSH=}7U7t&K8zrSn#*?IU`QVcLGG3>FyQFl<^hr{>d~hjU zKDd-F8L!j8!=?1zDdn$DO0SG3OX>B&rF6;o5e>XVO0P_xETz{6m(uHlOX-sFBN}*w zl-?gCe_o-1o22y0^d>1?GOkGJlJQav+$5z}rZ-9H^}(fd$+#l5e`LJ7l&%AkJulP1 zGo|#(^qEq6WjtI;myDNb;F(f-W%^7hy*{{CKYT<%3J<^1&rJ zeQ-%m8IO|UEtkqsf`k`Jc(R0lC*dXucS(4qB&UpLO7tH}_PkD_m+>r#K2p+8l|(P& z`4YWZqOX?dWxQOXPnGBwOSnzKDY`Y9#z`iGG?Rl+v|K!n;a# zRVm>eBz&EOuafvwN%%Giua@xTk~}pMK1jlAB|Jik_lShIlW;}ySHFuw0q1ZDhvg*R zBSONrNO*S%?;_#(629HbMNvv5e4|8PF5&k{_+kkkD&fl{{8b6Bl<*5Be4T_pBk8S5 z!dFXpwS7Y2e)@JYC{n zt$`;E@` zpC-wplkf{9c@iZ2O^HvEgin(ABun^S$sSA+zE0wkCElxqE<4*RuiZSiVBJ{8PtxTmO&H>RzhfPW~`P{ zutEE32(4e#e!ifUBJHb_@z4qJz}XoD=DXK($lS!>;s4(E|NmUqT=U%bv!Av1T6^ua zkMo4`T}k}el%Y-|1PE9OMEfaW0?4>D1DUp{~-AXh%cdX#)yB9c=b%u|7VeWJMl+}??=4+V#WN+ zBYw6?;=6$O94coK@oR`5N&NjJzm)i=DZPvMK9s(K_;j-84C2oreirdRCOIDBU!i zKM(OoNlp#%g~ZP%KGZ1%>v+UxQF<@&Yl-(0zm&?el6gwMmiXUOzV*caf%rz^uORuG ziT@*|Zz6sGrEezwMM~dF{6Q+`F5WN!Gx6!fHxd6slG98)e(>7)*UCIO$}Zx=ovD@DOMC(88zw%5@{JPTi{u<2 z{uxRiBVOKM(D}D9>HiN=dOPuhs673Mf11+g5&tTsFCcyt@kPWRCw?UHi-|8KzE5Z2 z;s3<olpS;V&!?;+kit1H>m5Z|BjolpD#;ujI0NxYZ%LMo@9_$*4l zlK7#Nel79Yl)j$$KT-Nd;&UkdX5xpF9h!*WNphNr&m}pn#OD#ei}-=W?4i zP2!`(e?jFuK>T4!A0vJ?rB@9}{~tuKp$`Ba`7;xD3n=M(QFIg5x7Q+hA)Ln*zV zcwVH861L+SH~A5Q5Dh(DkBBH~97 zKa%)oNq#BuKcMt3;ztr+LHq^8&mevj@w14(ka!RAf1vWz5dS>!^ND|h_(jC?I+&OE zE#yCb;y)mMCGlgZoNI~CqkQX$-$!y9i62XHHWNRE(l-(RGm_s-{5X=+O8gfjXBY9M zlzuPqWyFVxj}spyem<4w0Pz=7`WW%!iC4c)`u`G=V<-Me;`7e+lsg#GgZQ ziip35_>sihi7zGIMe<$5Pb9vA_^ZhNGl<_n{4C;sL-~4$pG5L&h`*Hh`NUsF{37Bf z6YnMdVanG}{JT`nmBbIFxVM)0DI~w1_$x_%Bk@y--%R`s#5WP2L-{rnzmL+l5??{( z*+u+nO23!*%PD=B_+?~=DDmS-&H>_oPU&OBe@yAsZ<7AMkMgw>|0T)kNBm-vlSlki zl2btZUP@m?{1udbB=H|nzNN(DH9?(!F5>4=`U>K&>`aaK5)pqNm1h?5UlQ*j{$=88 zi2sn}&nNze#4jR#9Lez#e*y7+;-{0GmBfEY`mQB@Ao*uK@li_ONc=kDHxoaD@@*o1 zCh^V0KSkwlCH`uXzl-<_iQh~7a^l0p|A_L95t(_%)QTm-w@Y_Y?nPlCzTdt(5Ot;%}t%^~4XScF{=ugOu-P z;(HU{MEqmKHxpk)`L+`8A$}L}bBNzde30aaiBBPYqr~SCe}MREk{=`f0P*U#N&i1W zyq)-)i0?=IPl(SW{-?wj5PviAMZ^y#eMb`i3Gt=G-$HU+#McmCL3}OoGl;*7>^6(| z9}@2&elE$WA-;~%&nNy@#4jR#9?9_%e<`K+6TgD^mBc?z_E}4OBk}db?s7x8D4Ju8S`Na<$~ zUqI<+5x;}V=^=gym8XXIyGZ_g;_o0ii-`Y-(tC-&n|MF*Z;_mp#Q%%ZuOBGc7O!A||e@XlS z;_s$%#)$tV$ycGI|6fY!?ZnTZ^!WD~W%J z__f6UoARwE{(8!{k@yhtn~8s&_$K0SA-{z)p2pZEl& zUrD@^__f6Ulk%-6{wb2*Nc=WRznS>=DSZ?1_fo#i#OD&FbG~Om=7_{NX};B|3rKf@&85j)l7U7rEewv zDav;j@h?;Qy~O{S_>=d&8a!!JfqPTc>XY~FXl%As?V;Q10PbV|cXR(!Q{w$1<$(gL zV~?Z2_OAKCyV+OXfce*h#nq*iCo@a5dpkz&^rbfg1>41l&US z65t47H?TE5ng3*9C*i5UZo<=ms|n8p_7T1YxPkEXz%7Jl14jr~16wna`QHreBs>?` zP53t8YQlE_`v~6++(7tV;1fUUif`9BQoB)lBhP55!(YQn34eT1I^ZXmo4 zxP|aDz!Aa?z}DW${GSDO5)J{o3BLebO?V5ikMN7Y4TN6;ZXx^%aD;FRu(eMz|JQ(> zgx>&m6MhT0n(*7eKEiu|8wl?MZXx_WaD;FK*xEOl|0lps!ux^Ugg*zaCVU9kNB9_U z1L5PqEu9!+0pJK>s~h?EGxOivzbCMha5}J?a3A1m!UKSPgmZu!2?A?yUU z_D|+N4A@Dy1lUb@1aLLsQNTXJV}Tn8Uj*Dj_!8gw#Mc&jyYVt_HSdCiA};*hzRUu$%C0z}1BB0QM2S8@Pe+y}&Jm9{`RJ z_5oY7lKDRj>?FJ#*iHCx;A+CFfPI9Y0&XC@4!DKzGr$qT4ZzmyWd6?rI|+w?-GpBN zt|q(%*hlz9;0D4k0k;r-1vo;u1=yOC%>OlDC*e1M-Gtu)t|t68u#fN_;0D6`fLjQ^ z4;&#J0k-BQ^Zx|cNq9f7oABqr)r1cL`v@NcZXkRdxP|a3;0R&sB;=o$%)ckFlW;n) zn{XfCYQh76eS~v>8wlqEw-6oz93kukwhm0@KMdGOxCGcucm!}Y;ZeXo!efCO2ww!; zLiiHk2w^v{H9wjEWMC)ZslaZ+(}1f9&jj`nz6Q8~@b$nggl7Xs2v-AJ2PN~r8Q4j9 zF0h;MZNSxp?*R4@z8koK@V&q-gdYHo5cUCE2PgA?7}!a8Ik21XCXTAa*(7_gIY39y^+2;geMqkw&c#{xGHz6iL5 z@Flw#Mc&jyYVt_HTAm(2fWU?<_Z zz;42~0ap{g1K3CSZr}#O_X4*NegHT^*avJKp3MJYU?<__z;42i16LDX1?(gI6mSFK zb-*ozp8<{#ZUDBPpUnSRU?<@au$%A;z}1Ae0Q(5P2;4yUCEymquK-5~w*Xs5B=dg_ z*h%;eU^n5nfU60=4eTSl2e^UoKHwI@?*m5&M}VzANap_uu#@n9U^n5XCAesL#U?<@cU^n3rz}19D0s9D#1#TdG5pWCPOMoMU-N4pS$^0h+I|)w(b`zck zTupc;u#fOHzzu}22W}xe8#qF^8rXVaGXI-_orLECy9wV0Tut~6U?1VTfg1?l3*18Z z0pJK>AFy?FGXIBxorISIy9qxITupctu#fOlzzu}g0k;r-1~@{v0oXbwng6rEPQoEz zH{ln6s|jxb_7Q#&xPkCXz%7Jd0ge!E0k)1!=KmV7lkgkBZo+Q?R}+34*hhE|a0B6e zz%7K|2aXVq09(f;^Zx|cNq9f7oABqr)jB?T-z&kx87eM&fb}=2z>!2^jmxSIsF9Q7 zICsCYuz66xxkLpv;a-Z>J9F)c#2QJr>ZG1-qNF`BIbMkL)mF9A?Hw0bW~6B|WeuL9 z%W@44I6t*?%6iC1x3sG)q&H>FH`2Ui${KIT8aX83v|Br6-C?BrSyx#|Z_2vSNb|BO ztCykU_=145IjLink?y*#vXI`CHPuMdXv+GvQ7%;&aAqZCU1_A7+*KCRo3h3s&EX7J z{N#Nt+Wsq!3dm8AENla3VQV+*uuX-;=3^iuY|9M&^HgGux&LbJ-+C=-vx4o5aPM-| zN%3`);|`?`MpHNB<9GaJ=H9MWw||=wcPX`XOd^ph`@JFyzhT;}!l{8d_%6hExl$d? zN>xhz7S>OR&q4YFHcLoh|5u*rn!Zq}H=QSzzB92`-HJqNT}R=GiBHJ$ZanYa3thG6 zt)0({--*wO@7;+!J&`G8ILA6hE1!RI+>7+cW2HJUIX?7wV$ELIxj=bmdLpT1Y^(R7 zgJ}!-PS`BFPu^zAFY$aGs!^W(h2K*Z(*H|-hLX&YxYt=u zzcVn2?iJ%+6t)S&PBlH%HqAcw@0jo-)S=kuPQ>*iHb=>m(CKXWrSNxtGDYLA1_yuB zxi@s~E^ztaGGa_$^8B|Zju4lwxz20wFhd>hjDGWoj<9pA%BE7hGe3i$gl)|evRtYxJ4?qoU<}+Kx z{yCu=W2h6G8m)1EJ6q#sf%EiKV;Xz9wmW*L3*gt4ua9tTFSpp|)s0b=jeT?;?Zt~koRAnn<2a$)!pO~(dEnd-2Z4KtQw!e;iT1%83$NLS_bSo6y zEQY?H>fB(R8`BCM9sSjUx-7k%Jy1rCD^v>#p{w60`;qChgC{<8!Ok}ZPu_P!5cb#V zC%g&m7oWB9#F}kx70_(DSL~b}a^l&~QP*|puAtx!TpvN5XlcUEfZYE?^M$NXn=P|s z9^$67dF_7G8F1tN`|`Z>Z&wZrMBqEp9^V6}(8q0p4pHPSGSwUvhz?bO5MuNgJlBTn zuq`We4Bzj8llUkxt}r?!?p9Oca_=a7>LTR%j74Rcdfa>lJ^n1^F!b1t>#lli1t&5^ zkFsv`_?gC2Wu?;_H}dImjaNjVHXuEup& zJ!XJ2^>`ODyZTjyJTH2jeQuz|@T*DSM33Ix=#kZp9+SR7k6+`So%GlRnccOIVNwo5 z59vR<>M;bIsmG>n^vIFtMUSV?fxl;leDJOQ;6#sqe);wG5&7!t?W6xU=po}Z95mC~ z$1$|EXQ0QP)7p8C*3OTho^(BOLI-i(RgX`>nR+bfMvsr=dC}vD-bY$d{tv)yM7$Ke zeu8JT`>W3lxX};n#XZrnp&K28-RQU%+?irP8D!(^ac2zp=^5(kWhtXkS53I?s^cHQ znL3tsqvLb(yy#e(i~-Mr6Fug4qsKkn=<)0~=#h#%=TTif^qm-kp*|LZ+lanXa2#dS?i+P=EAEMo z95SU{Y57sVGXr^=b@fABch#{1oT=mghD?bM ztfLF}H9Y*BK(!ICF9s)i^yo&9Uft+%@i*x4w2`Nb&m?cB@m*ki4>7(6<6FjH{SBOF zeCHV7S@=%JCk-FF!S%(r^yB9IMABp$_rj^Jcq{DXQ1%YY6)N#ti!r@%uM)n3-+_-6 zn>-KwM3#)@SdJCgf{&E95_PkB#N@c&>WV*7a%nJ{tK#;$*)bUl1m_mTDsbQa8T#2N zuDE@o3hdux3pV0xrsV5FzNN@dOY^JA+WmUBMf&gfC$O=9*u+kG^;WAUFEL2Pe{f9d zEHm^FY!~f2@Psyhu&Ka_+pWRlx7dQQs+8cdYkOcE*c0Q&oZXEds@?WNj0@(e_^X>H z1jPq7EwvO!u2u22d%)SwYI@a{k54W>Sxt?JOM;D?Ec!E7$TJrO8xt1?8*j4e+;ri_ zfh!F*4z=mrEy9fkHzugky)(x`FZGeSUB>6__&9o7O2uCGB`R3Z+c&-)c2Zu;^KG#6 zZ=p|}!~@o7z4j* zwRd=8s

n`w9GB>!3Y%!#cYq@457o_rKFVZbN>RMIGFaIVr}qB{I(aai)JA&LeO2 ze)+&VC*dD5wibVo^6gE}Tk&d7bx`uh8T?8aW4GA`Vs4fldK>k5DX8kn-F%?O(^OyJtlrNrnV;5ey57R zdsuCa-VUE?L%sG@@#xSD_*O=seNsxm{*k5cwUCAPq#n2v`yd0+Zbf#qO2vzISOS;N z!SxgsZ-<{@?!Bw{{K@g?PFp}ra}&~7T=D3I_%6ivIDDUj?~7Hu0?$Uz#rH&fp9ek- zd^x^*yW;IP;Cd47S*(HR56}i|X>S%6A|K3Y?I$mN$KC_}iF%CwRt3#Aq2=emGtx#3 z|38x9of(CXr^2RE?)IV6f_9Y0)IIxCwY4$gDyvaybVHwsWzybdOq~z=HlhvM2f8q( z%??dOELN8CJrSEK3B$e{Vc(+|57?C}9)zEWJiD^5u-9qxhq)8?smgk!!MGLm>0KrB zU>QGbvdxTHQ{YF++A%4LImWW9Vhy$dF-hyFb(TtcbMAc|($`zmR!55Z!$#D z9azs0eHtMP*Bw@`f1RF}Bh(A!mTM{B$4B*RE#Cg?Ty6fp4CQz_RrS9OvOPW2R!OVf zKT_0r{}$ZyVt&_o??AD3Zxf#N;9mG>Vq5*D1wjk+odjFogmt0F&i;XqP#<30Z|-jy z+YVnUEW9*Wj<{4XOjYV_*AgmFmgiOPy7A>pQi5og6N=D&MV~0@hRh&p{Ye$+_t!W+gsj4!Fxvk7AC*gXM_*kwhJ`u8|&E=ph(Tm;jj>DEM z^R9mKPDIBO@!B8&);C z2-n$#uHcvVSmJ{$*>5hLqz;B{xuLIyTH-d$Gs9@ZZMHP6{?3y8hE9x!kv6*25`Vdu z+KPB~(9#ROWp$O=l`8X~Y$EF@WF+ph#1kK8XxwS`!J49JpA^UpA5vq>;2WBKzD#Tr z+caK?whB2i)^L|jj@J*h?fwvD`3PlcLwky#KRSw7x6wICtFva5)vU8}tT7ZImP_4< zj}+LGe$to^d(E)~Ud&f<>4)nZRN&Rai8U{R|27+Dp#7h2#|+Jm?^auO>$c2TKgh6U zzGcvxRfa8(cVo*pP=2=Mz2~W|Rj}m_tRvLebX(&0LYgg2J4WxD7;m)>ioNc;K2}~^ zR2sc!V*ECw(d=Ox6sm(BA~OoRx8t6qIg0OPi0=cHYx`Hy?QiEpjMq2go;>5Q zWOu0l)bif$M=WzZq87+F{gX# z_#W!Gxc~BX5=TuR+;8~cVcXym@w>sD_8Y9(uRGh_*Tr`D-Lz)Ajj}Fc*iOby;)kc% z&Nn#ry7kAMw!{0nV7tMHm-(Sl-PlgEp(VFNL2fIad!t3|c39FoPGBuTp&h(;@scIfsx?AE>%-`2BY@Qtm~F88DT%NlzW z&zW|XILyBB8}uLFs%LNAH);*v_`mUsqv*T1P3=S9CvB>b{6hL?DKG0Q<8;#xHXqVu za2q-ff0z1QY;zfHCtqtjOVKXE;{RIv$?x!N)7#JCd9FCOp$$EZHsl`C#P+!n_Gw&p zV@%qEJq7E8=odO{_RxOx;Xgy)a4Y(T+t4>`K-`~t!HRXyUGVt2dFUI?L*Gzk$<+22 zu0XnSOUAs~QOnnrgWHHUEOOGpe+5}GrkQt>3Y1&Y=h-1c#x6y8UT_#O<0iCm#OOpmaZpI=Ph{B(^uDLXsw!VbTU%-!q~$IBSnW{#-tluc$ZLhNEPw zDD`=T3$e!DVR>1`Lpnc5{0ja3#y=*u2Ek!W6>3MF%KeYD{>q9rZ4Z428Bx^F6DJe7 zZOC8Rd1*KGYqoRIyA`qZ4W~tG=N|aY8@?N2;vdq+t$$Cp?;W=$+xNOtiCnF{`11Ak zf*7r}7vG@o)n48^0=>|We~NzmXXwZGqaVKl{rEie$q23SavGlw5LB(C#i^SmLMw^)k-OYYT^p|^G+l{m()2@+&dOPUaZazX? z4gOl+qqm=8Bj!3R`5kJLs&q6LbXcCy+mQ4>^{Z561?Is^(9W8DgHLNakAD|i^;P}P zWGl13?%Ll-AJko+^S;qfnq!~u8e4Q5>3z&E&tRh^-NcoM;iqDo<_6t1a~?_BM&Y{C zHtw@dv(1$6VjJ6#Gy2i@wauFU2HVX19=2J}wtDy3!=Fj@>{Kr zQjWc+#P`0ft>ymr`Oma2HhRfuXBO(4Bo3Q>sf?QioBdLHH};XS`5X(@;)WLo9>;x* z?Q~szXPu_&&hMgY>Y3xp_w|R&F1r3dX)A9X=suosTao^^nfhN>o$dpE8o#1n&C=qB zb;t>>{|CN{O&tGy_5YSp&i|YE@yHo$!s8OL$$exK&tlysGJavZY_}O>65r`|DTQ4k zsZ+Im!4DDhe~kFuYON}@W1q6s_v5Bk>sd{&yKihdJlz#fv!rDd_fS_|i1A`O_J_+S z;=BabUF6<#7%RMv^!qotf*EyHO^Czu>L;nnj2-&5SFSCt?ZRu}{glRRXs7feghO2x6_QtNlyHo|q3vy6EkgN6>i5w6iv! zfGimkCgx!ddQ(PO8`A6Z4BfU*iESY#iu>)i=yUZpd`IWOcKW*5=9_TFDU7*#it-Nl z*ybonL*C(KJ+<|i&k^sn^^WH(0d?>fE}#9GwAjykN3 zNx$Pm{=&=LC5n4?%tak&n;q~2`^n4R$;8-xqqdio8+u3Nq0Z}MP5sKg+WCUFz}?wX z?cV0YS|--0e}{G+9txZ7v;{Vx&9&d>ioY9CyQ4QDu2`@p-dD!vn1eUyb8yTTcF9_D z82lT)8)FZ^??jfA(Y)7u95OKn;5F1{$llb`6*t#VZo!{B=B zTyNp}_UUsnb*$`biJZ@Iy}C`F@6qS2lc|uIs&ml2&-gTh%h0(r;d&cf-#%|0$Fu!a z+27ILF+c4nIGm`w+>*9JbdY(U)T#GSqB7m$Dyyo)S`+MmO{}sw(nprM;$|H>ZCFP( z)>P`yr$lX+YHKR8Z>G<=WNpHwtxdEq!?({^qqtAS_b*fNK9UYT6a~(}wZxu3eV$lz z{#S@Y;J4yBis#X>J2F%jLC2vFOE!0l!5I!P-pJ zfpRay_qoZkPej?HgLFQ8o-2M3GNZqp(kUnW16SOXCF^Eo$Vb}vVXf_BZ9%C@iD9y@ z`>Iu6f2i*{G3HR&9UjzQG2~1A$unmC-KFg@;mncPZPG+7ra0vKLj8KMTua=m(#xsF zBr0>kVgEf>#t-n1?Nt~f;4Guor^^}x^LESHb#mrSxTq~Jq|dilP#H(+1JlJVvn?q4-kq*bh_NyEMi#w9YgahyzD@OsPOrr{2ZEiCp0`-fmX zW!bf{Vyt_}T86}uuIu)NBTrwqFIT#4ij8#>S!2eBG>}!M_MfXm5kr8?jwE9j-iRI5!glgXj${o(`hvBPt~q(jMZcBf1b2?#9^ET2ppL{8D|47!x@1~ zaaLeb@WkzIoMXf}gVZS}v~$vOE_>0Kz)SE4k6aHvPv*Rv3;$LUC_`SuA*(BYA$X1J zH$3n!^FFTMqw76V2Kdcke5NDLEksPy7OMbiEP+{P6PG?|a$TF$Oq1O1{Xi_Af^ zGm{wi-3UD{#Coc^UvmuHqu_8}Y9;o?RwmEjWQPu8eE1peEyR3B(>-=x;8&);xL!xs z&zZIa--v6|4!zG{hnrAFwnG(gr=Er#t_Nq@;RBST^S)sR@h{B|2QX%X4XoIE`XM;e z4pVV0cF5|+4uiU}!_;rE!*jTY|K+LM;q2jo8%*8d13xo$2VYCqvi_vm4g5_ekMtf~ zoA&uDuDkP-K`1-hCl|O=f5Sclz?t@0(~W)7abL5~O6-*ze$oTnj^+1ieqzP7*ynF( zM_v8o9hAMRpIE=aJ~!dse#Bz4jhst5K6(ZnBQoZow(vf1R~_F2XX-e+8y$D!zOG}D z?gNP9e*?E8eTk;y>$nyjpXf$M@!zgGz7Fn8ZJ`AD{{cFhbtmnsySn=w@?^alfxGIp z37n}{Q8#+6$9+vNdvT|4%lyvt?I&<8dfnKKUO(wZuP44iuOqm3pILWkzfF*7>Uh=} zbi5P!vyQg|chzw&I8()Bb?Hg?Jd)ymKb^TAs?5?gaK%Q)e^MO0d zY_!uNaHbue@5T-VxUbiBNx+F1CTRzOGwV7J*P>VCQ{>epp0}e7chxKJ8}wR?ds-W% zK5q$RnDPA_T!)~y=x{NOYx0&^J>>)@V(x+mh+iw@xeO9c6kPCqhn<4O3pMo z@sV>Z1^CFlbMgHcK61`c@KAg|Vq8m_hw;hAN5-`_d}M5G!3TRrn(QL{7D?7!<(!eE z;d>R>(~&a;=6bBRkE+av@7{rQl2;h(ZLR2!WzIDRV~r<}z8~)ON1AuEvyj=Lxu|22 zD`PJ^K9Y}lF0u;OQYMk*HNJViBz=CZeim}2b`}zIrgqGowDVt>Gu5={=ONoMkCL&@ zVdRA~VJpouVIDWmn<3ps)HTnaJUA06a%Jwczaz2c66F0LKL75iR)2!e$M}4NkDM70 zf0eo!jgOR5)-Nu=XCyv9z-I(L=i@URpY!l3!KWCXB7CH7hT$W;W-qMg6j; zjdh&AqTI5MgWqOt`ytZq5WLdSL7P$!lx43zQmj@j&YsHI*M`LR6{Ow*W^oi z((w^n%Y2$`Epscbe~}@wM9u`<6O1+0tgiMK{+sH+oVS{Fu!`zH=B{R4xw_PW%wf$s zcm#F8^HJVl!jjdYfF+yjA4Y3TKR) zZ^pHZn`Lh7#l31^X(OVydG1pB19RNGMPi6CZhm6FT|D2XSJn2Xnc4q>;06HAehM;C!gmjTL2W z%S2j~+f4hUq=lb$rp4J%N&6*Yx0HE1>?8Fh*KIp3D1R2t6gWzxe#D*&HDAdJbx3-Y z$DwjMN`(#4k1fFm%|6w0#XuYz7->HWS$uhRr%=uz(AFw3=2%(yXh|T9 zyrunK0{v=HF09R9pFxGvdrXYs3~5I_>S8XqG&|xT${?}Xg>n^Gyc5z=z{%RROO?sF z_b~D^efA>M$C2rmVJ?0t{A^MXcGrGKsM)%7cwis$vlu=hXWcb_F`h?z!a6(7|HBqV zkR#VVTuV$!*iuk`8K^&N;P@@QFwgIeJo=y>`^vfN&2~$#fc@kLc9GZUP-7dHsoi;q zB~7*=v4z*Tf|ZC5R~M>nuOgmoTQ(>r@uVJUHV&0@KaS8MtqyO9)g!%}C3>byb@w3bqt)f+l7JRR z!SzLKnj?E9n^d3`GNVH+fo#Z=dOeExm4>>N^>V4(cEPCIcEmubTk*Mit6sP5h^c1X zM$wk-J(50DpKJI~llYJ&;Ddh8i~cBkmXX(1*q8GP3PxVRWrJg8US1=wplz_UE6tBW zutAk2tHX=Bkuzi=)P?-Eq2Bhd@j;yPirR3#eAzSO{iu&d$P{_9e&1mGam)v<9?xiJ zCZS*BvLBb)l`505Toi3Y$^@*nm)D~xFP`E0YDC_zN?EXXAa&tTSy~K!7`6|eEB>9W zVV_|13u1GrE3=N42oFD&x?%oq@MVZ&WgkwCZ%2LOclCHbKziU(*sP$p8iO^&&D-3v z?x^oCRij=tf1ZOqHq@KQx8RJZ`0AICC3en7zAr(ad#1U9@;i-d;j2GFU%3>%eHits z`8LwEp?<`-cc8zQaZo*;X@t!%4mSGA{LqE4+fu`~qeiUKeLEL%B{TE@Y$eY&!ZtzJ zMSS~3_@?+%1M<+zofQhh_oTcLtgBieQ`6Ix5!i$@AE6u)r!GeMC5>+1e9fLCz&+t~ z#eYe*IV$Zz&Je0REzLPdBeCGf^yz5x)6n*Rh&8?|5nryrm?TAuFIs-8SKuk=S`bc* z#(aKrA@bMH^Q)%v0!y#}^-#3L8dOIn%Xx6^9T_h{w)yP2Xq$(y*004X^o!E}jl#!_ zUC*Ih=Dk_qWt^?WFT+2i|2hu7vmfl@CvyJ~-|ylta}b};g3Lkq$k$H+(6Ga!EfcaYddnU@i#4a za*`Fl$4ZC&Gf)q`P#?V!gZtoj`Sy_Jw-fa^EPh>)r^ar?JE)gFpn^-$ht%6FT0Fc? z%5@WBFEISG1Y@DlR$Si)JvO4=rTj8RD3^57PI1p{Q?DW>xKMr>pUK(JqAc{;J24hQ zn$dMCAZ-KjE^slvvw`nMf465uVPG)uJ-GhzrILWeAbGZ80AdEpF%Y^oAus!2#Mm^o zKw&Rf_)PGU_jSmt>6RtI=|Ai?{Y<{z#`4f!28Mp~Z#{h!zZq&Dr1#yX9b}w-68FUp4mGI5)ZZiZ zggo0Y9+5Ua6mfVx@~y|aFLYkouOlSCvw0G{?Bk_j@5-UlI_eNlV#r7K1_$CdJ1?Vc zUk977?TvD3dJXE-OX|$j>-UCU^+?}nJ1h2Wdfjg5B{3(6@=NTP)8Nv6XW>GOFLJ3s zky3H(9?lEbgDVDZwA~mhvg`Y-4ai^oaS`I8X#+3P6+nNPOM3903578U;(e?r1>+^` zfxo z8MBuHo7Xb_khoEZkMsxTb00zn8LwV|e8r#Sp4ql)44>-SwmfM#Zv}am8?vSt-<`IH z5AVQziE$#&wCxV;tLA~@e8hLBb@AOg)Sb-zW&R-cHOnM6p47$05~rS}ytbmvF2wov zF|gOR2!5ODRDpLy_TeAw)$ao%o;dYI~x|WQ)Hli$kjJ@SKdvC0L;8_`0Zm?!| z)ZyN0SucUD_rOoR+FrIkez+UuUybp#q?5IQg^=<0QwjJ~R_J!zlV@JXGbiu+5BLz? zmji!1GTj=?>ZQ#wL!-Osn~hk~RbSCBj55e?hP&!r2)&OXuhuSlXQTgUHS~Vn(ECh! zdSK@x)7>cFMELd2#-sZaxvhqMUN`LH!MU4b@K3YPkoAKvF&7bi%=Lp~wv>{OY(2F1 zx5ztNq_27wb^ayVccM>9EOAN&y@*#g!Y+P%t6uhLmfrSh>cO^YC_^0jZC~18Df9Rq z9KZA;6<>O)2iE&DwLM*#Q%nCX^V~1H%yVVT5r*CC5xYGDu-rR^<_V(15$ICb+&tdW>>V$2wBiDHa4CKlw)6pvH8AgL z$2olaiAhh?;w*ml{b}o^uA+z4me$bnLye*EA^EMY8!_2|{Os7v!1~Gh8a$76z@UGa z8^23T(|$XoFh);@@7m|+=U&ngBh`a--YtXYtrkniwRpyZXQXZJ zMS4k7GYs=|-(Sc3$0Dz>D5LM8@&1c&jr#Cg-DNdaYnjwZ(;4bw&nJmB@8Vo$U$sg6)qv?uKE!S=sF95d^vL5pcwp%WOlnZ73930n`0Px@ngk`g%agu?r#GVyzG ztL9@4*vTRD)S=eEDD8QP`B|YK;JOVQ_WuJ?=AWa?;i1~T^j5#5Lws_fd=JU>E&8=j zuCLXvm*V=!^dALJJR$Eix(Z{_9$LKD{0(vtpSOt&uYBWq#QAO7v-tK%ED?-yybfJ{ zX5`n5*idWaSC4DcC$;B+tBw2>uB&jZ$-x;(Go4@$@GMCO*;@=doxJbmAPz2R?J-tm zMO(IE+?IlIn+lcV9b*db85-Nm6|7Y`Z!TUKc>BG}{&Z;IjekG1c=yMLitxLUtosM9 zuSs{s?}B_eqh|+a2ZzB=XaoGW7-LtxEy|oYCo~`V-#yzE6d(J*n%g09|8Ce)>yL2H zj^9K3ud%Pc%UI)(_31r0KOkwnIJ4HQ#n2q>JkU8vFXw^oLEpaLn*C;lk+%bLMIX+u zRmpil#JP(5-&-%g$OFnwN<6M7B423gPJH}$&{nCG+%Xr9nog82;md`~sj6PH__ zuTS?**oNz$A%@kU%u%cT&78ijps8aT%BrqQTi<50LATt{{fJpLu!Hb^XWDvgi~;{S zG9B&i+DWjpD;}$ob+*51>uh%;?KQE)ww=%cvHIY1C~HwSWnKS0%PRJe_PY&sdlh!` ze3j^2m-Zkg`~&3_yXoyC`93x?9*?e+{!1Oq!8i=DHU8^#*YO=V*CIY4>m)~0^|@r* z(BwLm%-1}!R)o2WtW7jzQn_P3t5bA7LDd=kCJTUTjtiyU3VO>gvjm#a}Z+ zqflmv;rcpd@;zaQ*#~6Ya~w80iFUdX&q_O!@r*n_8qecB2bw*!*n<1!n$(k!DQ)2k zJZHuX>2Hr3?LqomS<{j^%4vLDXQrlZWyQMcph%Iq;5!6~zauO3VL4EohS%+$C*qq?NG~)>#gD zw0P?X$=aCcbvN{FgbdtUmDVh0R@K2Gi+7#HvU*(+&JIOwMI{bA2RmqG+lTt@D*q_# z&gGT0U-26YK3c3odA4fy$9PTYdjRJ93@vuN{{wb2-&;7j^ZwWS!(7al3n$FSe99$}b^b*5k#m#HXI>^r_s?Sk%V{#`*;8 zpq<&2Sf~G1IVW@tbkp_$P$%qDN5IQmK-NBsEcQ2LuCodG%2_Y74ilPPzCK%zJ%lu^G~q0b@X2;${2 zjK}J*wl8Iyh`#p8_ua5zZpTxIxjRs|PofXOJ3({Jw%!cR+=G&~{x8Upw*F*}D}FWN zzxd8S!2KIscVnWi{=WluHp^y~!vQ? z>wkLtnh5<&`MPgsg??|yxeIxldA^N2ycmD^TlBRx$she-<*$+Uu%=70-H9KcsXfo> zMxPH52SlFK*-9gCynFL&I_Tx^#=j9KbCrsZVgE+FH1#@@f48AN#ka*zzpsBk1AAy~ z1F@wJABmab=Mp!sfZugjx2FI8z8jyN3B5)C-=R#V?R0&=y}l-OQ(r#F>8`#?zoots zljQx512JC1`yJoGyBx0_gz?B=?HxYS{~SZic<^D>BxRL;_bA44=R%*KVBXP)GmmYy zr`E~u8)W|eA<`gb2c}4zpVT~|(V7y#Tqf@6>75|^)Crv5u7^Jyeii!`POK089(@DG z#1XWitU|Th`?xFC3+3H_v&fs!mgE_`*l7jUb0ODW2YJR?yjAr2InLo@UWWatU8^w< zt$|Dg)9*bmJBqg6*f}rD)aIi{&`uhSd0DW_yiCR%5+BU@XLz1jK3iw`_DP*j|8eld zJF?ez1I8fN1z~G#T#ERq&1r+ioXvYOQTYYhl-OJByj1HaGehT~P7{-?sGk(fM=jWI z>4CM4p6HWPQAhTmUkx6$A#3m*<{U21@?id#B4enGt8J(|8|FmTPz?1a@$e(?a!yl^ z*|PVUS8}Pu67bc?bEyyWnBLx*AE4~g_qI)vJ>DFo%M4A1z2)~QjcyfK=uQbN_N4@B zuIU%Ns|D8&^baoerIdMQdnb5&Y0rCn_}vQPUK{$9N0D!h5A}$5`qZ>2*exgY0rI>X zoaZ$a--j3@+}%jmirALc(>t?bXd1?|I5!F35j)#ZwwiVLUHYwRfdyl>Ic^*D$O>H` zvY)*|o0q|_Dr;6DjjS6Yjm)7v;G#IUB05h)T3PF;$9#4k@=wEc4d!??>(qAHn~*d= zg}r4>Qm$vi1|H`%LGd>){4=*^Y0&ObyG2ILE6}H|Dwf+mJLo|=!D;Z{+Ecua5`7rvGMmZf+4Uw-Mjw;ujH0`ueBPA2{&&x;&W#txj3?v#;+ z-*Z4lo7SIHz^|vkzb9ku?lQEOOVM7eT6@Wm_wYh@S)&r&3sFYxcMoWz-Ra&R`kcZ$ zHD!HEo{@EY`4*p)@d)Nw8lGVC@c#yhGw{O-%yA@by%qf(V#z(I+jhj2nirC>Di3w7 ze&LF>L6*aotHmlw|6jmfd^^;@4i|jpJ>Z28yW$J=wWH1de^@K?%tgQDOU9|qD5L0| z4!s@PcEs5hnkUXvmFIGa_|l=#KKe(0TsI+u0r2*#QiC&$%d zPt1#VN);lV6Q9CgV{LWel(_6OTm=7bhFv7~7U5noKCeFByVPDdC0=~_lz7N}LsR{p zOM+FF!FLo{{OcMYuml^QyQ+{Ra#Z5;36 zfS!6A&kX$(y34r9Tu+m6%%dpRIHb|Wm^X_)`hMfhnw_#j&4@)}C-aloDe<{y@Z>Uy z&#CZVJLIJyKBouUVXLCYT(NQeF<y^avxGLIY%Jt zlG&E5H=|$NzeU!gTv!Kw>C`0c-EkG#yW{fl?zko0zB?{Womy4a-@i`wHwzBm|IV!_ zv-q;iG35Pm`}*W-?~l9IrsB^bU#WMQL&>=XiAPtX9W2!5aao}fJloo5;EKDiQNc9C zAv>P2BQCXnU<=}$&-RGT{d`;B<_T>!?}W%Qh4<{~^N1O3Xsb9gsOe|MDXhI{aSCa= z#;NFqs6#W|c}BXOUr#4>dSv=k*!FVRxB@X^3Sz`$tnKSD0{*Z|epm2o#K{ESrFjaU z|EY46!v{Wr{EzX`>%RxaPZsRQ^+dT&_W|*vAHkM>>A!xc7VN;DmS4s`nDhG4k4b!w zF4Om_*Pvg;I0s|ylt3Qha}@J_*?$bDy5em}(*w3O<<#N)K^w-g(pTLMo&82XDDA>; z^n+h(7a6YjqeyG^eSWj=125~pTD!pY2DBY7^?idMogEwacUQ1C%HlWrzU;UwKKQ4z zgZ0w(jsEWu>i-n_K0o?EFZw^}s|UaaEHe`_^Y@-EGY2v=Yi9>nd@eOV z)rNgV*%y>EV$Z;CCv4W>SJ+E@Arj7_Q~+y%R2pcruZw$E&d|y;hV}W_Iw8Y)n(#;wq*P{d@!*inR}wYZZ^=HctrueB$$w42;QB^>%xc*zA9(%^tp3)@IO7ZF)P+ zLz#0$*Z-mXX2C8AytnieJ`$r_u{LN|s;m`fy`cYgKi)xYFTnc+1^2=`-0^NByGxZ- z$hSw8`Gp^>w$}*us%%=rQP@YJ9t@3Hd(@~$<;kUnbkJf*!koaH!$)#n8L1WS^(w^+n*OU|& zy5d-CDk;Di)iGGzA^l(DCn*7i^FGo~;eRcZ)J%iVLRLH8`(aO0f#S2&fO1R0JTJ!e zY3H~~AHm+BKizVb<2|*&k2rWabT6*U3oKWv-+8q)rBl-~R=6yVJ*}vZ8ub0u81s0X zHjIz;{rQhjj%?($VYy{N9rCZmI0EmV(B8vej4^R7J(GgSt-`bDr<)6Hupm3+G^x7djhd zYruG*(dvr-3;s|8T!ClI{0s1YNYhSco~DgckoQ(RW70}h18X-pO|^e+~w|Syh|44$un$qk7lEBrDhs0Z1pw! zSZ8(GC(p3Y8qGdA9rcEN5_mUfE!jtK`x)$Wy*M1_(Kc(W z*xU3svu%o>NFAIlzH&YM3vHnWZK3P9*W2b~WqAuyrjs@iVb?gzuM* z)aqgmxUbh=W@stu&w}Tqz9qjuLT9OiKY*A2^K)dn9#0S3EG2DNpOJKZP;QwA+51n9 zKQRFP3Fh;DtCU~ji2i?&^!oZU#=rXW=Khg=7UHE5gR@a*QeRn?Y%K#^A<$#{fqg=3R(K$vV1gk-yihu~I(^wYDtlhGyK&F8MQTV7AjRd`#ke z$w0?|D##I^n~V4`74hNn#kGstdvs{jp%3$V?`KuOJzbXG2XUM;zGiK;}Y_Te-XZ`m8 zW^9$%DRz{#W$uS$PtHtV1OJs+E@iOC5|yu^?VH$-eaMIrD@G;#ceC5@-#@&s`R_{1 z%~uw7#-Gg4e`5S?`fiHhyH@C7`d`=cBz< z5-Y}FxiSvJSU}dQFy0#As8b7MEFf_M>tH1^9%#c^Yl#_CP<7aG zVE_Dyi_;M^u&y;XY}VyQbyXGm^P3>A{4+cwywNvGO!MD{vBM)c!wnu|ht0(|4*c5K zLF_KEiTikoFA`_EuJxy)4(2pW3wnC`S0JX16+JDrb7Ec76)4A^4bSR+zM%nQeCSe( zxL2E6Fjiug^ygJ4!DHWj?rgnHOMfnFb~vM4S&aMT58;dv)&$CrLJs`DydC?YxF_Qz ziFd6iv-}=S+9TExR>&BvpvO0l!4&-19D~Vk2Sx9i!U)n?Zcu&T#@=g!EpZ)q?q12aYgQ%1rW#GD#@!2Z0g)^m-F^UseKz+WoqaX@0sG^Dbd14e{3UI0!_O=W{)YP5uodwcelEBU^<0Jdsu$@m zmwJQmgu#_>htJ_V4Re_y*m=Wz{J#TvcA-V{(V9^>PoxUQ)ilVtA~mK4bt(2;3ZHNy zy&rlDmfrN}3rL&KLRxNP^1NyP3!$(0g~Tx# ztBSA7xs_s+Pkak=Y>W{zL((=ZJzQmd5u=vEFS)NYWt)ER6U+mnM!kL^^mnJ)r+0*L)+YmTQeuU_M7@e57uzIj-g*q`FekB_Jv)?(DGh5sXucJE#u^Qh}FFitCw1O%@zNW zxYjJb34g1@w-(=y>hU^=XQe%hkD2jA_Gva8u`Jkuw2ing_e6Jzv)m_|WA3|9Kb`H@ zK02@iHahaJDAZ#suz&zqc$phWiTW08K%zLK1uVSXPJh`-mOdy8RsN)B6V?uH&4p z7wZ_%uXBA>&dDqs=89LIOl*_>jpa$Xv+-V87v_R}A=}i0|NpL57mrNQ;$b=VVZ+E* zxB{$c+S8_BZwC7#;Ov-7I)Zq=G{y_kb_?xO;(MT<2lGq$-<{GfJt!OhpH$Oc-JK6A z+PU)WqF$R0wT}GTA^Xk)hl-Z8t}j;hH|;$xUy+M*jWT{o>x1ud+ z`^HY}b4fpUy)_tgVo!M(ewX3HZ|>fSuN>*z?2xxGne2+y`0p z5388e|1#8h*SdTkdCEKFf~W(}!>-sm$s1?w+n@HkwSr5v z^Cy{M>`9}JJ%~rH6xZ`^d-H@szk0p^XS*xV9<_ZV#J_U1NmmNiwXqjffNxg{*0%9` zl;VCk>x=6Od|!?<#aZxEd{^N6@+=j{ZrAy{a3g+t*vM2clA4&(B$* zp7)?G>{#QMI+FOJQky48x(cL|dQv?ktzJ)Q_(QR_n$7bo(r)rXSA)Y`5&vT=r$fOHVrWY;Ud%&${J@&0#VNB45~u9ghm<&_CVf3l z-KFghWrw8ymvR;@#o2$nKjDelD)<$i^W!{Z*LR!g^{xM|8gXc)>_0w;`W=MNUc}F( zD1(&i2vr3 z_LKHNzXa;S1D$_q%~|0DzX;z2@Cgfi0&QYKk?9jSOXz?<7s0l8ujAHi)JY*eQs?qp zZJ8tNN4f9B^HN@OZMEx}ZmCl#Poq(Pvi@W4?@1eK+Lu_9gSxmA@n7oTPLvVlJm`T> z)>x~W#6QKBa;9E%#e11Z<6C3jT4US^ZP2O)H z&-&z9rN)W;FXTE^;eP<)3>oU7IgvWfJZpqBmCF16c)J%dAA7`hoH>&ABI9`T+>u(0 zwiHL5XA=YrGBQV_9a(b=3A!xtaoPzOTI;>$lGtj zSyYTCd%^F_z0j#R>od2w*ZNBAsmi%-_+h07``P#oEI{0FBACoA`5Pgcq< z??yO^ec{vIjbN1XJd{E9!9K(LI-}oXpHl2xin{#(&zbG%Yx}eC?Y0%Rpq!tOJz6aoP_->b(P~XwV(*^Y{i<;%HsBcfe`KOEp)1Y%i`E`m)jP&8)qi;b1d1R^U>DL z^MEeQnauNmVf2Y|K1k-DYC@VA-X>Wip%2`4WWDKEa(U*5VE5Cu!o)r%Nw_KjR z7-{9bPUf?H>De&+y=%T+l*P<|q6yiKgKl2?IM|iHYznCQF zdGzySeAe5(RzFjhRe*OkVVzu_t;Ms-rpDG_E*|Znk1bkz=8atjehJ=}YR0F3!)9i? zDxla_fcNxCyYe8$_QyC2wpR@HCX$Y|~N>yS-rS6-cuM_om=pJz~ja z`0g6}U!Z(tf5gn!W5oVul)b`;{cj@ewUBuaV*eto|H#9bFZchD_vZ0YSJ(gldu9U6 zB!n#+;F16?NpPtPl2nihD67_f6s1}<0os}nt=1hC6G&SFK|jQ$OK3~bRx_jNM-&w7 zLVzx@v=%;Cwe6>Mf^D4;HzYs?#eAQy_Y&S2CL~yF`}qC-n8(b#-*-9Z+;h)8%f07@ zzwc_J5}D_;kps-4Qx1Fg{OK0#FH-jVwBg|WpsTLoT6=Pix9SEnse8Ot_bJN$#l}0z z@0`&ZyX^cS;3fXu!uSdI2KM%dHr4pfr+bH=w~n&?DU-|Z516CmyD-Z?XOCIK$ETV) zrCA<&zQi0mKtH+sevmfz^E=A3y?nn&{XKkthwt5d{~Wr$$G1a!_u3M4Juh+newyEc z_uI7XtSu{m7qS$Sl77K6CX6!4Zf>~S+u{Hvb8Q8ob~Z5;NYxX^Z9*>joUTgBN@p4 zgjgn3Z_F(VtTRY=A0V#@L-1q+O}Zpcoqd8 zmc6VPhiG;kxZq<6MULbAWt{H18vZrqB=o3;UQ2CQ3V}uPTQWNzJhZo$^EhT3qSFTY z?xK&mu3CKk7Gv(re>Z((n|7_M=Dz9la1!mBwt%fy1nj;~bkXNHexGhXPX{LVx|j9& z1m`5SUl+=xT%tA4eNLi*wMzS5wGY!dC(!{sdS1;l^fGdY98NE-w-Ibj?Y}GpE{Aqk zKo3VZ*+o00np3t77B!e3JUiROgY!T9UkI(w;Q#rI&1ro9g>^CCe4ifvE598ce~o$$ z&h@?6QLn4t1Z%w;?_C41qu9&aqa6kBN3^z9HBD%xTq1kMT1yX|p)mKB+UF-sdW&3Z%E{-rSLvEwQllF6|TS$(9)Do-;0a zUQeuDbEaNvCV9g&m&a4K41ArnAjMU;H(Mf?vY&C){RkR6bJcB21nqux9w685cLa66 z;;Q?OtFGIY2->zp5ILA@+Y-st{T6i-$$ROv&hyW?elO#<@IB5o7t-PH`YL1lGTL+I zgyy5E|NdWh{Wr_jf75!H6K?%ia?XQq;PENN=DBp`6-kAECGVuqN)AZ3)%hmL1xH4< z!#|E3-_38w7T5)R(o@SGvvt)V>x9;lGHeijJ8Q}JTr_mc%1YLLjk~EA47SF717+`W z(FY%*NuS@-muPZP98I!%unDrT30@X_3FL&ECb9_XnKKJSCJQE2M67er%!j%7RSh3044IM%u7{B3?acF+nN_x>*2Bk)6)Pm4B8pBDZ? zQ^x>jou%vYY4JY7JMmK@dbs7L=&_UBZVsP(101BIC&M3F3;g(^az`b1TQ}VHihJEC zN0)Nejhk(~>e?P~P|hvkQ1AQRghV*#z205b3l7qgu0oF($ymrI6+>S-V4q`j)J%yYZ`S(<0t(3mvDZ8uS1kFRr-m@jA zX7~X4rv0X_B0WX*G(YaD2tJ(sW$WCfGe>s(fqM3NlgOzqeTy~9(I={Hed2w}N{84_ zdmm}Pv&}!r@Qkyb`a~ytF0#IK&BYC_ekxshoz_D2qxsov_wy=cWxr0qrqrBwJ!lE37bywa5uT&mb__TzTQ(&vZL9@UMbORM)$F~ z!PRGFFEkT;q8a*ZesThut#7wu1b5T4TpDPVLYxgSn>jOUh4I2ET^Lb4}h< z@@x%nQy$Sg=HQHzGgd~Kr@6>!o!eB-&~j+_f825A)V-Rzn$Mccn$wa?weV+8^SOb3 zln2v2$CX#}7V!9XddCZD%RQgMJ1iL~ou|vMdW5;8v(ET9@LQv=S9u#HlOk1~#@B(f z(`)QL9Up>lm!4yAb}u@XI4v;kCr8FpHs0mnEgyLlooxZQ3-2cR5zxg%uM=#XTkugk za(Fg4x1NJvg)^qnvDR9J9uRBMK6DcvqxL=I+~3jT)SvRDipG+8iV3IFPb>9AXXThx zzE$ZF%A=l6nGB8hcuVH`4>C5?%{V!Ix_wIh{Q!DgMEe)= zacrfY=o59*=YC&kdJpuO`!A$VCU9qbiuAb>`Wz(R=0|+G(WgrLDXe@Nip`=YZ42=6 zkK^3=qf^bjM(LHD`G4FKYC%rR-noalySD0rkaEvUF1h23In0Ins=p$aihGeu#`X-+ zm$jflv1-~@`(1Hn;*n;~1J03a56{cMt+KM66P4GTkpA|I-tl`TnR6w=$-l_jOBHD1 zj78&A?uPV)S`~Y>@hmzZ~N-|>8;4|u+bJYQzxX~oyOjo%^s7Q67=oy z$BzQPYx;oSQ{Z=5U+@cA{ArHgMTd`{){|qwr{zb1-${MI?^f^|c?A5Jf6w@DoEpm; zYK>p~{9Ad9@EUg%c)d%$%iiYSMDY3><$94XhxpUu8oxgtK7MnL5uP7z>-+p$+Xp;l zpXojjbA35nejdW_5*L0~9X|i^juC!ajsm}X`+(n8^vzrPg5SZ5OnGe1zrP%g-)`jl zv6z1~M}gmkeZcQw@Y8)D8o$HNd%EI^vZ*7A38doZ!oE>1rN!)jxSbf8e4C0pyuuvn zvi;q$M0}*GpM!tWKfv;j?N(WA=jQ&#x-X*>I{wiut~N^O$BDC{r&<03VsE*AtBnX{ zFQBd)hUZ-MWluTvo9w+BP1J9&_iAjjVPNmZx(jKC{fhZB_;z%66FzeKDHo9QY_#jQ z-dB^ScO1{83%t%4>sfAp<K96$0AP!{N!(P*G zaI)RbZx|D`6J>9-k`kJiU%gPlT^5pyj;IWVk-#7|a4DV)VGnc#aPa>{Q6*}IpSuRW;Rv+3|c-UHKOGq0E$^B*64XfN~-4>;rhR zjUdP0JZ;){BA?M>d_1|xm;koAU-?t`-HJ`x(|*XG3a3xWhHk&q&LQQqa?{9<6NRVj zxahXY=YE!Z(kd^zo@e-Jo+0k}j63f64eSZk`LnyuiURJP#vjBp=gj90_xtIEW}BDs zEYX?I26#xe-4nEZ33R_$WArKE{{VfQOZ(@z$G56K_HjD-Ci@X@&A@M#iT^AMKiY6) z!H7@*Ss>r2SGYG0($U z?y985R$o$~vH1Q8#^UM;5$Y-z%#*AK`h6`lDaDr<#U_o;l3bbI*n-bBGO20eM}M9b zGIM3UHzO3q9~y0&8H%#Mxc#+@L;LR}&-YuGgrX0#x2+-&k}tNiB01EFAG5O}CDd6l zkWVU~K_U5sj5Olg%sI&dzd>90Xd?rP8jpY78`_!HG%@`ZUnuJ|!(7+=ZyWSOxhQKG ze%0ZBOA2|aeT{h;$hPT*;w&rt>!!w{PxcQ*&SanQ@XCqp1Au+L$MhZCz<9P-4G2Z1 z9lmctzJo~BuP3xlV+{=)zDL>dX|}xSsqL?MfDhI51<9K z?>#$ahAQx@7NH~EYM&!mt1{3w$p1Bh?b53l+b=N2a~SI@@sVDEA7VE5#q~G+5ZX7d zHZ+$@%v|tkW-j>0sH;53d*%dVm)qyNR+B$-KX+4zH`e3t+sCKVJF;yP{hwg!J;TF~ zQ11?NpM7Symfz-k=-~LJRW}iix*I_;qyv0ZN3?4vMpo&%<6{x+Jp#O|cwdB^+3!Pd zLw6H>h!L-IXmcy&+FzS#o_*T{Ua#n00BB;E_W-1Ye~k|1Zuk1GcCEWZ+QIn|&MZhD zEa9C=PyS!4-^|??sIU0lRs0|Kk(C4bO1%S)$cLS4m3R3{XeC_DvE$k2^q#TH`LJ`{ zAEB!wZx7z{B4c9Z`#5mDmvQnjUe>*dom={E*V^pN$K;c~5L&mzyIu29`iOD^<@Vza zQ0C*t5BjaI_j()s%)@#wx%RzABliIngr7P;RPRk{tf!vl;x_n9zkl#MYc6))#Qfl# zM#HJMhc@~$I$pf#j?l)=aiO1Hekb4Og`O|Ii|_HF_17;9wT@w~Jn0QJoO*X?W7Wux zjhzL&D-6~5zmR!cGa*v7Y(jniDUAo-^N|-fDYWkm^4Y%CpL)!#CkKRDs+LlwdV-P8 zeTdMbm3c($FxJZaJT=z3qbL-}rJoe~v*!JZ zyh7=5siDaA%uD8U%NQ%?>|MyHwN>Zf3rz397q|mo;Ory&0>}8a4}-o@_`&k+k(-M4 zyXG^v&V+|F4%7K&oVoYKy34Vncnb4$GCZMtA-`&nUcQBVmEt92S-RTnnnSc1-|o4z zCmZ8=yN>!e)8yB*aKP#d`Jcgl8_EAn`pSamhQo6skpCl1UC_;MiFmDZ&*1gqvxsj% zV|0E}VZ_&;e8Bx0cRe*E6!8TbiKm%z-<&V}E~j5p?jz4TC&6#GBHOj+X~2xe=sm&M zhhLn<-Im@)tqYL>(;E-Wxi}Q9;M~vk$b8m<{qsMEY)9V5$@MrM@i6iGPLGN(O`FAL9wQI|HaCYSUKX_--6FL8;ek126 zN^fBg%^Uo8xxb?<;YgZOV~f-Vb@g~)9t$dpse!8XfNj}d^^6lf%b3Zc+i=rQk@C#8RNC5NcvYh>!{;1 z+Y5f9u-8;3>aos4l(Mh)9`GMR`9CrygY0_$aMgQ@dS?67EB$zYxrbi${*Df!82p{o z%b{I&ei=tUv-0x~;67vzYqUR9itX1e7JX7tXp*1(6x>m!vwqQ2`-OIGA+DHap7(21 z{Q7dv>&h;Xo~3;$Y!&czQFkKhZf9CuZG(UMqX0fpQvq z_nB6cZkJ9+{!i=5vHmQ1Q`hkMH2T^D9qVZOyUNX4btvBkzM>Vm`2|T*t6_3X#@I3S7 zL-vN~ld!$jeQPg1pMy!;uT71ynPr9U1%G6;Vnm+&W{+{60c_VWxBR9LF|EsoSj}GU zZ1TNo?B#=Y=T&gpBUZq8_`~-?GjzcG2)07?!OnBl<}|xa`6M;3<(I7V+I(^I)YxF? zsPYlnudK}`zwkUpJgz0oLbW;vP(N27oLGHp5 zZ!i|N-)aAt^A4GvuXm5z?^e6sZS zudy*P4$E77UB?VhpeBDraKlVbO7e7% zKRH92JbqkRPhX ziscF}r!O~5*++osw?}{}1DNCsHSJ@2Oy+{4*5I!&P6680@A>?m$47HKUcbmC)?~`) zbMXhk1760b1-(FbHpI~J>(LWSjLPxZ6O3C7?3Z)VJLZnQD5Shn_2^4E1~x^$)n4f?eF2;V59jJu zO!l9z{p0zsQMLsd@8okRev}s83w+Y+g=0SRTY7n}ji)2eI(>)oKka2~+AsBm(z!2G zedsRh9O7yX-t?{hp-q2!i8~2K_w#R6JIaIeN7{FOUjSUCmnkks{vqhFlzUhej}uLl zKQIM-TYlmSbnd7xIXnvgd9|4jkUW*pX*&6>l&`U#JsLA8FIwdBy^8a#+IOM)`Ftuo z$>l-nCZAvwD2K{kV9|bFwecA6YAtIr$Jm1Lhm3J4dD1lBqQD#=U)oY{phmEX-^<8{ zsQnJ(m?zr9K#ttl3{T!NYfnYe?tll|3cFSF9h$`2#~6jjLBj=`iwdhhp0dOL_eBqJ z#$lLpIr&>WwV~0k)D?SD%A44$ZnYH%zXP1gqqdiMYwDUlYY*n_HeAAief4JUyLxge zzfAc<TZw&*C*j)>xZwcKmO7IjFaw8@|tKF9RU??!qDid6U=Ctq zFortIdjPp3yEe*P$SNx+(Dyp?EJa4!hv>W6W#<=EVly{0PgkQOOV5!1NqPwKE&p}z zsG6*|tX#_~gWNIS%df98#6$9(I~V+KCFzdPLeZVLN`7>{cwnCt!KaDS zHtzvWf5hvlO*h|rYIWY=ktLp5`7s{Z?5UL>;}Ng7R{oJkCVOjje&>-T-dex;-dn3Z z_>Xvf<~)6by;~aRN0#_%(~y7Fr=YWQpKd+#ORxxzj7sutP^LOLxFPKX|FHBEh78M? zC?CGo$`R&V{1Gyw!JC%9Z_ZTiGFKjK-Pd*zcj5%$`wOwtCU@QQBKhR5`z`89&b`li z;LII;%m4Wyet+FhA0OXJFX8TIUpo2s?lW`SML5SAI5^qNYo~m6%43&&a8VC;VSV(_ zXN~l&`pGlPrS2X3s>{ z7w;z5BmY~G169b&>3i>cNbAK?WXeY5-)898z;E5Z?Ub8>Oqzah@(#(?S*`azR7MWS z2IQJ#+tZBm1AN}~rG)GIRW!a_WbA${b@S7e{U$XoNnP@^@{u8<+Jf};8*gCi%%R5i zS&Js`DDP(sE$5D5$M?>veXf_$*`h|d>6j^!Sy9R{#v8Ujux-arpXu z0oF2OdouXW1mBr9zPo(MTgQSg&(^d}weZch@y!L_D0gY*f^W1x-{2cf=DQ2u;cd}D z#)kcqEqre?ePZe1-N@sHZBU-9LOfIa3~GZ=wHS(T)WRN(;*S z2MbvPwrgEo`T=Kk85eT>mZM+HE@KT?;57=%7UULW(ryLMm+-ul=UOZEZ9bz;8Re=! z$S#n)DCal(AqxddIc3z|61z+dW#ms)yXCYSh3EGX%YMo1OLkDQS@xw9g9ZA%1-?r; zSX`hrRll?0tw5}E_SQ_JfVH{s1J(%5d*vF^Ipfd&%F_AT&@qVF?k-(0wx9<6q59+E z0^zfiewRXzvFIBWuFGs-vH5qE!w_ywOBe8Sm8_@adwok`L;K+ro*Hia@`jw_re1^(J%0a&h~q}TMcL=`p-b#y$gH+^fc8|*?H(e zmfi(Fv=kTk!Bx+z7|Xv=R(J8%YkcT8+mqH7_Bs&x#iB`clIKOV216#T-|?dT4Q)5iCsQv&xfNK3Q`km2;zpQK+-C z;$`vi?`%G9WQ>NC-dHfS)Z*iJ&U&D3F#iYB=0@~xwJ$!dhL8R9_YU=&$z`&UyjzRm z-_+9bg4EKy0?F8o@NErx+mC_!4dDIpng{D%2G+r)UoGhL3@m>Po*rC!dcj8Ue8)G) zs+gL2GM>6bM8H0 zeTOl5pYOB4aqxkP9YYUPJog?r4g)`5>DLO1y}t4@&;IW^;X9OeI$7`3rf?Kqo!~6I z2AAFd4e|@#^9>Al()J~sgMFVqv%SXd_t&hb8}f0{!$V7NE|}yUR6Y-!hnAj+91sjc zOuSwLFK6!Q+uF}*>Fe>ibTjd_NKa@!B^b*0__yBvV6Z?kfZPDHXCaRVdQxiM^^FZb zKpys)oa zd7eLF<$rG=zjfuj$@G&`K9{zgz2fh&MpdK#w{Yiy>_6SNCH-IJ>ft^0F^@SbTjZ5j zi-?&Ze>{I*#%)37flP+l4Wuqx88%8+gFvjjYZU?TPV(Eg! z#Kcpt?c^?B&V%Owe>*T)F}RHIFKMFzIIaEX_*88;C;7k!Ik112V9Czc9lHkq1@}T^ z$^rDW&vnsfA@mt((q}RBfAPcnP5MZ$i+ z&N4>Sr2N8)Svq^#nq{kHShkvVe^Hic(@DNsYi9;)XIA)^^pRn<%RR>A@>d@J80(Ca z%l~J;l3Yui>Rfadujr(X5wQh^=6Xy`l5#=qs7zN$i^UZ1v_cC?(fqb9Ku!j zWl?7{zxBV^pbzkQjPuiiqlwQH!HJ#s>Jog8lvTNAJ`T)tIK$zxq8Z-F1WqMxq?S?NU%t!$pC)Yf9t64*MDNH8iT#q?DEsBV{8Nm&zVn&dB^di zTjw1t`M4i{hO^g@+%TpOV-LLE2@gqjNH%0)Lm)e1@X|Wv;a<(U_o_EztMrrS*~2vj zTFORVJzsapXNN0U^BdSZ#4|I0@wcd_92D9wc^&_84nWt)||);PuybF z)jqIR?9xePxdkm_f}zpm)vty=fmGxaw2}PELEc47+cm2#NPGK$S-SmxY}I{pY+JR; z&NZpIvHY~!izqW4_#D}g&Dg5$TRhi1EaF`r>v{e`{7S49Gy5%i$nQz6@lRw9ocvOq z!JapVj)&w&_xl%$2a<~lUW($YL_dB%Z_UWs-?(zyI<`X4ll^K`cY0niO*toZrafIa z>i5a~)*j})z$HGCTzQN+d^_*72HeWChvCPPQ>^`8FHo*zr1g6(zi&h4%XhdM+)Td# zGEo1U`0wn8Dq$@OQC54uZo?n!*i1iETeJ^d)~@Ea=(37$`9dXI6~}VoR~8*J!r!*b z$=*tI-$GtakbM7^jh@Lmn9Y8P?0b!n;Mtei@q+B77iq(7t2dzY-p<|Bve_1o4u� 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 z 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�^ajSNO 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%0DR`CD{LAYM5Mc^y+7Dm@m)9wKlP<4+ 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 z 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

9>{A}#p-ad{`8FY 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

CfL@nQAV`w= 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�u($xRLQPHsdgvQjT`S5b;^ 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%0D(v;ybJy30i?!T0-A1Y)B^BLGT$X&l}DL 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 dP70Uc2|&9Ef27pMfMP!e?j0v3RMaj|1Hygd zq;N4#D_kSuLbLD+oH7@#(KyF(p~5xReDoKtah6HpYP{DJuFvCsOQOQ{1sATdz+AY- zEBqZW7p{q>(?op(m^a?#-r?G3ncY(h`^CnwYq;M?*%iQZ)8Zt}#7gQf_zf1CH{Dv1=$&u*49g{Y{{=6zANp^6W=!t)!*d2g51NPKJ5( zAMaFHLT<_m`?sZ9M1|69puJzv25aMdp)_l2KHB>Qu)`74-du1N<}_Oe%n{SYTyP5h z3z*k!A4Jv2MbRiY`=_z;SK7Kqz3#(xfCr&@Jd%4p5bhTxH;Gv7BptJBIJ_{>ztrhv=rzF@%#OEpb1fZ~U z!1JwKzWB)n)|&W&DEZWaLI5cm0lzfxG)@jC@_=p|>+ndp&|G4`yCY1E0qWe$9v{ZCs zD#?uJKE#jN%BH2F`^bDWsW^S4q@w%8{M5G+r{Ydv3KKW1lFWF5uLEZtg`YNOs3cRH z;2c0z31_S%Q=8yAKpzs$tkeU577&iCw0RfZ(POop!`!4wX>*uc4ktl#n47awSi;@3 zY;j%l(U&c5Zp$QFI$o1(alJ}E=B8|Uz}fN@FwJ3ZP~q=^DO=pUm1N=<^(A2LhWw@* z1jk)Zlx`?wPK;d(lm_N*C|pSuTPjucxbIVlPd5FG~;zLtt zA0A7yOnkUU|M9YhCp7VewwD@{7TVq`_>+6|+=EvPe}}9^T4;O4%|{d3XJCgbV2KzR z)3zMi(c{c4^J0vIw%`|mf1ZgOk`-fQF(DLIHyS}56j|AR==5^BY zyKWv{tz4en&kn}X(^qvvO<<0melgWQrsxqX9|G?nEB&n%iY+I&-|_*LhwbB(caofn zXx>1d8Pg4Qz~|7mL3W?v{1&{GU}uRBj>%h`Ql1Y@DgVQGN_j8bqyKn8{P7ci%1`s9 z{C1o2Ghw?&DCK9Fk0#~!!w$#e921XyIOQJ!b386I@hCX|1S~9HLAEY40VcQ+@L)7= zh3P@T!-19)UKt~koZz)UCkU@r>T^Jm6M@$#brzuNgx4wcn?OSeuaA+}S&HomK-&m! zRO-Dz4+(FIi5fv;DeClJ#5xtwyv^!#UI*fU_)Zxa0L%gLy(uSbB(0q6^OY04yiMxI zLG<>jP&xU{eDs%-LzYQ7DHM?;U#lLDnNWbr$$Bm)?*el?5T&G3nOH82m~ zA7=Ojp91FLJ7Lb3T?@u%NOC&-j{CVMtt(PaYJ&5yo;Ll!@<1109@aB4GHHvIFMv;@ zd1tK^nY1rje$H~4wB3wJ&P!c0ZM{t70fcv6(SFCYybg<=DEf+^OfuAG&HJ=&d=oRqFnX&D<-A5d)4fX-? z8_LnXKpf0}D@T_Cb1>hEkrz`+kDda~8wn$~t#NrVWeKph#P9gz#-X0zKhn0lb{}~$ zH>4V+>hDD`63SW2HrzP9$4d)O-}HzDn)k?O#tt#~BHH%Y?lZPHEqB&~T_XM@re7thed6dpK%A=osn9JFljO8U^PX8N z61pFOaSDgU%4$Qb%md~W4v&?ZF6VU!m}`2vSUFxgsp88?P&`mexT6voBMGEVRl;Hd>r)4zzNz6(nboNrRB^BS7> zmFYpj^??Quo)jw=^nyPDT26SfQm+R(LwHK8{G?LUmw`A9rYUufuT4##9xFAS)oBHG zNo;7ncGwo!6*%=%p#r)%B2-|{bAi18%msF>!dbGL0=wSy zrKl?bb6;*WeJQvjF!$wV)0gZT{;p$^Gp-#9>=x^aMCm4Q?&I%GKd?M-4w(CRYph%< ziK{h;EiNtmo+Y5CT|0~MtrwVZZhK@c%x)&+hg~UFOyq=eNO!6Sotzp9GVKm zL9$Od^b0W8%3oroR*FNuXQAB#U4c2>N+>)P zn0us@=@C)?49q=J#`K8b2f*ATs7%VBAv`&AE$w7qAnA zypomEl;H%jfpHI3QSz67`;xq>mX84Ao~^FrTYztoyoQof;om!zqN!N8NB{APhbJuY z$5UQk;jdx~e?dg*%1}HNG9OJmoq`?iy%bZd)^R+=Pc!jU%oHoZHGp|FSjrSD!2^JK zrY)oJW-@~2m5t5w5=|4Lj+lDKM{3nrV53LO3Y(W((78V!bEu3N){!l~Z3kfvsTN z%dM6CK5((ZkhjtDN?_dk?UXY;fR~WGy_K`?6pATtB;hXU!;BvN$9f~p$R3~!vw$Znb#|b)2~Sb#)ElXB2({OjXi7XA)P`C5uUwbT63172FY+6ZeuyTy`xu3wZKTyf*E! zb%nng4g3Ml34PV{1Iq($@gzy;YnA1Wf>>z{ycf;AZmr0L`gzN5SS}ap^)-A69e^MQ3Ceyg(FQ4o(l1>#zA$Bepov=ca8NvQ8yEAstYHZZO+ z|ETk-56m^@U!Oxx@C)GkWaYlKBIgxZ%J2u4%Xu{cpN8f>^qDc|wGup6X>5CB_mT4| z0oIfFV|8AmfVjLpRgUfk=JNKR?+8vXq6`+#Xznv>TpaCbxl=`gF`YQN13c_S=)4Ah!MNgPQu3+5 zzmq((mj4CDl{iYt^Oj3;TA;bnTHXzeD|D=qF9*I(@;EJj3dWT?Udbz#PjdR9xmmS* z3>a7RY)bwMa7+cr16uBZaiveJV!lY>bZ!mIl|ISW_jsQfaCAjjNw!vG2=jn3&tbU? zVK4A+N&lSBj2XgT!K+omww!h!8NzqLz9F7V4dF&0o@8<>M;`$5B;)yx-~`K7#-%fw z8??s7(dCxsv0NN|241xa^m%<|jHC6zx6`(Kb{}!{C|Gh;@chcrVn95<6;uQ89`G_! z7qV6)*0zH2yqBWn;nk9yk$v$VmsBmU1pxX9H@?i7PD65 zI<_EKd*a1?a&x+U!H?3m7wkTA9eWk5NDc53RpdHWYFjlRo^nem|33!aLF&@hik$B6 zU_2GSsN`8|;@$+<^peppP;R;G!7q}PUihgz4I<;=q&^mPpdYONJ zQV-oaA+%0?!+i9wQ{S{q)~O5MFzeK}s?MoK>(og+vHc3n>(sXu{s)-Hseu_MQRjHm ztWz7BaS~h^m|ySP*o+gq7VHGfulH?YU6HH#ufTcynwoxKd0-bXk6*K@QnSU%1K^5p zA^e(KD^j!H0{et`3!mIX`c&{Mw5_GxM{0K1+euDoG`Ce%so8SmdO#c^ZInZUfH_3k z`i|fPR|4N7BkinlaVWAr97S{6`{c% z=iVHXd$+kp_5|h{xzOaE;03_+^s2ke^oHO+fa8_}uc#_3e8JBFH6*-B;f_E{39nIj zCs6nb;B^WIfL!TzN%+lr8>$T zn^vv=^i}KJ)l9WMg#q3gs@7-BM}M_GYnfE*O8+y}`drmrwdp87a<%RW%+>n5!V7^p zVlJA95%mdRj+jd(Vg$!EO_GSYYEFz@3swWB2WH)C))l!?-yNJI>4xbZkuL&1jpp98 za#_$`1LFw0rQ`*h;Tj&zy{+Xv!8r2nD)~m>$0Wa}<=L8JbxpzauadtBJQmHpujRAA zI8q-f`5(aXEg*lS<+;H)f}g0KX#_l;aax|C4VLms8=NyU(cd$HLTxcjl$lA@w!B6;BOUf;=OkwxnwxB`P~JL$AHn`3osFO19R^TGiSiA1?B^D?+j0oUuQB7UIcFNJnlYx zYCV)+XTH?l@DY~FuQMls|BmK<<}+hfUT4AUb-=cfb|3k5=DT3ih>uE2IN{>M8Yh;PZrESL&z0 zRSUt$n@asI&@{qtDfK#_$As%Ebzij?*2{%^i zp+LI`H&N=dK!s9)n<{lJpwWbzDfJ?tXbPVeh2_Wc5U0VMH6#3iQg;TLN4UGf>ws<(?y1f)T``P2n){JbzYR2waG%1m@R75e1;o>M zKc)T?n5Xgneg~bTj2+}bHg`dU`4NpfvT*3uNFh7Vj76Ab9b`LGZPhl9hm2tFHP|g^-y4*g(sQfBX~V97oRESB-ypV zEnqG_Qwz&lg>f)tPqH&4djQ{fTMuQe(jWZO9N^QHd;{=P!ZWN~)+*V5PIhkO0{^D4 ztX1ToZv%5_o27gi56q=)wlaPIIR9R(Xy#bs;!8QO-o)oB`52&Egy&hg_>y5?vhxy} zJ74+I42TQoLgmZXz+5;NDdWEZ=lcal7F*-uODVATi7!#|!9b@8FST;<$j;Ob5Z&DqnH{ zanWC|e0c|$i~a^>d;;)aWMrc?F1|bfEB!0@CMB-}w21JxRxZAL2lj;cX5~x#Z^<&H ze5ZVQ6PTxz@0IcKz*o@Rt=72s@(ir%A@FTV-VkUD;q6u~z8nTiJPiJW@})QsPgp-H zU%CSGgtb!{Ukv<=jQnJci!WJ^Bs*`Qxx19S4bV@7cU!smavbcrqu_g#FE0S`bhuah z0?gClK4p9n@WY>Q74wTVF1|bkAGQm8zmk{#9dg14tXzDV3SM(J_(A2%pTIoX{-%7% zbu3vX+e6BD3*gOY?qO?Od^rr3^auD6B`*Oqh44`;7hl$aJtqFU@+I+4V4BMRP`)$; z=BfNoWqb~B*l`#+ZjFmCxxm^GKcVD9fUXlhY31TeqT0Cp$gS+$+|&_%aUcF!8HO{x?vgGr-rZTzu&Pwwd^K<;yW3UgX?VzT`feEQ_4K zmGO4KJJH-**0}g`4lLyy_-!Sx1GJX#9V-`K4uR!54}MqqQVEEcQ2&@EluUvj0#8Z6 z?Dem;B2SVn0OzIE1GDH5`8nWR7hwFMmCJK#&x7%j>#tOw(zTY4qG z0i5qI$Ro7;1u$OHWmNLkz+aL)la|i_yO0p~@wADRT!Z{MD;H;y!FZvX zD@7KnV!Z+Ic#^wTF89#pfbjy>^IH#`AUWNK3aWk#Tu+w!PGpQud><;WlFtO@ z`%w9;T)O=~aJ~UrjEvUB2J+2{5m84^@-PY{8p=AELR(%w0Lb(d*?^ zfQO^GCzSeYApSd*r=QfJzTcL<=lmzDYzprM4XR4dVs-e@nj#{&IA_?l9mCbS9dy0Tpy=sm(W zm3k1+cZB~|>is~OzXiUn`XmwP4Z?Sok^cdGL--$s*8$xnd|w$!zZqY0pt%o~x+Tyo z!jF}DEzlFfPyIOUwqI2B(B)Wrgc#rUi>r?_qBHB~*W- zIbDvqw0mGAFyHpertmgkz8uS5-2^GC?*ns?CRH~<%D8AxJbFh#`doFn7sRdwy8py{Uu;)|O zosaPB9{ugf{8ld3%Y$zm|sM{`SAj{X4tfb?a2W{jiZ{qPG+ zH1|cjk2u;5Y!UIY%F%T|ToTGFM{fXgNvKf$N`EQ|(xdtN<7ZH4ZbfUH3WgIH3buuK zB_-btRA>NjWh<}rB87cvux`YwRA2HQeeWQhHV}vlPBrDrcci2eQr&m9PVfnEvw_%D z!y1=P>juWWrsdLU+rXVc(AV;rF`bqGK8Uu}w);q@O$0ka{3X?CSAn?Jy{sH9G&o6W zU0vT1oM1cPU1;tr*0?x&%<@+)7e@;YNpjkuxv%-m7)N`9pQmm0>^|b?zhEzZ4F0-u z^c5g3vu~F<>E{d7?<}J%6cQ7sfz)U1?ob0iBb;(`jPNbzdCKX@U3sT5MRSA7rw{1*A6WgwwaIq<-&H$WVw)GlvytP zQ2ls&S}wf8GktkrUM}oVxFawx7j~LJ67^(YUM}o1fh2f0FbC4l=ET^wz`wv8NPA7y zVI0gi8czkFx%;e#QoIIQ{)^>OyuJg!PWt^mGp2a`3;xy^Y&&50k>b@9Y#i}}rg(`* zQ-L^!e^ZX`0_GS#LT>!I&ShTpS$^zJ~Pp9rR#I96G3RbTfFi zaoF~|-A5eF1@er|mxCXw-Pj>S*p6<>>1`oVn+eqXU6CbI<#Z-~^WeKO-X-tZ{KP z^8~{$S}u;h4Bi*b{mW;@I64gc9BsQ~_Yp^Lf(0jnUsjGj55z^|swo;0jLm`hA)#y5 ziaaFrIXFFe>E1BKMC3mK)03C(O)HmG;+t~1n!pH zu~wuTj#_@#a_NSAUnV(+Nq^60#&km~Y->^y+y1fpNH^>Q-$eXh)eX^K;ivsnu^uQ# zUj^p+_Rx0(Cpa4TZ#4IjHEzahlHrdn7e^capQ`hKucCP3_&t(5LXiNEM@is#FO&pK zLJOVHLPC=wH58>uN2C{NQlxhT>0P9YARd64E}=vnaWb0Ht>P@@cu1)oJ_A$lJ%bUoO8;_gJ5 zmrG1>&%?`G6uv_ZLz93xs;6@t!Sas+zJX+?*UH7vcbaF=Tnw!@AI%oY&gf913|$58 zU4XLp^gd!}QLtXbGdT^V3CI3D^bqFY5Fc&WLqa?ioD+`aQGp3ZP_$b6SQ+K=R0&Kt zR;jF-a2$so9w*jB$z^3SPdMHJ^Ej~~N-iq}NAJalky6kdHb>Ev2{pyiZGl%e2Hp~- zs+#d^;FpAdiXtCr>7&5G`(XYyLpldg9l}2w(yf7J5#C`Oauv{J!n+J5Pk^HL1MfDJ zln3fbc#olE6wo%p`wS&VfPxMH?>CfW2l{~UuZEIVK#K_5RX@5+wViA>A418^Wgy>776=+MpUv8~7z~$%BwSYv6i7 zg9x9Gn%;+|8B)bx0{u+*V$?zhJ_;0i2>5c;Y6s2>^daHD4c)DQrW3wuICcrpX~Nfy z)42nb|1j_k1D6LHNcfh4zXCc=_>O_^0>%6ee9yqOfcg-AU>G5$2du7;N`Y75rb->qAvNj^M z(-n9=lKs|@UJZ1C@H<2IU7$S2fUW4Gfl9M-w!+sthEg4m49WR5ws+Dtz74hm+Zm{S z#)RYx>3)VTd8UW>Xv3Zn;;B!4U44|;J{%p0K-Y8xIu`BnG$tu|+V2mQRS_r#mT&|* z5iJp@IR}sSz#M^2M@s|}ya2cb{)Cx*AzDI>;N!sbr=IMK(RU6~s1cmwWG1UNl6~2b zt`9Vd@Reu@Oe~!`VSf-ESl3x3V(`tAk zr!|*&aG~Ivw0k?J_*`q(`L2+~dyXg)v*M1HIXJ4vnKbNX~kxm5W+K*7RFZeTH9)|5` z8HU+3|0>{Xr%?rYwJEZ$aSfb@XTNGJEbh&<3@e5-JV!=L9f+2Cz%`FUOFped>R_ej z`8Ah1cnE%-Bz69o(L1D)c zEPvcLcr6pjeqSpWL+5H9qq!LRH+aq!kdJk!QHI8VPoc6ny^k2W9PA?TB8H()fp}6< z%&34u-{NgcB)hoQA{EdJj3+Dc#(Av-=E+J)he4MA5^(92&{9fkk@Knr#=NxVa$eKG ze>_mqebzT#}A5vL0y^ow%@LGK0 z2FXq`&Z{91Pu;2;=QR#^7fIL9TI9S=fbo>BmLcw0hj+%1?AoSyFEF0!)p5GPzY6#Y ziPzQQvMTuujHiJ04e_GuaT$VSe`tz-3C2^yhK4cwfP=n+cq1(?w&w-oDPt2udvoBK zB;Hhui!tlKcq-Y<(0(5{b_2wlYjM$D3yi0jEe-9Xf%lO3M_OF8p9kZqXDdV8`#sic zAENuWHpT0K^OUr$AwCiKAd=nA6u$<>Q`Pp-GF6oT7Pb+u;2_x@v^bUGV_{%Ch3ynA zQ&&BHk4E0Eu_g;#6vRFM{!ux4YAJZ`cnxWy<@R zqY+#FD!{Xl>>gT+^o4IU@2R=;guT6eh-Xi=YtLL!dtNHf@BXd#Ycki ztbLdvz8m;0iGN{==lBWVBA{9K2tzytcn*?1(iGnU#1^bxz1fxzm1MvmMB*W0T zBuUo>lO0E}{D*<_{*0n2TDce+3&wn^=3?k);7dq;nnR5;bOU&%?I@eB_Yp&Fum;3u z7>2e3;%l3khM}{8`Pycd;|P}j2ylTNQ1Z1_E{2u{V?JARF?0y{CX%1yP@@bz03N*) zWpnjDVrT`hKE&r4hK>W`%c=!VL;c%fQSA4z)jt>lG)PL>i2|f)sB=w5V_f%!o72kB| zp({S$bM*3ouP~egCRY=m~xZO!p>y@6;DO1?M>>H@SS4`m;`gYXj2_0$&>S z=YRzF2c{bYz92(-88EHV`$7!qQ^2%J?{gc{Y5$U&T)t34x)d-imHW~;rS;XMFNfoA zL)FlK8!7^S>?g8@ep1>3YKFGjQIE zay{XTRDT;vr0W5*i}S0$4JCLeFuOQPofwQHGX58QuQz#p`{<&}raw`^Q(( zFmyLCH>}czp-+IhVU=+l!Sd(-TW<6C%4+3e=s?ZOX)cCt2dCRVzVZ$=%Fu@>quW2e z3VI(gwC+{8{o_k83>^tfw|{(<3_~{pbDOU0ID+N>8<=kY_^N2-VrYqLidWTK4DAh0 zw|{(z4mHZquA2HN*U2gyQlAMN8Ao}PoEj=Acnvv|4&9o>`WjW^o{j1Lmvl(wSxHNpKTjz5!Jsv)r{7 zJRF#BG*!$jV}aoBf%hOX*p)NW5aaR)z6AV|aFxvR@fOB9SlIP42bP{b#YynuLqk|y zFEv=$jaAkWEbJzlNwAo3OD#S$&0KQ~1&c-;EVcsk;zNpouLAQ5Tyy0HkaILi|avyF2IJ>8HZ>ETrB;YTR?2cNCe4=DJ*lyyT9OA0o9R<%x4XCr;M?O&!1=f^!m(23b z6g~vCyRyI1i_f8AQVIegz!T$q}%!3EE z#~aecfj%QV(ZIuidS-x<$?D@%qGT8FGm@TaNWTTDY6DL9#+5MFB7eH|#T zA9%TO$XKABgjX2SV}bS)UTNS{K-ut~uD#l+B(+2TR4LG*gY;L8wxc;L4ZOOyQ)QhU zdY5L>q2sowSNC>T`eht-=x_Pez0Sbgp?@*(B4F;&dsX`q>A!%veeGB6OK`@Y@VXo| zq~Fwuv1#6_z}&tLR*G0e?TfL00PwyEnByMO7E^w|;?28>DEnRS zGqDU!UcLlBHwFAirAqy1&M8OU1 zX^Ni&<0gMfwGlZl&(FE6!$Gj+FD)*U@rK~s70wvi#{%y_vd?O9G3Edmcaigkc!uqG zAq&aAV2XDFLPt&IRMHcHPi^ z1~~gpi2qNEi}olm?t(WB?VW+wkoYYvF4}j4ao4i(er$?=3dUXhsp0n(z?Vte=BOkqRdUMx@Gk;EYG4I6PvoCom!vQCT%2 ztt+ZVq+*FOBK^uE(kWn$7^MLf)v+Y=QQQ`AWct^mv@*+QKpo91r|On;iwZmCTn7vL|>fb+?JtWI9U zF9ExsqLNx^aem2*D)Eov^xc#-!9Los*9LozJ1a4rFHnhXeX0`Q^SL~K1u8L<%Bo7d z06lzunSD};=eZI?OQ=fp`lJ#CmjLE@T)2dj*yZ|m3kF$#OQIF8l#ev!o&gUz4h}w-vTcz<8i7wDxz?25A+7-Bw*cKCT-lKR7bvzKa1}#3 z0f;|qn`pF?e!%?s+9X5C8esl>ZL&|UhNMAU0bX++cGobJwqe#y zB>Q7S`Z3V$KDb_L^^gcU!z)tI*&FPm4SQd(C+mlfYnd|sK+tLAS3#$O-{mPt zQu6plg379()4GxhI+gqqblxXX?`&WmIjZ?3=m-Z&%h;%=owS?>XrGp9n0q6nY`iAr?pb}MpKXgi`PS9KV10&IBoHAc=x5GKE zprJ&v?N!z}5_Ql_Mxu-n;qq;bj{Zrr$l+^vB&rF_BT**<4+rK*-9IWMXj5dO^)Wa*vzH-04Y;=zj@v}0_&#uUa$n^(*6#fm zn4R3uFHZ-^L5t=Ix5gpa{k0ZZ0h*@y0L^6u=nQz64f%l%HR`e;C-@*L`&{oMD?nd@ z?IJ$NFHZ-EMTda6euo%_2Imcz`W@;xg5|FWJP*kprj?7KD>VN?b20QWc#IG7!yRgr zp=H1qQP~K+j~KcZ>^AX{PD5#IpM$9Dvi}bD(T06B*i+Kk%^F4qy4lc3)yV+ds1C@qqMVV7{L_FtUOJUjz2h z@HQy2MgXUVhjEdC@Nf`S#o=KR>gHk~JWNqpXLy*ZnS_UR(JDMli+PUrq1GbZ=!)ixG?#8v?EP?S)F+T%>`?>m8?S`L_T+=!i4=PHPdbd5b8%L38n18}MPBApgBX zjq=(8ls%)ejd~yPT1e4wt8!=XO@`MJfw>E9HVhpD%w6cm$WN9~r;zGxT|L~|k7RGr z%Bh24H3uxR2KY~gczK|8gtuz(*W8Zp*ABPhKLFnrS=b$R9Cr!atj`9jLU9+&+n*hd@o<6uusXAr;U2;%AUsUUt6O6mrJ_$`%H zL3}=97!Uh*RKIS>LHrUh_v?qMUklD#9dl2b6g^Yk6WkJ*hxg|ybPApWd>hGrVMtrJ zb5YL5B1fK$i#y8`41^;0hASb{o>8fvyuy>y%Cn;@*6LApS9`ii3Er zeE2wZAc#k(tTTw`)=Yx7 zlM!3+Szxa00_w!rG;j9eYA#nWpG0NG{)WIjmy6OCN_^R*d9>ydUtA@^tv@U@;zABJ zD!x=gSwR=d3hR9&zN`XoNc{bL5|zcG+rZq;Vhuyf#)nHgi*p>o@{a?4gJc)c%EeGm zNyUq5E{662-;ZP$bEr{S=mDBr(p($Xih?h4E{RN17SAt<^ z=5pcEyDB=4VEJ1CA4jq)Y2{+*P0cH7E{0YwA8vh(WLI&hQHHJuFI)j-RrNk%XjQPU zh$k9`t^?wZon#oAAt78kcCzCLmcKLb9VENDRxXByRaCr&=3?kj@QX-xO@|s~Xi%ka zYci5uOYb9wZU)O<8N9Y(Xhk57DRm4(=L2(0sp~j`<^LCWP!%YtrK7Odm#eHA4ZmxkM#B~AB6tvwhBtvZK(0|2!Gi6E zYUN;qx~di22zUyTz0tt)fH<7~psp1~`Y14uotxEKfM8c6j6wAF$QDC79+=;z_{os& z2%NPP4!O;cUI1K~@Xvc{S9z3 zeQkBGA$7XIK4Y*hw@F7F`K5)LK zQ1ZJW{XS3|!bhCaspIl_$J$FdeQ|Xett9z_)U}ttRn|E!U)4;;k69N z)~4OPM}hg`>bim5E!4PtLp3{*t^~}@?v`qHg8KvW+RI(lzSuPXI$&OVxu;E$i;!#J z+#DYm;&w}1;UL)$P4V_%+)N)Ux3PBbY+!DtPt;n39P}_SkNQuw7U}=~j}(8Vx%B_` z;5_O-cc@YQe-6rc)c;5CBmMssIFI@-)RKl+RODksRBFYq3`5%ja}W8~aRkdh6Sz6O zKlEBF7enuA{zh{#v`8zQFUh}ks8NQtLm9ts^q<~G4BZRP?;E`{41ER6oztbJs>=S> zxL7KMhL}cOV2MZD13#iUP7o&Qgo4D-otg)0E{2A*3AdW0fqaNVjWV(F$_Hm%pobO;|P{N?2~Y7bP&$gqm_%H zoixv;xfuE#_&t*MI@BmbZ=kG3Fv_y)eZa0Kpg2fg5}=|oV63qHlJ25hK7SN&#$={+6H_!$ro^_QHCx75AKYzf_fh@ zG!s}2;!%d74S{$JC}bEq8kom`!j2=rP~ZWVv*Ut6D;Gn3zh|OJF%a1uyM1l;%^UpnVe z{qqHuhG*(kg+Z93jStMD2CJ-^M`gv0D8A4fsxCCA@H{FJmOxa+Z(#n^%UCt# z6ubMzXs+nk4!V9 ze*@+(k4$$;r_LD`JFexA>udSt@W_zBoMDB^I_C`EY9@1r3;oobVP!tKgExZb3|afD zIm0RgCjzsJ*C-c@bYEb0@jB&V!7G5-#T(R#v1#7FfZ4_0tLZpnzk5Kqd`)MgwoqDQ zGtDHO|cqYSl%BBNM1{a&Ev=IsNJO^AExKLRR9=vdhjC;-d{a zEW|U%8IO5pYN_)9j<%+t%) z%58$b1m@}G8x;x!?*rzk(|?9^P%Cvw_0Ev43Oo|YcIB7lNKrB#=rG|l`N`=nkKhwP zIa>n<8`AlJa#qCrH^h+c49v65w1)H=V4iJ;8q)WHc_x+KkS@|jUEF0bq#M>va9IyIQ)%^z48?SYErh0%QZU7po}U|K+Box!xA zW)e)Bj#9xiD!)9N@Er%!#lU<47H#0`z}z$n=a+?1kuLP53Z^mnWnonCr@-7ail`G~ z)4XeexoH&5FAJlL{da-+%A=UJPTzb?3aK7>=;ZUP`)J2r>l}EhZM|xDv zG3v^rWPVu~6^kYSbE_?&Hh7&=Sys+xNOo<98fEA#@N|<=_JQ6<49yPKig+Ev&`*Il4Ae6W{SKJJ zKz+v%EdOI*zUcf=D;GnXOi{dn=3?k7aK7kl=uo2!y@xWs=xn6-5kp%{RTrI&4MUdz za|CK?7rk;`AN{dF)+waR#`R3=V_+~`Kcm}ctaB{-PBR&c#x77}(T4o; z*jr_tr`AU^Ikgcl)zi*>eL1JoI%gc;f7}Gjr`FHFmx1}z2B@cjMLOdv^|bTn>Sfsh0hr(F8mdi^2jag1=ck0fFvRx)FB%9>3^&D}fb-MCBh>?)qP^h1 zxvcj-hxjNhE~}``!TG7;(dx-a5uXIi?~IMn;_}YeZg76uc$|6$lEu9bf%$3U@xK2Z zCU=RJJZ{8rBzuC^LeC;w-mYNth)*=cR|35tJV}dJXRp5u#W`1ti;FEC!RHg7Y1lF! zn4gsX+OXv?Fh40h+fe>5aD@ywp*dQ)*ir**0P(qo_?JL`5}v2U#g?mJ*)oF9H*CoV z#Lr#2+PkFEK&H9tB2&BE-&x}jbEKu^TR!+}=Ti#}1ZR=K|g}$&4sd`^giObIIuRvw;G=73B-@d|7;jEADADL z-|oB4kI9SYy!mjW1j*i^mD5A?mUl4NO5!^m;>w_n;1T&zwoC7`i>uO(hUbv%-M;UF z16A1!h@ZsYV;D3Nn4iSo>svH05R2Zc7j8|WXSnuh<@9u*<*g0AgZO?!ydQ9;F2D!0 zcrG5?>NmhjOE>Ueecz-F*fJEDpYuOx*z!FvKj(kQ(H<=Sb>MOhaYBc+a%onzz?lE8 zxiqWE;Co2^h(nEX+DY&djZk(}?<37B32YGYV@9)@48*S(95)R81(;tkIN>;g<$nfT zt1*gG1vs+rwv0F0`c1oXN_^} zH1K#D$IfXjGLB_#8ZK`=Trkcn37Fq{xagCYnWc4p4(zRp6`V_2i@eOd2fQQk%MNj6 z|4WqNW7U>@MeidoGuKMN%6%gE-#&SnS^Dn?V1BXUnqmJ|;2wiv|8=cJ?0*E#FI?O( z?6;eR%L^AbeZ|iP0%euY!mXu9_ARZ2UdOP!>%cA$zwHoL_TK_;*aKyE^ggY)MW^(^ zL#jyjU0;E8ffoHW5WmxL-!SM9Fu&9Bz!(E~7|dUj$0xj|}ntz*`AF z*5WdX90LEN6!;Tk6tVhY{!OojJTs<1C4f61+0V5WnKAVP<2OlO7^bfR<~K=R`ig!Z z2n=6g)$TNs{Yq=0Rcgz76D(pF_`imD4A5Z0ueJC@cH{lwxGypS{EcsM`hXit0r7h( z|2b{(cLbhI((kkuS}?P`E5P{u6_;P$Uy=5D8o2C8h^N7wSwcZnYI&=J@p~=7et9QM z#D@ZJCh-t0F0;3TVEn#IT6Jq#nrddO67l;kq5dI11{`zyYc!bI(2`DTp%o{~+aGKf z@$`oHb)Xh=fHP?Et?Zax^KpTXxxby!ACWQOn4&=ZHcckOmX^T$Hcgm6-Hw1Qe_`H# zc`g1tPG+r~t~e}jwndoiA=z0B@j5_r2xryeH`tckOEJMfvOWG;@1@#87i^!#)2i(J zU>|MR3xYlWbG{+iH*esAZGK+0DmyT*%X262hT!Kat1j63K@VRO49+V{Zx8tm!G*wl z!8SavEWHWd56nw%qw~tjso-0{y!19EF9lwgM{tIcYE^ceAsq+I>tEvy=?{VXAlVZQ z>488St6-sgk|8}Gn4goFVo2`;=I11)8q)WGc{ygfAsvqU|GXSC!;r24%xfYu4e5Ts zye2ZskX{aa2+5vpNS^?DNqCM^I`!K2+q{7bz(=SmUT0l{x+z0*3CXTgS?2}ddd=hl z(0;8h0Kdyik<8^u;HgM$V7>s{VBp@sT-h5{WsCHDV6N;RRAmd^2h5edMV%O%=Di8b zmHks*nS(O+r+<@6)>*e|3uO$hulY93Wegq#&g-l{JJhH#U?s|Uoprn3N5;o)D9SFw&?>;(&UQPFVEI1*<_9N!(aOcp)tc|oTnxPg&g-mu9cq-J zY5v1SFFhc!Pwyj!HUQ@bC-xhL4glsR{;Of=JYa6(zd4Rz`F8^6&xT-fP%9ThgWoBB zNOLi?40uZ<`>;ceGPEuDMk@PV?<0n81-nfAh+*hWAnskq3`5gf>M5i@97nMHvB3Nk z(s8X^3>~2P3C+dOwcz{|(n*IJW$0fhOfh!T4133 z1gFdcWi^~*T2$v|0Qty%=GQ7z&G4U|c=yLT`!50o_xyakvC%G%0l zBK;JYomNLVO>o@0aB*6Fbp~vjw<9n+?Zawkdyvx@`xgWMItHJMXrL`5ms;L?;2~qd z8#=^Q*C@Ci&yP@9BfU?D_t|{#WyBj-ONpS*<;an@0&~4IRi2h3KL!p@z-X1CwaA|r zF7zGl7E;ADciQjo0K5#zZlT3x^1mL8>+vH)`#s>o8zBC%78mWMz_@-}8`=i}?` z*SEX_!PXG}*CDPdek*vPA5ivM@6(LUZ}bzE-H_}ziPJLE6#^fEt`O?&r+Bv{)JGfk z(ooM^X8;-E2p|h}02z)NNYfzob^Z}5s{%-?PgMXJrTRiz67^03W|xdpeL?Ux!btYy zYVr*c!5O;a3m8cDR0DquG=uPT11|$QOZY1T-vNsF40u*GT8(gdM0XTWGs3eC+yQ7F z;kl~aiS!zvD}?8%P{uel+^lkho0B@+tb<2p23p;BD(h@@8#I$vH*C9Vb>CNO`4_di zxm;}7mIY*4%O;@R4x{rK$u*-Re6U^^A7;tgk*2irpPkGK`?gx zc0)X5CmuOPvUix`DPUYByA1J3zcPrn&NR_T;+#Vm9utlJ7BKz-&JIlgU%*QT8?Nf z5{Msx75oMKs6$-!$I{^AsO*^DM*{IYu#?39P=S~aLH%)D<_Pr14WT~Tu)h!W#8dat zp9;L^=#O@i8qgm>ciBLHe5|snKQ8H~`r}j8SSoUV`~#T#<4e_81pfzIzCRkvTjdhL z4S=Q){!jG+!7G6NN7zb|;a@2MN*Dm_N|NDUa1)@ZgoBc#KMGzBbdGR{q2vybZy>PS zP*N1A3*k^hdMMCOgwq+)zXPTH95{n<$lO2;3BPCHPk@#Z4m0pJpj(8q7>9fely?wt z)})S?DQwH>JQ*2giD8$J$Z$Rjnpwh-x)+ zl4Kg#fm=;$U~V-FlVlnwcn0wANcJ*iuHbV(o}s|YlQ#ZM<_ZoO5oRrzkJ;f0L%J+* zePmG}CwALa)){GcXeN<%&fhB1?o5ijKn|}) zyL(RnbEMs6VE0uOX@5~}5b5&3?1sI{4T3)dW;YyAC&s3ER|2yeeog9lmE6GCfAW9f zR?{1Z0l#Sr$w`*KJs9(Yn!kNae^cj+hnPnp*@qlzRGc{o-t-a54(ol!^J)G2EZi#f z9Q^mBmpN$M7mKO`aSa@G8tNYeT%P`(_A#wRW^mtubIlxAH6tf*AGpasP<}#-Q@!C| z&OdNP<)y#(v?VlWn$9k35jEwlq4;>vXu4eaGt@^L_Nh?MIA=S3;Ap3z$tt=%f${}` zcKTFh^=xB|YNyXt1uf-v`ZX|D(7&pJ1Rn(+Is_LW?^GugoNjEGmFImlNLR9iF~OC9 z`TK2Yk|m4@?hCvD$qqK8w*$Q(9O9HtZN8r5K=Un$bK~ZlBiZG-9B96|RMy#i!!?uU zyW5J8H^?KB4{;~C&h`8jn452I1DA9~$V9B<-GSLVzGUgef>!{uck(4md}h=9 ze*;ge=(X(p+7uaVbEkq#l$&|fP2fq5mqxKyNFgU z2DJxULcFL$Tp6?;+#Q0lVtOAjC>vM<;>Dc?1+GmBIbzp99lK)DlKp|oFQT%}$}g&! zRDSDIDs~l1x_6dhS3$1)uYkGoiyL?^FwYX>Ro4*dr@&nKrBv4t9QhaeJ`Lq%RY+jd zysdzF;4haXwaM5&ANU@UU0z!#&I>w?St62M!6B}k*9?3Ul_ltX#CgAiWjq63F-dAu zj$9Ck=N6R>gW3c0+@gx(2$p|2@IR!as#Y!rg`LHnIwU*MA+8MS48EVrs_A{ipetaJ z=fIN;gDL{?^rgBA9^#4tz#B=rhSnn8;{X^>Yib$xzX9fHO>KukmcRIU+}B33KhRpl z{s~}vh}Ut5EBjA^7rcP7x_Te6zYJJU;`I#sM*;E7=|jVyoxnVEYT!76<$npBbP-A# zYUN^3GqA6SH*$z8gI0lCmr&MN?;{3f2Wv>YiD6I|AfBA17!Lgg_zFok(^|x#&%t=o z*1`~vxg2h_L$X_%;(fq)GWW3|z7hBliMKMvL$8F(B(II(ol?L&$!nXG`wETSQt91a zhFiZO+3mCzngUwh<6zb+@J}4#$~)=7KclktdY_HleXG9>w+15F9g^ndqA^<9|Cc~K zkL=_$$iD^nHc5BZT4aoV4#xA#uEyyW`VXtNV{ucUn-&*megw|*&hBd7Dd#m4_$`wC znHHy6spSoOhwll{Al}nyj5i6G=cB!nzPcXp&WN-T)-5Evx7I?lRm=MltVk$$ABVW| zPG#^7RMuDT^OC)@D`SN963OnD6cLf?9lBB~mY1%Su7&z&!@eHsS?ioj)J+b|dE4o^ zL<5BF?*ns*hAOM(61gU*xkO_%TK>p$i7LPxFq^B^+(iy^H*0g3!M?KrbC;{EGWRj`aC~2(%)P|s7MQHe zU8BquoC18$kEzcFHMk3&0vr_(!kY}cJ~eg=7H;=fj0s3i5*raCepWnxgL(F6BC>}TZEk0AL=9P$9OyY;XbY*mTHepV77`!s5LcaaJ$SC1C>x>o>B{E6h={PFbAyje&TdmD z4Jl5Yv}igXZP>-qd2TsdeaRYuPTHh~n(&vc;qu%MwEA)?t6F`#>8jONs3B9@ zC*0~M1G7u2)Q~By;Gcl6Alb<^WM(h;CQ!2wT%T00@us~S_6iQ05oT3ei_TEfkS+r} zj&Q9S@{L)MZUa0K$^O8Qo(1#^;W~!&VW6O|fa}$eXIex_E}%rhAJ&ldPr)AmbXjk z11|*T#@J1HUZf8Jv*)`j&kKGI%%1P5yu+q>^W?{@n>^pEM$?YudB*-E;KTj!=67#x zA=QiJ9RV3qZnPB^f zk1`B84#cf5{1VCD6eFEgaPXWkE90l=m78OZSECyWf=dJEih=Z& zm=G5Y`GR`@e~)Bujgi= zsPqcpU50cWpb3O`8`4XFW{}-`4C%AL=LzpMq_cb*W^Kw3CHoEOn!s-fA26hc15YUe z{96nSu-d?%fnOrohYTg}tqikjA=!sx4&F&Uc~to9c{DqUcKc|uGL373uLGA_2zXrZZ(mxyc6;Q23z&i~55zzO9 zcNzFspiGN_e~FdGB)W3~wIaMH_WQ-;Pr;pmHW1!tNN)pjEdkzdNM``*K=@ZfdL+;# z!oS6K5BMZ?4EifJFa~+z)EIOQmGC4m23=5D=NNQRGZ}+Mmr-NTrPyna$n!6F3_1bK zW6)&-=PIklpubhEigX)buGMR*Rt2vF=32d>YL!j%zXBdq4sqqCHihck@=gZh+P1E-ig=z15!Q!$ zG4egq;?#C5Zx?WGHBSujZNTXhp#7;So*Rr?({n@oQ{bH>{*Nhs9E@ApOGCUs#RzL4 zlKsjQp903M@3m?nY`ga_U~YYHVmmCM)~8OXQiL@I$$qP~P}{Wp(=`82^VsX;$lKt> zD?|RBLya2862Lc7nH4AMgDRDyk$xvwx+>tVxalKlq!){_198I-ic|AFZcQHnbHfjg za~irFI8#+93DL^M(41h*-I|M`J;1k;d|HPZW#~TevWX}Q)%%E{Nnlfnr!x#)0K|PR zgJI}PVD57n<8r^C-XI>GT0O$bQUglf)5@twTHZLY@x(J3;wynl)dUXH;+gA{)1H2S zwpIr`bKICn3TLbx>-D*@Mn8qZUwU`GkfxAu*`?h++OW&GJ!PDsI5sX2ij&ao`A@?X z!*LP4YQ|q&`yTD|j3*pKoh*zHFNRBrva+x6!7MH!SZ5$r0j* zcFGSTJ{Ned2SMr+Elystytlx4Zqh;dN5m_jLFKuQ=QulRaenv)O`#E*!Ug!+&WNV4 zZxxNox!gY5u*2P+51maR!7(bg(4%q{^zHV6rchO7RZ}>yS~Z1gDt>q2rVzSDHHDfg zehaP%%<;Rfir<1~0&|?Mui~`eQ^4%V2C>p`1bf$p;e#%?xzi}N_-krUf;$3pdukFJ zS)KZV;5EP>l)@OEq5>o1)b`ZDG3brMDf5L_7dpp4d+MgL&i3@FX40NcwN~w^d+b1N z<6XEt^Sk~4skV--UaXdABmoe-eLVh~EWjlLGu!i(gEp zk#r!~Hsb%q}p$+ENerCnP%!+9^o}i7iLL-fIpX zWQgYnnoBrXi;FEA!JZNiiFMkNu|`m5VKx!N-Jy zr#HlNw#4cx;S5?_Y#9rFKM#0D!xM9R>FowtNoE7p&e`xnPxs@dNO*yO7SVwa9w$18}~O z&1snaek;tk=|VPF?9jV`_Wo~2nAiz*5w5k+WiHmS!1fT2aEPn+eg?d0XO!jE`wZpw ze(6)N?nrrJ#}r6y@3cCyYC6r(&ZYIyhJ8M*r;l@3Zjca|q4iHtGqffNF3-Tgu-sH- z)v#RmJ2fmfOOP4bP#%^C1M>*;ae~ay1g`?-FFmwNkTpxeXGxm=z+3wSajf8M8!#-> zhYC9yxDGJ?J+ICQGE*1nQNa9WYnKFBYZd%6@Dn7vo1rB5dpu}{WOq04hd^Tq_b_zN z1v*Z+XToF`Emer_@>{~J-bi+DLwYpOPQrbh((rzxN#y-IX??U|-%aZo>-7E!hxdak zD)0XVcTWm<|Fp^~?_YyWJQ|!;-k;9i&$Cf^|B~{);3mNB7Q>&{l(~ZE0{=+(dIG&t z;qnN+1l(^K@C`${z@{+k7~z|SbT?r465!j0^g7^%gzp&A4}c3S2fk-W7ylv58bJ8I zA>9vnJ}G&q>PigU1bm(FV*@`0F1i%>se$7+;{hJR&kfuU_$c8Q2HpyMh%9+!;5WcI zRsz2^aKexH)HLC@#_0?KUP<^r<8-zHKOt;Yl=ds9^Dl6vRlu%_j%rAqKZaEd%r@Gi zb@2SrQ_` zA0=MWFw`CvAsxE3VQ5=m?$Bi%N3i@Wfag_&lCoO482a89ikH(|3~dWuxf0~dJJcvc zzeU+ER8~RnBZlT2j>&0d@C3uqR=^xfDpi!BMjGRM;D%)&U0G|9G5jnz$C#>yc&-r< z)@c$?G{u{NbL>en#ODIHE(`HwQ~W$Q$D|sDc%G5CT}0wFP4QOX9II*@;!A-Cm4o;P zruhHBIfm6W#G^;y#uz!Ko+;iHoMYREhWJ|Gq17SYz!bj^&M~i%QRDA_iQ85b+!{No z3V)CTxK#~kX`;1AjUUpyspeASxkg7=Pe?w+p+?ns3d%axL|HSvkJR{H@J+;<8#Nw0 z2CB%SmWH88z#MKravZ_(j|N^)3rarL%Eiz-nzzzi46QI0i+8ml-`b%@89EeYKTug4 zy^k1r58V9$cw48Tfd>XgBm_eJ7EHr9)Q`r>R?ST1{T{E;PavN_3 zX`u<;Of_zb_)%c~cF8O)F1;>YA1oEn#Ba7CUKMyReOP3UDLx3CCxr9V@XOl08-aO3 zI6pyd(#k<^1M{a&7HBPUPqai|IDkH9vd|%}YO*WJ_){l~^geP=bQd^(>SS?(+@zHw zzXIkt=TgJ|qWy3LBzu|GBBwhLjOU`?7~&g&?~?cmQ~Vtm&rw$zr&|hRHP2C3C9Dmi z>Xy?jIu898$zH9s(72BU6R_WiuQ9~W1C<&NyjF{!;Z~CwGuB!(Yh9NxB$_TMoR{0FBkba``l z7EQ1#rSs8-T{)d+zH@@T+VRZDcKyuAdfY)?5}06rr?P5--SsCm!Tw%7xv+vK*fW6n z^5#eN$7(#xNHv;^cK5ab z<_`Rafky&!2R@-p73sCWZ0euNRL112`CDm;wq&S}HtbTNo()cCm8}xE7VJ<(U5zAE zad|ceoK;a}m9sWO4_i>Vip&2Xm0&g*4f+!XeQ0=v#(Wi8(1ZGCTecU+}zdyb94LLz&C)o zvIncm7HQvX)!c@v$`;%Vm@9j@Is-P%KMVLIl08D3LQTQ)UIF7qFiJU7#0$(poItX_ z)Z!9AhkmWK;Ze zFm7a14e@=zndU=$nkgO)#*J@=A>JSO0EvHPivJIc8|5rRyzm079wFIZo8qIuxUtSL z#J2-KBk{SW_**b;#PbdDatkA@{z&!$Q+yN{H||BwTJ`P#=El9a%Bn-uxTW^~0iIt5 zFPSaTTBzycugWb_e5vN%yR;hpJ9wV5kYDCdqXy)(i!laL*>b(lZ`CO_4gxuxb7|zz31+HQE&J@#OLj zJ7}!0o6biYcD;0-GftO3c8v8IYO3MuImXwE0hj-yvdZO+_A8gaR0HT$cKI-1Hu$X? zKn1S?zJO$>sVOcOd>^Rr0pMT*CjpHo>^AT^pj(7PojA4Lveyg*_7XS=4(#DIU7mS? zddsb{&U(wEnbcd=Evnw^n&-1oy)EW?>jlj9me;@wfVt)QYsx4t(g%Ur4f$%yC@%OJ zFuS3kIs-P%AN5m&)f~x=(xynH?h3~4DP)MR1pXh17dFMMt++rS|HK&LNraK?SW|o* z7`wBGA$|)u-!_OBHN>eA&HI)5ZI*OC+OV^x^W1YbqU7pf$}YuHV#pc+={#9xk{jFkdb;t1fLza2H^{ENWrk zrNAeU?2oF;L`tMD0cAP}{Bd=xv+*pcZxRwKtVdV3shzM|cH0DcW2 zsl5E0$ge7^+&mn5*v$u(o70o1cQY`%`KWTU;9J1_eX*13EClB`q&_D1r#cJ4$-w-P zufGiGzQFvEuhWL~a$x>0)LBFNFJS&I)Hy>s6dvM_GhHyG%K`HT-!3|(Q{%wh>VY_r zTVGE+ghx&X;=p5-b;f}wnn@fevPZ>%r>c%Ga2)6a%yHnEf#(CWi~mtB7U|=_?BbWo z#ezfjMu>}Fs}p0>yz#*N3AZ=ZW$l--za23Dsf@SULRn?mtoeVM%PPxraQ=kbJBJ!I z6)3O|gZOzo3v3~rllmZ8Wf>06pKx>4khNd2XcI8kZjgF_TJTk1uHE1oPD8Wo$4W8% z?Yj`ITnufexm$BFbQw5*!Y!>sjWYBk%J>s*p?V)Nw8#OhkJG2!(iw)f0p^C4!7y|N zFgL7>jw4w9{lNUevG=rcF*N*F#WQIxhJFOjf7l_+p+*@x6=nRvvCMiOG4vrge{d{| zVQ7KhFr6-ie(f;~Z3@h7I-BDN_ycIb{J}A=RxXBK(mcE7VyOQh7DMr2F*}DtjWV!QFfXu;QX>PK=06V13v6F% zQ)Ge7+667Nz&1t=4I*9+m>1Z_YH=Bc`+)OEGTsnh3(N~_6HM{z;5@=iQk|Q%d$aAv zB@G4i$*Nb%L8}3Ojbu;JTBL@TX+BkRsp0G3-d`X;&7nrsa3uIJDx0qNks6)^www5j z>e9KzqGLcjxXm;SeFw~g+pOvE>#A!yNO;AR`*ErI!K z{ByMU4X*FFBbd|RqxtsS>aB{=s3*3x0Umb>RWjeOWezY8oeLaiYx$1@UvGyCmxWrn zI4$O=;)^sFr}YIN^$Fw`JJcwrtw&iH_nqy<1+h97 z< z@TpiJxE3&e;=$NIg_M6p zyge{Sn!;L~BMnvm)yq`Q%XsjD0lV-sifw_}6jFS1T;Pb%T$s0w<2WkZe9}Badb;OGpO$_Nm zz{BeSH;tl>=JJSiU0`-bvnZL6Gfr(R9isvhvGF)J9yq$9*w#{S{J90CVw3*|HAJHR;ver|~01m+MpNQ=v7%8Q;?A#iY%{6P{qXiH%B{ZPY} z;lS+sVNo*I5?fXPSJ;ku&=*>{gun-y57%5mVEzku2rdXujE!)pQ6aDv%6!2n8>#n^ z5V!!m74cC~GH!^W2Y|WSN2_WViyi=T9~h&xs6LP`q`@D!qKPk%mHv+}=&3*rwqOWd zsuYdik$&-w4AzFsE-U_|6-6xm7pz2)NKMY|k({*t=nhap^&7uW8h6#v92Y+30-8lRvViqA^_$Cvcf zC$Flv!s0WzQezbUz@EgY_^d9Mr!h(K6=%FhWmSyo0yTVIUYDF$a}xC~0_JK8cgdLv zJ_(%hBo3U{CGQ*v&IQzfu-}Pwc!@9KN)0dZ$uNtnq6F+%l^R~+ORB6Ryu_E%Ou|c+ zo2t4>yIvKf`dZK7r8Y3vR~Z9;0n8^>PMw%Y{|L+{RzaPZ;Jd(lVwKbxuxbAMx9}D# zQha4?iaa9R1&mL)sv*7%_yUP18sb!K<^QB=OUz3D$5-=w;;gn-j%w?xtF0YWbPiP8 zCn~F|tsd0y*>zB7*PW|vBru;{S9NxRe*}I*2kzmLMkYANsW7WCQhYBbPOY{t9M$%< zuC`IIkyv^{0A)Q5yjPut;8>upg!ij9DR>mnHp0KUWYJCVVW2c;fDalt8&DGA!-nn;fhH3^ zV(4B0bc^sY1BaZ&Clit4j~hxp02)L1q;Wb6fKC!VW#H>TzH`8*4FgL94Iq5hIOJDA zrwE@nlspECI}d!(X-R4ezw2n>h0>_N^bl1R)KE{7;~%T6vxPs=Oj>x}XR3uib#*LE zEj*NV_cj3L7XHk@UjTC(_(!z?k^T;t+rUfJ1_WOO<~HzJofwr+tgC0|BZy^!KFX>qZAJQ%mt%!c^yz?oh_Jc}v*J{Y%Qk6}z3;IBzMn-&*iR)TTc z&YniPs@Q%F*!~ydIkdP`Q#=^A`CNv07vRMt9&U<%55|2Vx8cb9z=d8zJdYL^zgGt1 zK9bis)#1Q?TY>)}@q${MJwrjX zOGs`6(KcD>|M<3^iOwKeHBDg3(g)Fi}}o3C-=JEmD%g!+0(?(50G z+}Ar9xF0b0^)AX(k^UB#P3@*kWlXMWm7ZMHBP;zM-_x_$>8f!KSIyI|ngsK{3Ak#q z$|_gIUR17{s*b;!UG)(#AAhDgKI2qZt#G(%i+0s&X#ObRsm zUG*o-+Zu4yDV0^Os((qj>a;rkPIlE7ziCRPU3K5#s{gdB9z*l^fUBOWtkYG` zG!s|7Ms?GbbNur(X^NAprm(AuW>BvB$H1+D*;Oxay|1O+-^p&-=(BZ9E%8*o)_l~u0leObB64w4Rdf?c%?n2(_%^jvVd>SKqidT3X*g?WDmT-8oxm8)i5QLbvQj(>w) zbpV);-$fmtajL5ZIb1bSyJ{FTUk|uyxXLg0+w7`vuX5EW z1J?p(SB+Mtiu530Hg&8rl`*-hgiWqmo0a~LU*~z`bk#QwS8dU*S_Si-2VAvUWtFS8 z{;gcKRvrIecGYcQKK}RW_>5Cswa4MAliF1WpgBvU)G6F=D(iIBLCwTf=TP13szX5| zOOmUy)9&7|aOJAQ2Cf9mt~#Pj73m(pZ0a#(Dr0>9*KNHEvfShQ23zinBk=Q_ehU4B zpV3G0b24X$YJ{DiU_-yKbcywqgq^ZQ1mBkvHxnQ>fdD2?jU`OU?%hfIV&mfD|domaDxw_S8>as{S zbK(51ZiTL-w_-9wEGF93ZPlyv)-9;Y99!Ad?HgpCr63cR;_CKco(vW($!0Fv!_}>g z&J-Kq>NXRZZB$a?3s<+EIuk$K)omy;G#|)ZYJ{uXWSuEJ(iOb`nTwUuTbavJxyv)M zT&NX9>VpQ-XFsA3q5K6>=5mhmu_ROuC-B0{!cka1-Fq+xlUU# zA7JYNZBc1+7NH+^k!vVOTNVWcQR>b@Tg>Rkedan!3lOVGrA26q8U46PU&%27rj!lX^5_!?x4H?r9#lYEZrWl6?mg{MFpd?_7H4NumUlbf7E0+SWi2t@q91o_ zV!Mg`K_ZlGPFpGT}OEq5DY{VHIKeo}f+Hd|$ErNnMzf%Ek4JwZU+DbV_rK@S*J5+ieTg~YwyL0Wfv0`>6oHGzj|-3>ZIY!Eaw#i`)j)1-$p%<{eueLqXu)1 zw$7zPRK8AI|D!GbiS3RpS4RA}>1Xj+jIqViV=HHI{A8&JVb1Qw-;V0u#@H1Goc)!u^g@lB-kWjPrvg^loVK{&BJMS~GtjZR6XPwKKDdWambac|MfMf_ zOyk|ClYuPYX?a2;CKPfk;fU}Qi zi)P;`wB>$BSrT@40(0lZF;YC0z<7&(n)6S=$vAin6|fwMq|jChG4~@3yY8Y8Y0f|M zr$I|I5~gel{kWG9qaSxKD&Q<_xk=7VL$te44*X1|(m2|ppAsXzL|0`f=O+ zvBf{PsercJw3YIbvM~dYU5(@R&N&C0+e?L58IMEpzER-4zQnG1t3Zsm=!XkZN)RKF z=Jb>Df6m?mJgVaT9>23mZbDd+MLAVom1Q$)ISK~NDvK|zZDbKbeTdw1dY`99A-&%?`^_dQeY%-m^rW>!RH z`Z)LpoLy)oGKox*&BnPfJWqol5wFlG-inPwP!#Sd)Cr<6r;UYfK6MUK=u9JWQ<$US zG(V%2$o)0Z59EpS-dA8_HBGFNp z^x@vZ2YiqQqBIGrC7lx6=s#girIST&rV)vb!kpIqcB@cfEW(p7VBm& z&y%tPd@~P?uTKfyu%z^eL!LA!>OWiks94+QPTL#Yl+a zk3uJ?+agc~QB|Bv zQH-Qc&|Tld*_2`ub%IumLMT->LDz(05e zpsP!9h6X_=55jp(1a*QwBe~HSh+??uD_YPmufoai?PewFh@1}qwcxWSIGX}C=d)Lh zYJ3lhK$#`RDkEwo#@JB~a|*E8ll}xX^T7ED#bD|L4IB^WNs6)532OZ_()JX^8`KFp z&$-_sIt4xb3Y?=T)>0>E(>eIqPw^dfM9w2X?U>Xu&bEMUnACgCZWllrMDaJ7f_z@2 zp=cgNY%+9$)=z+Q++W}|oCs8f20?SEdyq~+tFFNL9Yt&E1f7_O#63Z$pdynIfQRBa z>IAKcG!1hnMY0FvaWn{e%m-&LiW$@i`tJ=mOV5CKhdM#$X2WUBf!IWyp#SEP_a?+1 z;So)I8)5;)&(sOpH6PBi6#r5uXx|bzf2W9R4V|DdF-Tv%sYv*Z(m*STYSSvHWCC@(L7!BDa~H)(>I9`#g>yK?BgDt$kk zbtpcjPSBo4aQ;g1C3S+v79gd!D1M|)&^OIMIYsdYb%Gx13g@nA;I*3$5z__+LHD$R zp#epC>I8lF1e~WS>QX1@w;pgtxFH^+PSCa25!8q`Al%dmTG0=b?G%Hk6LcDPQk%S( z+RUa-P?eeRcIY|i3W;XZAm|cx%jguebugTVDK=0isQ5@YYf$W_PEgrVa6U+JnmR$l zv*Dabag{nj!)7D4-zc1Ip%b)YJSb-<5~&k(S00=-De6-vXzpBitAV%6Oqd7Mkp@96 zsq00jpkLmE_1rAz2D}B7NrNC`Hgq|33fks`b2^=Zn#aT0onk3$5hP2e3PYDI&fTPfEp;J(sFW~G= zF`qg?H4So)Cuaa9L~94gZCBDP8tM#Ox;mB11_!uam0}O%|Q+F?&f(FE*y?>RW33YI8ki3L!so2)a(Ifkx9Hs0VeE=oB>X2%M`Z-lk4a#ZTbl+HvUS z5v`>`Q1KJceMzUFDrJzg{d5Y-EeGdY6u(j@=(F;09-z2IouI+%5a`SIkVjNH1qML{ z)K#NXP?JPByHYf!PSCLGa897;M4g~<7)zUTDEd(+XnkWif1r4YIzfw?!MTBAB6Whk zYyszSinpi}^ly7O@9F^Y5p{yruSZHZQ`c|<(6=-QI!N7NIt4BN1v#{Z;sSMo>Ys-* zg~HJhIzjoD;9N>^H+6!NuEE)qq9%2Mex=j#FGO?d1U>4AHq3O2$Eg$aS2UbOV;}}l zC#c9Kq%@Zzi#kDn76BzT7Gf%Of_iKQWiQ17>I7XX3Q7?t#2V@ZE#3-B`{K}5{v2o* z4TAbncZ^O!OH07Hk>XG41pT!QK0Zx=Zs>NPqMcw6w1>K~bPB3e9?nJ-_fse6y^3&d zqi98)pq5`El=T$dsT1U_49eRS&r>HTs~VisC|;#bP^a2(4xpGuouF%V;Eb;ev4lE7 zZ61WPH^rya3EER1&R;2ZQYUCqOE?!&oT5(9iq>#`N%1#zf>z?vM)NBQUJYo*cZNYw z!`^VFQdFT%(B}i;{E^~e>IBsv3TFyM2kHc^c@fT?6uqev^upK37oKo7M^Gnd**H)( zQ+TNp^ne%6b`*1|6SS-+>hn8v3VO3IoU17|Q732}zkuwZQ&8Dw;e3$dBz1y*83d;q z3~_}zK|g20d5fY*Ds+MpM#EW`q5^e-s(*)sPk9Zx#Y7Eg5VV-OWN{L`v=i1V6g{aE z6g8efQ4FR|(A}J7U-d#aohX+EL9RUL-k?*^@(IX@EfmYC6ZA`GIM>oCs7V2wT`9h! zPLMGT&IF1R)CsEm4V>K0Y+j~L&@(?E@{<%X__69}K_BgdGjj%bb@l^QqCwCU>gv)d z=*VmaMe!JQg66*s=Q;{Eb%Kn82xY|*=*AEYqe0M@)Me8t=${pE#;=5UojO62SHZc6 zVi|RUhHZdz0>uXE1a-p?jGO$GadS6yf;!#vHfuJ zx1voaei|cMP)`ny%h4%l-Vp>)<|srR>ICh@?*^Lu@j&xY>ID6I43yX-(D6si%w9AI z;t!;nFVHEd;YnCOqIiuuLH&NB4!;p*@+ZE`Su_aZuTz>!=@fM9XE^zbN9KC!1g$&+ zAMaDgUmh~|(jbVx5oP{Fr=W$u(i_D;)CoF_OLk4(v}+c{(cEZ3x6UGzZ!bc}OJ>a^ z8U*o&1@|Y(t%(6kOA3_Pq)nFYGk?&>)ESGn*N73cC6qoVHak!! z=%;FMa<8%3n>s;rs>8{RtmX*n1a+wiC%68YUg`wRr~@ar2$^%K6SSo+oZJgzuAolP z`3KI9Xp2Pbzom3U^QH1W}k5r$INEx;~`PnMUNM zFb~6NPNJ2_{RYtkuY)4a@e^TnK)64kAz~8HTB6oOTZw2*6AFcSi;wUl4fjHrXNW{c zVbX{D{AEyX(Lj_YK^5x`r^Hqos7PeOdE9N|C>HDg^zDcWJJ#=D3C6t)Nbjh)r}#C@&S_At>B?s1rnCUVj_9pQ(F+6gtz0+!W>+IL*i&uoAiB zh?>p^MVvim!n&6QelHFC;B-GglrRgZ2@$PnLZL8sUxT3=4R;|*^C=?HQJD1M9>V7x zNdr-u1eHrCV+&omEc&^}G+unDaic|sVPvL`s$eu|E1&Q6H+<*k@U|SE;Tkl5$+-)7 z8FA~8QLYB9Vh_M8KcY5x%!obW$5`@t`2-vdIy*9d=Kt*-51~>=48Ve|2qW_{)m

c&);3ns$IY)Q==9W^t+ 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 Jvor^Pzwa&Zeh2<|GmA02L+)aw$s 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%0A0LSqR|JXnI0j*wvF1PMmXkzn*y5{y~Ppl7#l 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 k!}lhur+dGQAG(w|hu(nA@$B?%Tu{)$@w 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 z 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�l8j_qci&-ctvxtyTrs;*mc^mjMZzfZ<3{O8qU5-$bMbqS+9gEQA-8GSX z!6#!%XJlKGGlwB>)58P?)Sb~J)<5vn!l}M`(GN;#$w^u5Dp99U1d!gt!y#2TL*Ds= zqdx5tm!7ffi187x*XdJLk*F$UWzklDUCuZ3$~9Ru^-;w=d_roOtj2hPV=`-IYmvzy zxDIjPA)epetuSe3jyBnpRCpC8ZAEx9X{Wb(D}wr6#|mjItNl%^i46%%>{_KA&mtYi zAosa=T7$pkqA5dLTj^L*p?=@M$8xOu%8DHak?d&Z#M&q`Xp+2bQG#jGtW|L+(_?do zj20GCXMt0y%YJnqL1(F&q(DkIEtGD{6=&r;bosyOf1fT9=&JC21~H zhZ^bV6^ujyN$SBds-=E?$rO+mQlmTW2|XCdAwz0lhSWX$-rSD9tKqEXS5-Rs5dxN`=R8F31;vRYN zSSoVkag=PPM?QGcO>rPk-A84f22`)iM1xX_`Km>L1g2K91m>fbpCm9mN&@pG5PEc# zJB)(ZWW>8|GrF;{W&p%ICN?+rQFYOEk#x-}j(Re@`JP+eFOXYC72^`>Ba+LgL?@RZ zD^i!_+4jJ)N@{-ffkeT3wX?N$V!LlqJ>)pdMbMeC2+lVl#QoXlHW|0TcJyhJuzU1t ztJB!hx3!wFO`+DmO-ZI(LD|PG0L1;=j;YFy2jtm08&Kz**^n5uG3C$(#DP;AI58m$ zT~kqTO(RT@D#hg6;f~vFCtB4z*y2JpGZxoYLSv6DpP|Uv{gE)(5dhS{4xsx;+v^iW?pDGbjddJz zkCwVFfi2CnQiyFHwKh5`Q?-H4amTH*=BP5wE^W4Ex}-Uy>``VcvP)Su#~wY6p?LjK z&6MhqXc!o_5)X)mJeTciGu2zQIwU`|2vyNPc!^W>PjwF33-dVW02$}o?6Pvciz3o8 zy~FN&7uhL?N-ZLJ5l{xO+BN`gKnY+tfCOetW!ImzVGP5|a7aF6bBAtSG6Wa*aFy-0 zlzX+DdF(w}(0&PRX-TOseeuF-s<%na3R!JhYf$1Q*5j-)wQ-)T$&It*OmBh%6+Cc? zeZSLVb!)HA;SSDcRgoJ9(^d%Mf_mJBF6W5W*LOZ(ob$5y>sZ#gYowOubl#ErUStFq`3hO9Y{(C4nt>XfLZ z$!-^qfXDaY`*uk(x|Ml%qu*sAUJr}~va!bAcZ`N4XQYZ*C|ar_LWQ}~>cUFU>3pW| zgW+EZn`BBAX2&p?p9zj*rqg^C5;^qQs>w#uA;;9G#oFHIcOZR9oWa2dH}qG=aB8d#G1C2l|y=fiK4Jxo0C-=+5=P+g`U^s z=_uaS*%U1gy1UW+sTvQRo>FJIsz;nd4YbJ1=CI zQ6Z|C>Ffpe`?WLdh8`>7?WYv_iZ5v&JZtD&)wJd{*rd(#O#1Mb{vFcs{zWGP`XeOeO_U7ua(R!%R4k>wRJRQ&aiUQNPAKiX z41ou{Ekr3%pZuUwL=LqqCQ#iF7I}Bf+-{W@SJQ6KO(|ItQ5^j7&-=t>#Z`ECg3i0>uG4>)DcpxwM@TN;18o>YoiRT} zR`m-Hg8?RX#bs{d>%fMGHT2kvV-+czPIXlM@+)Y-bV4;y(I)DPPvF*1Ply*U6qZv% zgG8w#$)@SW3!M#oFg@LpsFVrnAsOzj3ffF4s}qT+kRV+}6GF&JDk^k>npSpUI9j|S zf_6k(wCq=naQ2j7x5~r49DUaCQ~#ruJ34^wy8P zRL{k*19h|6Vgu2oIsUMW!<*K7p>?VcU z5CkVM*w17a#E}39USNWMNJg;hD}0bxOah4|Aq@t3@d6Y4%9uLW<;yy(3}`ZXaJ{VBan*dDwl9@o^TI^RTyr8Dia9*)Y;#oSYIpU4BYcm?iv}O7LDnP1M{S=66n2EB zdTck$HLq0dacCD?Kf7bw(#A3}SFd0>T!9C{G5mliNMi7ut2(Z6(8t%vG?@nAhWfh4 zj@#hkIHlppRdFT))zQ6(j3dVwFWi6Ybp&Yj29oV1)O5U2q;O+NF;pu?;s+Y zj)@4TW8xm2jvUZ5+10~*DIa`Ot<(<{A{%CMxIfPRy}@&fcN4t0rrwbX10$?~#pEY@ z1~<vHpD#m~q%j$Q#%9c1HT(D{&5_8U2$w%`B;7+J z=i!8gpNpk-tUUL}cmjVOIAjOX;SmYDo)8rn&(hMElz&j=N|LiL!4t8T2>>EMVO(uK z<4|iFh5CsP^O@jNmBbB8^B#UkGA5u{>XykIif8@LMM91AGEH(yQ>83igy zk}|8K9f@JEoqD;jW zgpCbDBid2+$(;*|kj0Ian{}RR&;=~dbdT25dLt3Z91M=kpkIx=p$Io1$vGT8Ha~Q+ z+PjJ-yp=>0MD&r;@mH9G=kQNd4Kc<5X?L7KbYht{pySFB;zTNHKPwi{4ne!$^UT;%IeWG?# zT2~5qqVt5?Ats2-%Y^*yMm;JnekN)>v69CWJ`AP7Pw2J-nqzC*@E!)M^d0}<$h5I=9 zx%iO(r|Jjt|7?7$$2{l91AkHtUA&Xe9q+${&weUAr2nbS_w47EukzVc`I`C1eOox? z@crC0a7UD_r#~wn_x}rNOxOPl`7mkt9*z4r7!4*vk0I*Y88^a4<~@vhrzyS9vgrQ# zezLM&p_@D$H?#R{GRDlsf81y50@{=4%WnZ0+LXK09Z;Y}xDl zHAMwdzh3{CVQqEnPfrX)xb}>BNc0rdhiI+0EC)nhq+B5h9xC)`!_kCCz*lWx+UeDg zH4osR8}lU;=`qD?g+~IWQYX>s@Vc{1(tr@@cM6MjR^hABE8?E$2tsJEEM1`zB zqdBM{i7GPV@uY?%JtbBnk)Hys1|UBLT8%q?3bYz-{1oVW9%TSJKgtj;py_GtD5BU6 zM_d{`Vra1&*6}@Q8;bDZY{jAQlE*|ee3u0M;4>TWtjKRRpDAEEBmf6eQR7FFPF+8M z&1~w&!D_wSjJ5OJ*ePDybUMLqt>$WUsRtlA zn)4FPVEFB!onggfKK;tO;pHbufGydF=ig>@jXZp&!Nqd^I9auH_!=G`LXLF^7H<~w z7488Yk!WwPj&2UX_Uo5FsZKo3zqY*7?R*J3+E#PJF*i8z-vR#i;stF-`O7cF)I}L& zcHg!V=bWV3HZQMd+p)5HibUV`7um4(=VVv=vb{TB(w3O0k`HWjtOzKtTS)AuJErZ9 zUO7^o`AwvrrrD~fco?jPnf>+FG56;kf4#UG-oQfO735{Jo-ZT${^h^7R4l;Xdgv*= zsWke_kKTIQI*#6WTh^zy%3!DwE~Jjw5=(RO0sA)x&$O+0xol_6`}XlOtj$3fW`c~} zuy&|3DO45HW(IakSS8*1h4FiZjkU+?rFvXmQ&JdqUwl{1jwW4xGoQbzFIB0ZYWlOU zBWzu|pUszTw_Ghgb*h5==v#v~B`#^b`5*Yjr+#?QeRMV7EXVD;`MBX#;)CgYzBm|t zMK5uIy+EXnMRVV*l?7Hd!Nw{rs6#bmc5TEj|MlB1zj?fDFf2uZRps}Xq0d-s%gKEN zYPHT}n&v`xU#K2wqD!pG7Lm?15!to`lx+tY8d>2JFwf^pb8oQDVg^qTqtC>Sig-yJ zEH^VcA#{K{F4mX$O4$xjqcHA)T<$Q3 zLEqy**p`(NP&TV*y|6vOS6e-e_<#8&sC~L+!c<1VMx&?LRxu^}9hijE|X+SbQRbesd>7VR9ncxfAS}51E<|*R`z(Xe83L9TK^-3(|DN zDH3^&8xAd4Xg4Hw)@(QkiL`C|NyN(*W16`XAYw9fvW~?VZ}8~NY(4#fK9qXc|6woX z9l20Swa;z9A$no#M8Lm66x|SS`ek^u-A72NZerK{u9}3<-A_P!wB9UdfTKS_GIdb3$Dw0#s|XK#0i70B|;YK zVKQX-H2n^OIu<|EUcVDWd;L#D7C)7)rwPEi`J)Vx+bu;BjQ37i!n~fSuL`GOJn6$e zE0Q92T`p8Ir-9=e!LzM2p8?rSGi@W%uX&kt`nUhFk;a1C05wso4njh-PI7j2BjJN1 zbTaRo?{AiEOIt%Q+wBGfNel;@73Lk5JUcNpe016+8czIV$~sX7C+Kdke&Al1<$N~Z ztfoJB&g1aSX2yHs`KaUBo3CF-qY+sehxEXq;(3@~{=fgDwgI@Q&{-rSo!*1ug?LjT zH+rX)(;8)86R9!L{whLO1>^QwZ_zb$N=tNF5u!++6`@ko`Nb4tU6zk#+k)(|d?MKr zOo!#uhz=;yUlpiTXBAOB^;iF6r`Jq%wgG;NkrC(mh&fd(8?Kxo-pb*G51ympyz-nQ z_?D5-K#1Wp)N^)9Pn+rVGxe(HGwxlf8>Hru(iyjqBxjJ&;3+oNjoazV>GXAr-urNh?Cs%olay_+w;#Azw!;0^w1Z}rq{YQFY(g;&AUPCHNL|DU-xYi=yp5eDn0 z+~+U)!AIURDmo$;WtF>f8#^oScjv{Sl;liR*_K<9bLofgw+{gBBtU{kzBAKtJImt1 z#tj5P5S;!(pMJSQfRB$4w@XXv+R`dMNIZta<&XL8<979J`Cs731CPUSjaFa5FafhY z7gcyTUe3NOH=r%S=zau0Ay`#BofNF317mur3cx-Su*imA>5H9FM3t_7s z7E=P+OHX*b2y0JNl@cBr!?ha&K zOl8u!F^Nco9JUOV%pn?$nuE&?nnN;;Y5O*Z#OT@3qscJHK_R!qC3yMi>CI}pPX^Ph zI1Jz4KN49LKCWD%VaIye zms-p$6jqDY6CSIj2@@b{2HJr|YEKH78b_VBq?Ox*ri)$tjw(`ioFLkO+0oQBakJxy zE5m0;6W2u1jw7xNrX5XO6+}3Wx;C_S9CdAk?KtY%K-+QDwehy2se>KfcWtntv{QYj zjJ_Qyy)FoM9C2kV?l|Jwklb<9&F-r6B41axf~n)jjk8~$b}1WmQLw8Hqpk^daTs+; zu#1BU-i4m72k)Zg7hMsoSbEMj@MfSlB;A+TYS0c(`FdcZw!(F)CSPZSX4bRT{&eV( z0cy5IYR1k0HE5xhjxv+=!&~XDcrrSu(t_ujcRJNr_ z?@PaB^6y1oVfF7zziIgI#Xw{G@5Ml4{_n*=vjfL%89)FA-$#eF-c3 z?@QQ<2fqZ)tmUj>0zB_XA7iz)XzppVc9L&dtj;Yx#$fFfrPo~TC*NbNc2e&&Rr{&; z7^Rm=^C;46zwUd0Wf!ayF*F5bc-)o%qlkYW6J2`Y3rk&IknId9?tCM=C zQQAqp*Cg#EKgJ;KWHH7Z?PM{=80};+#uV*jF~$(>WYKGeR^8OrR*0=o&Wz}^wSoz1 zcfnj((y@8y8ugmdZ?mM(W-Gwc?wG^qstT*BHEkKyN0BD4ZPA}~4 zBynp-V!KApjBdB#WgrV%-iEjRZqsu>h?|Mjwqs(5zJrAJPHpoZ1LOn2y;g+Wy2c>$ zD=sp~pxIRh0kFKx&;V>TN^#YotbKH!foU5Y&EZO$AWgxAGE#8V^7{-N3~+2!i@VSu z$QD3bM9WJJrF8k727#$~t3jgJlFiT77ND7}iYCmiHk5)THyiw^*r}a3g_^=k&v0dd z9uk5q3lA^^meSOn!~kRFZXmCmyc|bq_HwZN^erI8`71)^{aFAObIZ-(s13L&9DnBK zaGOy&iDP==ERKPgF<9^nle5q<71(B*Rc3OKP?*XE-}YS2X*T5(XLG?^oX!QLG@pZT z$%J+@5Qfh7@piYx|I(c0mUy3Q#cK%>7VfWGXh*0*7=X_JVJ8EbL6hu+CNUZ0SzA_R z*k+rF%W6zhT2^Bil(Ds}#_-w2Uu$$1)s~mlm>4pbm(?7SUshwNWLbT_+01@c5;11u z=>3D8Xl@}qCIT1!_LpPy{=xYHLVAP>DDI`N&j{edZgYWmwWr{6a0O102I^)T4_`E~-2r1&!s)SdaEx=fF)@D51-u8=o11>TcYLJm8 zrWqtCF}pZKTZS{I=8oBc zOi*|)XDAo_w*fqy+cDuPMYi6zUzk$Z(%r3h?s{}Y_b~ZTcydB^!cb!cigP^MR&8Mn zlLh3;bhUum$3HuS9S%3k#pB#nbNU{ghkidvD<3pY1mRMay77}VhAT|B7%h+>Zq+?D z9HV~>c4$$pvl8ety3<|C5g)O{zV}P0E^Ltx@g6m1s-!H}-hddAo8V-NLZ|*Q2I>76 zMq`jV_{19nZ6i3G4mN1`9ws>*tsNJ&Zm@f`f{+EAk&W&Cf_R6-pnhG3kUp#^W0tla zzzaeHeAe#{v`F)JU`07-d$1@8BMkn&_ArYWu8LY-$x^CCikDR_4zxSutA_nRGWDJ2 zh(?d!Tu>?&K{wEd$&;$NB{Eeb*x{Il%rvIUJ7M*H2}&u;bg!`x$RKte; zt_qNJauw3|ELm2y9srtN(k3vF^}sMVt0I_zVmb^pe-${&_2W93mJ2nK>uyy2S|n#X z{LzIJ<-#lV@qdDuXEVdt0&`NC z3`dY#1-+OsB%NIeR^9CL3ewd4v=2!P$9J>8O?oc#vV^f#YyvU}M7V;)jgVskJQUMk zGSFYlH#_7L|4%Gzpn$Vf@ic^OxghJaXNHE-1t>C))*qd;e!rjqcZ)dAlMZklbm6iy z-fO0bz+AJ>KRC6^0l|<^%2{xZ?E#K-#J>e-pPB%a~)n$~p^uX|-UFk0c%>FcKdv`wlF^5$AtM&afqIhZ_KnmS#)$YmT!yIz? zL&z39p+nhmZy+DJef{$n^HD=5fB4Aid6DmMaKHR+H*_rXlef#=*Y#prPv7-RpptJ7 zZHf;Sh! zkQKn(D@ra>j03}a*de``gXAA<{W{xH+j9@L!hksaeYSmz4=nuxfGAy++VS_VtNB+j z0$PBi60uvOhHN8|tSM3=Vv8&0HM?5E;}n11i($BeS7K)7;ohs+1%@;Mr5OB||Ks*m^dJaG5YQKZ zvcTvB`{2PfI_NL{3yP+fi&qctKVJV5fBAK>egwr#^Yi@r`pf;}_58<=;q>|%9;&&U z-CnOCjW<4Vbn)Sj6C+sQ1)@0tr!OaAD-aPn1hsJuN&oPv8X#gxOwTD3C%%`4_4_X{ z5wVujZy!Ehql}OY(gXZzxPo3G+rs?9tesTt;lvZah6j39yX^&t5jE)5ju#I)BWeIk^AeWBM5NHpu1`;|-(JHrFW8#b zD|-9IbnLfSe6H&j)V!wm3mVZ70D+ILfdzHf@_KeXTr6N=xZ0h=`%5rPu2(k~|9iVR z-0l_=09dlPaPz-Q=pg7}STr3Lak64W z4S4ODUhjSdmheQJz|vLW*)wA6X#C@U;V6MhO=4CT9~RKmW}1K;AFp9w4w7Ad#DyUe z$rAm?{|e;(;~yl3A99Yb*>QyqySl!xedgvzJ|E3^$6?6KNn&Eufo~Owv11K&{6q=_ zCj55k*uzA&r7K94evR*Z!$hT(gPMgy@q`ei1s%RS{beg2KJ-ZDw%}^vS_mM9TgyZD z1QFdgdHNSv@zjNp^I!1)lIH5^M?187d!1E(rOb)Y6A;>*#iJ85(K*8;URjL2MCMW; zS&r>jc0{GfuC(aNKq{IeC{Ms}W67;JunMByhS6LqKv+ABPH!neob<$o7Qup&P4Atp zFHVxO)~qmQS~vAEfYGp#G;+_t0R?cmUXvw?OQJJ$Y(E++1}z)}x_EaoU*ZaKOgW)p z+`jwhlgW}(388*9F!pIUT4;41Sik*$lB3FD`y{wq+k3_!(2(f`gr;0%a0hpgc(wSX9`W#u#E%RmF?lx z@5@_w!m$wl4Oo3gNOpQSHE~S1Sse~7mSF*YZv^|k-Ynt`;8@~LBzu`Dr~XIMbM9hG zaa{#Q01ug8fnmuNDYjUsv)$Tk%*;Z&K(Jve`R4T-2Q=-HX&~K9`H{ zQiSxS(bB3Ju_3z8>TE{SfWnV7jWuc<@rfPAuu8+9v`mAV@slpWjh2Qs8*qAsaMeE? zSFEce4ku#p$T05zzQ06w#LM-=&x@OPYxo0xSrgK_%}pDbp+`-mAP*KdPGlQ_c69{S zk%^am64G$Cg*s*h&Z+-dZmw^mOrV9ZcvjSEjQO{#V+=?^qeB6XF^bqsdW=YOYZ$oj zT7@hfpmC6`f^rz%3g9e&wbkHJ5UZv=V#zh|L39mtEV~B2SNJ%xR@0O*yhfhkV7r@b zcH4ihc3;tVc}yE!4dxjH(2YPlzkwYEJ=_fbUK6RL;)ZB%@aU)qs|+7*4X!kVSR+|j zBNhGQmrEt(t{yRgDA0r9ashdZB~>i0JV&S?qov2Zmk|o8>xr?&0x;p-cE&1OxYTYQ_A5&Ts1$+6@TGWs-E>XsAtF~EUWqO0r+m;%}Y#lr)XYgt$jjKYKkDXoT=Vm9KY~kuF zDNaRe@rH>2c7w@V5{jzR@f0?Yx-Jb`WJ@mB=}1k&Ftfk8nnMwUZ*$I7|*qXQUXukJ92AA@aVwTHk+xqazG$ z3(lO%Si$;rVPJdhXT zR%JSXdHM;wuox{+@BRajUI_{89i-Ix_Ip(}dPvI=GLuk)Hldz(ce%=jmsgAQn);alN>O1f(Cb(;n;zmyZrKjDl=|6N@diB z>$HLhjr?LggVO+Z5LXbPsmCG0AUBB85T~!)0GFjXM{Q@Qn(;n@#&AI6-%u$>|Dp3k zT3dGvhr!GS!@|vlF@(?s{sK(Y_r z%nm1_r|I00ysZ5fF$>*1j^r73^=3xdp%^Peo)c%-$)galdkInOS^V19sb+=}Rok8Y zG~5g&DvC}V!NJW?V&S{4pAary#?t6jthk1a#Dspcm{P}?&wV{N9FQqV_Lnmx=|?A- z!5Ef?PP_L;i8`@nreWgxZxkss@LsL954SUTow&2AX!4E5#a^_0#cnj;JEbDC(2+Ki z(EjQqWDG?|Nzs*~#I>fQW8*t>6tN@d&DRi?z1%!Nbhh>8cdVHBI`dxm(5o@N)Uy#x zXQxn7*9hHC)u^PC;0evw2%p&t=0;Hj-N_AaaX@z0hycvGqO6lBhDiJl#_jjnX4yT7 zaoau~8T#8JOP%ciI%`E+dxvYg+5PM!Wj6Z`S<%4`w3CnB{yS{nwXUF#9Qw$9U%N9o z{VYaT*(f~hOynnaBz)|v0=dhGrcuQBXCDRQDncu%u49=(Jc*(Ch(vrh|I1Pf2?Mdb@LaNuL?DNDbuv>>E1+cFWt@{UhAw z+C6UE+wA(8L`h!uBLJP15Rkep2I{OO^g-|C!7;wo!EsS1Nuz^f0ty`*gLm??Iyk1_ zb#PqRM;1LqkS+q^+Ip2RdWc41LWf&SsjJQBzN#1xktJ+q@hCFJLuBc+=kO>V)epApIqE&g5KHj zCnbADR29XTcNm+eXo)9cS|yT{b&7sQ26{q)S0mMi^f3qtp-xfGjTN7e@ERs5?IVo) z8D`!$wZ>9Qu@ieeKIj{ z>ZG3xHFDAp#%!s$hl)(zHXQ zn}Qu8NJ240y2<+?f(-l+=_Z3+_2;&KuZ~?c3J}&65*fHof%wT&knQ~&q&w_nU(et zo|veNjD}*KW*D7Z?Vdd&;%9GG-bZ}EnQSRsnl#nD>UY3Ny)TI{Hk=fVp<%%~YfJh$ zlhsWBw6K$`(F7?8{jeBS6&F34F?D((E$*xihU8cRR|}h*zQaVusK*F>h1Nj$-6zWg zql+B!a{jo1G>ji+JD0slFV!Tj)P97b>Li33Blao=?ra5$LSmaC8NK_kFp)_tkM`=u zp>)kfU%_aXcmzl9FS9$hc9=i>ri; z%OOW$^av-u-~8qH$TGW?(4IB!28_96H4fcn4jqAwa}`=J++KlOB$RgJ*|Q61Rm?{4 z>{(vX?DB|9XAy`fXs}nBHO(bneix@X?H!m2T0?czH048Hq2VyWj#5EDDiv2-Oj~m7(=Xu<`DH^qREZcGO0y{P(OxT+7 zSk>4B0R>h>IIUlC!#^8(u1+`^-pRX0o)1ogek2f%kR($IKXyn?<~|WLW>P1*G3yDx zZ31=DcDs9`?yUAs8hC8;39eGF?VDWMF-qorKN{J+geG;55vHSq%xR6SgEM83MGp;Q zH(4U>j_McEE-jXW>#Tk{&D&SP1cZzBeh1YxbI~gKeRjXNm3*rF+(oO|qS5Bf{N2$d zIQix4aY8Lmfh!^P=%xW9Bj3(`T+Se#)~tidSuhO1&tu-;Ce{7ws3~1vftO9!w~v&_ zns;6E%{<^nIl?6w!tV|#&^`BI{ay6O^8C+$y}=^R^k)ZC)AXzRS4%l8oo8&C-eJ-Z zduxAn@So6I4y&6rG#Ng)0N2Kr_mD^CQ4Fc(rI{Q_$B3x-j2_QX{B6mqZbtklx3>~Z4L(BL@B4X_o zCII&^vJQ}d?6)qVsE3}_jAN(g?1#ZL)6@P!{`=eUkklD-u3_Gom$Prn*>0PqU&D;B zCW}V|<5Pf18%48IE0bw876g8WH5|bJjkr($x`b?%hknn6iXr;^G!5hP4b_v4)f<5K zgZN})@VSofA)lxvLsF!?BisgKf=hq0>y5YD>42j&q6sYapG#u~TV%$MS8U3PhE>S$-;rSB)rC{b+Ox0>w;}K$uR4=O^7^(eMKLIaGRpqdTmr8q6=N&>fBOF6{dpZrAn&M z7%zBBGu4MmLr2w-E8416RZ(?Vd#D&5k@j$^sRC1*!@~p&><_d1#Y~ZQaROF#2J7}G zzHQDufYU;%O=5{A>`W?*q-{wBh2N7@5a?j;ciUwAnP^!RI+OEApV7VTesO)n5rAHD zDOB}bp}YE#Ksb-&+{0+f`Spmg!WoJ4ytF#3W>Q*bq{117j$)aRR)>f4;>v|qtD78W z$OtTG^MJ)RdJLhg`QZw0Q~D~HEvEmiBywbKPkJhv13DXKtmJTPFGYG5PNVgTiqY)T z?Stj6?lM}SN1#EEMBJoK3n0qopySnmWsg@wfs%|lSq*56B^FI3<3{j}pyXi>RU;;@ z>p~Gn$}J4T1lrIq7Zf@k6p2?iF-(;jjrTy#n700R71fM#56d*x!F3SLTdN)ci8qYH z7~O1#RVHbMrnE$3ER_N3Ya*C$)j)5Ltg_o;+4Od%=OGAKvoAevw|r`IGOm=?ii~ko z#$#F!$!Hv`LiNy~35|;NCAGPL;ZCnso1Ksh)6HFsZ!%zH&d{GVvSere23yVb-5oq6 z$A)q_+5@hlYFH2?z)EV^LsVrX4dOwq>h-^?s78Z$SVn`mCskbZg@>)uwVmmKeP{ZT zDmq#*0Et4Yzm_jLQh{YCqn8e_Yj%pjt zqqervJXUi%&7(E8)I1V}Ne&$YGEqAkvKC)s)b57(MP0DGb;B>fnxA^1Zv>+{GTv zkCB)lc)*l~lZWW24e3*lXa|%3-9gA`SC6R}N*=a@i`BIr)ej_J(m@P!dcUGf?=H0> zqi%(vg!#Nj<3ex7xKe*cFdem`Jl+wi?bE2FgO~~Wjc^tH8bNn(viZ9sWZ$<@8As49 zWOOGWUg4sZl+MDE&41W}vwm#12qD{$nMRLT1fWY!I5LQb#4 zp}?RjoeDXo%CQhvQP{dyeG4(ZYWto`sdq8NtOQYOUWOQbl%#5BLtaI#!y(60IUR~> zNq&ckOIOWL3ukP{^uoli&EWy_FPc{stG->QUntvR7d+_s6kgKw2~<^PN@bXUTm7Dt zRY{n{g$X>P)$uhL`*Z1rd&Ak*MC4zFz~tv2s>OA zb7`NeLgsh7D%6hHR;I}YoI@c{GFZe)-Y}aSb{r~t)QEKL<&#CZ_M$5TTm`9d0*#1i z#j&|pOe@!2MQCeiigGSN=h(T#>NiU9Yi3Za<_t=0GMkhDewv~}Qy`ff02Zq>Z*$c} zH^z)~UV{ZLyk%B3!mCZXp;cTnzj{PG!&kv8gSdYfX7#maUj+B;saoKv^cw8H0%@# z;L?IZ%X!cqP3(~B{f+9^L0a?D{j4IIASnl`FeW*T?9i*6Z19wW^%kTns3K$1`+v@E zZ!vB4yV?D^)iIc3K83%di{LSdIzt!){#X>W@v<>7P{1yD5HN*jCsPhpm6`U5DN%n` zhOJBq`PiHaeyW&#VoIZ2rK5RA(LM=$RYbc_Oc4A?NJ=9z$CQi1%ZMKR3mERSs>4k3 zCQod?H~^Up1r<6lJ7wHY8OzKU2gl79FOD}@95hnpZHEZQ*eHh;Ln8%#4|i=;gez8v z6Hr*S8H2-NsGL*NY0H*ya0nSa7$6K7S3y#}enBn~->zd?0MNOK4$tT>?s5 z=@OFPHd&gVj!6-D9xulyZ7MhwSZb4yeXFEU|FEqONCn zU^XRO2DiJ}-NST!lPpXeJn%{2X(fzHs{AJOiY-?D&GP=s?rZR~HW*JZF$*%p z*iThaD38&_{cic?&FX%cngC42F>6-@O-#e@Dkn-p{oC#O^X&Gw8DzYgez=^zeExCz zs#Ry?$>I@r?n_k;oV*uzvn*p;Syv3SQ^8@A5ItvY;6zT=P5fGw>3juiuOVWr3;Mf? zV&BU%NUS+QYq^VN^8~ZS((mNW8ad(Cy%^>_Tx&d$sSEtcj z^y}ztQ=pFDG7#$61FnFWsA;uZeS>EWgf*Z=1V(L4gcgLTfE^wUnz-qt;r{AzGb_?s zYCC7Z&2mbH9)?Pa#)yY=X!_$}y@ko@96%sBk86n#QEw#(_?d|IR%hlJ% z9pqiP`g{3(l!Ozs)cMthOfG36GX*gEoecot!7{vX8gPqO~^ti_+M(fpt0mR`IR@%G~5#iuD81KFMQfBXZ$XeDp6J%qf`BfA)CCw8&3|0oR{w&P*w-q;?L2#gxV zRe{nsAXi`vzFKX;U$_4La(%yrnmqixxOumRKj7D|bNtsgV~z_3A|$Z6K7PL0%zj=# zCL5qef4A{o-DB1M$SKahVU8qon4Et*#mNcc2%n?DTabmZdWZaSl2W-JgbYp?DLJ*{ zo6XuK+s(fneV)zj(?NxFF}LDlU{`#K`4u0l47azd`Eq*4w#jk)u^agXz?QIlo!mFJ7-U(4&_ycG&T7hA?ktH4qpUFMjUaKDCepM-AlsvfJ3= zb1>!e9`hzVha=Y<(9B1g2p@KvY%Ua5eckw&P#z*lJ=g#x>GK%vVR8{k6d6w}Xf#f{ zdAF=Y3WYOzIpn{JNCiDv%?AR@rRScZ2r-fphP+LstXj1dCtHfDnJ{Z~_=8wU;Kqh` zoYci`xJjl@=rG@ueeb8C5?)tvAzPMdl3^8du5oNGlH?|XF?}0dMF+IOAqiQ(&ZXrD8QpS%F8yG!KGXAccQpQ=f43f88uHAgjYXzgFyP5Lj>QI!{W8-&=?XLSWcWxH1`B3-MavtK1d z#j9=xNfWCHaH_eZ>IEOKgMTDb}%{ZZ`ewQzXwmDXz1}NClMm@O&AKGr_2GO^*+X z5g4(-zp7LxcsJwqdj7cmG`rO|Fdp_xScw;LJI;&9qt(2KJVxYnF}8}C(L6BcMdTrk z7m+RuwaI$-N!5$E{kq<$yodx?co79TWiO%|FBEIRbY-IFk$R*7WAnH~ZHzY&LCUz{!~T14~-ru+)LDnr>P2vp;b1zD9(aI5eMZWTU3pwsdR(y)+yf@ai+ zKEbW%6NIOjmQyy`f^a0CAfd4b*pCLD;gy3t#Hn0`-0OH9A7<4ivu zt!Dc17=r1?19PSy4{1!luR)g>i;@TSt7O&mdxSvfFZavEKjxtH#R(t9IwlB(DaeZw z)?|5*(LDg%3uHqgu?3NQ%@#~?8)MKJgDFyO4SsF-0Vd=J;6`P%3Z*RSav9$MN3e9G zIxj)iF6lZ{G8dFe+Igylh(T#AL^(!dAxeguI6kuv)dMFT#kzjaE1_AKbbQ&G@C%fV zU|&U=3sqk8)ZJaeFmiZX&jgeVpoo=jmD&K~mg`t&lGA$>Ejs)lJU@)^?^{(Rf*wx)0yNcUmC%8T2 zaz9E7x5rL&d+aK150Flb-v>O|?Gdvp8Y_0Q6d$V$W6wrD0BUZJoh}q=r*M1h6mAco z({g*zu#nvzX4HsokDciDfII(!+kpI1R=S#R1 zk4UE7yd^4;3d=zeo}VgXl{w0wG|bT)Lu-!KR~*)gixaOzd-Jr%GtA&~soQaRHM$Ja z5p`);q;-mYRcV@}dENbt6t+1zyw)VuR7#wyE`DE{2i}z;0o3O!Ue3K-&ez}I<}2oq z(c7kYAy>ep6I=dUT^c;0`+fE0E9^W$pe;mWDGm?mFo?l2k75?o>Js2Ie!HCEUFF4Z zo8?c4grR%3jRVXH8mTNEooI4j>T+O9e4K6I-ySLO3NnL5GL+?22?pGIKvv{A>{{S< zbmiiDF7F`c^9-{eY+p7So-%XyAz&LN91<%#i<^i~4HK+J zHA*I_9n_2xp)76*N4qX3Wpyb`8n*rP2)U)&`K!?V8i1+Q z{m+O^o{kK$vg~DWQ#%CZ#Pco#l&Mlqq6`{F4u+~`r6P^V0i`m`z?oSS$?9iHhJ{Qr zQ=;fVXPwrv_k~s==z6NZ7?`t3^9aGrZqx*Y>LMrG>Hd6_sUSmSE9O#bMG$R3rXwWt zj{)T@KUPGGn~wg8&5x7~7q2L@a&fGlueQHEY~Q_|K2OwR%8XLNYrxRdh^e^*LBsId zhbv^FP4>qkAwwP|obf-SUg42(4STbm z&u(1;+N6^N9AKE@Q1+OlsKprl&F}7(vo<@l@RX1s7eP8xDS5r!eryRwP6wi54!H2o z7LIWz5E6Tcg>rcHt06cXnA^@o()si=#C!rl{oKreH7e=3c$u;=QI#@6^l*WrWR|5S zj(M%XA(d^AisPFiqRX#9Ni8&sP>E1qhcfueQWU8dVIhbeAXd#rNVT;flS1@vlvD*# z$~9@6B&~%h6TGoDWzd!7DVLUApa%Q0gd28lo8zOGQ+)kM zk-5%r@@v;|Oj((%c94*yHB5pR*D(n}Sj!~v;t~-!o77>!2rGIFeo{e zTeBs3ggunVA=*l*=;L}-WQG)}qc?(}RkUlifmB~}55(IOw~^)-r5cV_+voH7@)jK& z`E5fP3ttKzg9a^DqKUKP+{~6w%enLE)LsZKq%G04Gp58;&z%xgIg3g})I^_BvnlU- z1_|d?Hxf>*sWYbheVs%8R??^1z+xma#B2U0Mc2_=qMxkKsZ#>;bm%8$*9uQK^%B{C z2HsjY{ut1jB3JbFdUM;vQmxdkBF5g}w0KRI*Ki*%4FG4Zg`?WP*%AhlX+M=@@iq78YF| zpd7fWohVHbhiwNg_en+AWJco9wF8>NRk602UpRa}(7BHq;=`F)1^c^ozz4%ok&i*O z>*E+yyI3Zu@<7T3)U?Uuz%88#6MHt4)mTN)Jgl6{q8&Ino{FV?oi@ky11A5VAvz4W z?5%&S;I+#1r4>;pk_WdNhgLDi$3?3dwi-F%5xzGNVQ6#yw@f>HpQ{HPgfrkI82zac z3f|X^W9W36o1V9cLbSA4AY+V0l12rQy!p8gV8;9H@VFWtvgRB3*ek|j$&6^j?-UbUN^MVAmm{eiTogBM z`HY(jb833JI;HA%YE8pE5OuHX9atp2)k@j)v%A~4nZgWoMlJhQoEgWf?aNu3>M3Q4 z!MzO#(2yP?x!dUW&8P60o(T+h9S_r|h>mJc5$VX}=T@d`%+ZC8f^Zj7hwSb~x`R4b zXXogvJ++#{=2fwyAqSJr+j2Pma4m&flZV* zLYEE|xGxGHW`4=3Q?lXPNXlt|Is&%D)h2aM=e>Z>$|1~G>;U)!tKC1J2D9qovpz3p z-q56LF@O5_o>)eL(SXDt_1!qCBK|UF zHM>Su1AbABt|w>k{>#X!ALc38GCd9rgIYT6$E$1C_0#C4GAL)?U$&LkaLSn%-GoC)_b*2Z{Grdr{ylv*?mwHZb^s zl$BPqV5kVzFY477!HQ}3B=w3+zFvC!RZFxDwSz@E^wi>WcH_7vU`v>2}`B zhsOiSbIjG0F6d=QWEQ1mk(yFksR-+Ov`&RhIfqQct>Sg-iKp&$4HKMRMzB; zme$+lT^DP#yiy$EoD``T|Mu|M%{av&#z~Qi@r#)hM9hy&tZ|A%dy1r}$rz6UUvHMn ztB2Wq$z8wWdE<#-fky7IytF031Or_`W_XSGr{&+%{1c3P716h}4-$wsCByBJC2b9j@qWQfPfm^elWQq#N);txyHc1=PRlw%W+2odsfZ610muCUpFWJKP zCV4#4d_B9rdRQ(OZqP2bE4W6VtnBREq2o*enKTFgttAtAAz-L%;Dog;1SH&r{i%hf zLsa{t#b$!pCI8%het!?oh)W3+_5?KU z5|Eahv4Va12v4btcU9Q-iWO{$PRTFqEGoYCNcL%cyPJLK8&HwzFVSPkimy${uy66D zV#uKV1>Pc9OD`MnO@_TJVbf?AJ~qX|)!N~{f|tTS-^$?>-1wW|x?LfV2v;&_%7=+O zz~WkOe*U?I-c;KYbfcd^q-gW9yeS8sJ%XJd3(>W9pJ6kJ_#~D1xg{JW@%S+7+sxpI zN^xkZNQ#<_@uiG+%iZ_&=I`=m5jR{0bPC28nX;OkMIWy}f1aP7&*$gIXN%$B=-dQ< zMF1`NCg|OHe*^Ef&lVrn-Dg8Ljd z=i;@}Hkq5iK94OseWfHe4z15rVX zC54PyMMgZk7HR`b1Z0wl|JIU;e8qO1xVXQ`V(wYR6xjd) zgLN4XLqs|D9}oUe(5#1gY>hLSWvlWmvzQ7uGmAH1Z12bA{OkStcKs!b%8Of8z=k=q z2R4l02-|7C+}{&Gq=CW;`nN%tBEg zMO?q$Kj8KBEbUriqwvj$2Fqw%=wXj5^{)fys}h+W4%POp``JgytWgeE(XS4)kBwcR z9J23ISI|WbFBH9)-B(;-Y-buLbUzv`HGn2{A&Sx^KixE<3YfTnZUW}Y5m6`&$9y7o zQy*+bA)@cB#Sv7{)`#Gg`{k`!LtHR%TeG6$(xK8G*#78iWf G=MSH!3OU;F#Z5HA=2)z5e#g984j+$s&t%X82gIIvc$_H$s~#+qaxE% zYD7<%LfRt)7y}r{9+fmnn0UGfgIUZnY5hhk!a_b-_*7GIxyY$%iUv{b*#P#j$XvXX z4Ht}5-Lq#=9kcK#7dy^`v`ZAKQRJ1HwlX_N`~-=k(5FU~#|kXQI4K5&6yBsj73AVW>axQ+ z9z^Ydht_d6gx;mDO^A>G1&{V_Z`a@9>4EL;<@(|0#m&1l`~kmyo#Vg%$Xg?)(R$fP zfzLf_l%r)Y@ysf38qMl&8qF$i8qI_^jpTAa0>L84n@|#9x)QE2y&BQm2X5lVd z(FR}`NN*Yu8vCYEKJ=^0HEsU#iEeKaq|?8pGHed`oL0HJ01d@yD{m)f6p(LbE4$F` zRGU@}rS^OcWAM7*!72#wiS3acAt!ru zCsAAelzzIjrH{YxCKA0493(V~%>QokH;(~(cxH3&lvh?=ue>~Nlb3xp)g$;$_a#jd zls0C)Sl(&-8+F&)E(GY12tnK90i|7sj6;8)o0Kx4R;JTCM6ju20tI=^lDfTvo68mx z*g5x@p2!5l3a{o6Zh!w`gPAn&m0W$090q|&*d{M4PrBKem~h#~l>XmqkV&ys#t7&V zCE0Phn{UaKABG4EuTI)5z}dC-Wb12R13|=6u^omJ^&VLU_aMlK2Ehprp?tl)2JJ{_6y}0|VIw@n zY;InXKV&Y+CqCq8v=knncK`Cqi;h8xd-R81ojq0Uy#qpZvtFupwxhAmet)4JK68%c zsNFp1lQm%Qo^UhFsUONK9?7xw^OW|e=Ikl@Ub&2Bz6-Ihb5pJKyhu}@1@RjAG19_tOinT-pZ z`V8F{AMRFj?RFO37hUjRLj?H5c*r((vHQYfwB=9f_its%ec}1pCBgr0@;B}a56_r; zZZXKJ>vg}!ZSu123ywRi0DrL=l9wD#~*T+4m>6dEsII7WSYOF9u;U< z?w6yv1E%MG`9tFFx|ZzaWN?sOnba>4$17(;Bp3@s+JsaKclVr7LN#+cjo?HT-cm>bZL9`Lu?grV&1$HU~KQ$w}vyaSIS*@--~XdCk2 zf<4FsQ)0PK(=Ti3eyM~8>MTPeMVOXFeJHd9@qa#!e}+c<)3P>y+*y74u*xn=@s-96 z6~UUC0#=(orP=@V5z?qYZvW*>#fKc|F^=IEh$z^iM*Q=E-k^JVr{juy)Ch%`hTmGA ztA3sV#qjjM+dL=u%<;dT&v%cr+rAMz!CO=%CP`2fw*{eb{I6HbZJ!jBqA^1=A|#~R z{HY=Se7M>zmtvwGepFLKl$f^rGlE({Rv8{B_~?+XCP;y4$3#X@K@O+Db2Dk)uI~H# zg|exz$RrN;rBkBWk3A$xkQ0gGFG`92Yq|OR^=uB;e@95fB9lbi7llN4JOBCpms`jZ z3q!ecI!!R`0*`H4i6g8K3boAdj|)`boo$3#ro^PoTt#tP5R)P1@$Sv+%iGK!#?Pq% zw<<3k0=0qr)#hgN>D;@_a-CH-8Fe^py3zu7cb~#(jHgqSiB%x6?huADt zA|zrBqAe*Ub9%cNCm|^y7MUdDzO*Hx1c}po%9*BVCQ6a$;K_Gvf3#VdI4_*S@4qcK zo7FV zZKb=)ZKXTmwvt@#2O-FqS3iu3{7Za$DE}s39=faDR=SgKD*+y4{=2u2(G)FNWf)&b z$|bGcR=S(2ZY$j>ZY$j>ZYu$u)@>yk7V>Q+Git=!N_XOIr91Jq65&X(nuiW$7b69t5ixHz*d31Uw`6q3`0ortKpuoDUt zB+QkafWm9%Bv)JjR?xSXbOMeauc1gm1}|uNgh_uNDN*7MnD_u@v5zJS$8u8G3QmT}wHOZ$^18WODph1JJV$Vv+OQ&hh z0Tc5Vh*oX;w;>L5i0kFi!Oh|9d^la4ADm6jCX_imhic0$gDWvUsuynPKjx3hMZtqkbw>nZ~71P z0t&JI)BkSsH0M}1*=dhv{FrmB0@F&65o`-$p0qW`M;i9zE4AlBQ(|g=v{~Vdfg{Y- zH>DzhSw$EYf1~YMWF~ zEblu{n&~L2N`xAy2GN$3(rZw~%U4hMrXp?8iGhlV_GmvJgiFIQghFb%R1!$WyDea$ zAYiVQ1PWz1HF&?6y_Sx;y+{(sr&hd*$i#27uGWwDy{F55TRaNc^+t|tbs9BHe4;@W z&4AmTFbNy73^(4IWuFveqfJ_dtlh3e{L1QKhoT zq}sSI3W@NX^VM>`ynVgie0NR@fPe3;sjV0Zdiyn^x17HK`UAPzT1bt?9K`|EX z&=Nvz=9Jy@?d;*x>~_^VSxwY`Zgo>u4vkExMtg05^ak^rT`3; z`I35FZ3;vv)D+=&n$a?ejE}a5+46ptr@4$zUZ%`jm1Wb(2B|0t`JD<T`CPTX`Bq!K~Nr34H{Ns4v}*7ORm zRIgmPgrH#MZpRRxgbYa-myD7Q{kBxSJ;g(NC8b01B}JnIq&)+6Fg@xzawwv~Nun4c zK{Wb3N-k`;SIgVk&*kF%ht8hono2#t4Y>7>Mk$2UE0a1}CpUcjD|Q z)pu|GaGvhdJ~%loJ_%y}9@8M?BDg|tB232W6_biiLpwCkAOq0<93xbSJ1vhf#*Ot5 ziONuP*cTc&b}4w+ zu?)#YLaLn0a{gCoEQK>#+N;}`HF;rbdgs3V# z4O}sxWyAX?*T1@qJjsQ~XU}q*ISa0;+|O?is@{EVso?g_+y-}{8c}SOz2V!Svu7>D z2rGS8N-}aq!N1nmQ(QhEjX`Aqqpgk3fU$7;2~1?n9!8C)FRS29}5k?ef8#_kS4C zLCE-GG~)}y_+ljE*P|J~HjH17V65D~NbQ|$Uq(y_^qKn&#;E#}jT=bR+*eX1MsHGN zg3%!?`#Xf@(o*o#!kS|>9KrE@lj_OV;jbWx4K)q z5XW1ngQxTVN)>u-_p%W>P4|*Ox8?2{kUDRS;clO`b`uFY&m57vf|1jD0%rT0|2Fr( zbqD3u!=(ut@J~t)hO0!cWz@gT?>MMtzRnYt-lXeMWtb-D%Vp=&*)$81*^& zc%#0gR4&mv6FR4)w;2me5CLt*w%wFtc3N!(IxzN5=YHRzEB6P5$ee7SB0@gsN>$w6xkdE-A1V6J=O@FSR=HYQr;XbKaHIJ!(_Fk z-S?gzWr_(lsjA=z5ag7X%$nAth`d}L$pAgIUgZEkCg4e?qBKHf0$MXvrl2!KWqhS6 zS|I?7tHKzS3G|zzHCp9TUpGi)T1xYu^JI<5+Bh}bM47QM%!dHl4V!z zZIun)i*B?PS!1OPu{{=a!&r@E?gGTB4c&bE)3uiY0%6wGSJuv3T&V~;ON%4d@9-0- z^tt>vBHi{@Xam7oQCnPrQjfvHRRT3jzw0mX7iyxly8@woE7EIwagEXG0^~?^+h17= zjBx|HTQgyHI!9n2K31WC#r10W`SHsWSX@s+2Zn1-r)6;k_lLFMFYFj2y8e;+k?6DrCKtZU9)|Lr`_N~ZRTP8@*?MdPWMYk;z_)`n) zVao(c-is89#!mdh)%N3h^WTq<`g||9&k>wwJ`EwTW(q=*Idf(mND;yqd!|B0Y0y+C zXf2uw37tt(A)vHrY7}6xQy4WB3K$mHj=!rB01*rUI!SBA-Bl>HL+@(HAO=R?$^OwA zGBiRx_O6Buoa;xaHDuf+RNcBYWZ?V?>Wu#xU-5eEUxPh{|BY&LrPW$tuZ;hzQ0TB* zt5l%o)NQIzKZbPPPJ%3$p%qEb&f0cOaN zsAc&`nK8E0-j{k3q491SN6*YXla4QDG*0X@SgqgPzggFB1y>pumHB=Ipq_?+%lz_Y zwcTCdOUs9RZhL|rS>3=a%~O5@x2MJ_6?7pR`AvqPJ)|2B=mM9aR{D^kIk=|rJFk5> z5BA+kI~1Z{m1e1KiZPd3WR00!F*A_jZE*xYmMuL@8PTyDb%T;_U)><0+*&uNsCL&48oCX3iwLZp?LBsb$bhDqF>iez){Oin zIU^Jp<$+veLi<8_R<$@_+gX#>Q`<*k+^!Y$V*A;187;HQm(i#&>{jtv`@tvMD!kpCLs_< z=VYjD1SnCxpJ@4ViDzYk9P!3L!k6c5{nE`D?%E`xcFQ1r9?SEbHg^(Lb~7QgjNea4 z#85=l=0ar9y}zhY>e^z6gt~VbY3m5Kxq73KQtPnK#R`qvZlrPuwbJf5Qesb0sm^_e z*f@P#50Omw?t^KO5gU-h1LHwSsU_QlI)JQXoCQ9isxnphuV$#q9AJW zpqaG0^sq@HvuK@op-lcW9zRLEn-On|X5z^yIX~vAuGxi78WUt1P^?aL&v{JFpTpZL zkT{-FOJCm{&yJUqlll4a(em){d>LiTM}`Us(HMkxxyY7#2{@1(S0yGIfH~e@c*K$w zDn#ftp?y;cwsNz_4^b`WMmFW>=z47D5aWRxWLV2RWu<7LQ;^p_VfOO&ajWekd<-Z< zBYDy?1%K?J>5m6^TIX(gznk6SL{N=23&kE4zK%A-ov>> z2Zq*c5mxe+ebTXJcg6q-0yRvFE_phQh2FTG=~TP?lhk&d&&Kw-U8v(R2BVuP7034k z(onyl2Xq6zRbNG%#(3qPDroz9qldv|qo?UaJi zRO6}T-aa!^&AC>WSi;-lT{PU2bLH7u+o1Z$OT`d&wDHn6N{15WsVMbl{FCUAMsfKAlG|S3Qxd!N=GS@jtgg%S znbeA3n4UeeOC@}^DIpUq|9!tk3D32&%f*DAwqO*unFv-EyNrtm< z_h}totJx&D%$)V6F!N1RQ>Uvf`G1Tx$+E=2v?dHJ&k>9>>nqQ6OKSHQTqqXg73$(rWPn;T#(YU-Z}}qq0&D^yGA6K$lsJ#2%;wI~wq4Ce;Lr z$k)OfDV^+`F>@5kkf4J(|xSc04azj;*P8xiD`%^toNi}uA1vxis{0zr2>}Pmu+z*u6cX1wI&jFRd8!ar%eGe;6WCu~5%#bt= zV+8`^_-7r{W}9@Vx~c6r)k(Xod5*Sgave6Fom{TId{wnOUfa?GL&FDPvE@BTy_V#w z^RO^Lu2*;5!=li zt-amMF%;X)9HqJ4%n`8mui&Dapcl>xco=#FZ=xUolkI~N5BSu!I2<3l#RToMMgl=)lNRunpG5WqCoa-<8e0W0DPM0AXC zFaU*rX<4EbNAQl>zjS=ay@ZH8)jP1v5XbZDt=jX>sy+9tp7&Ml`G~3!j;k8}U|D*- z1?_>u+L+L8fX5~@mQ_iR2~9MN(r+Rd6PhsCbr!#%s`Mtbqu4Z|17 ze=X;`)mm~wNlk+$;9mGxorJ&E3z=Z`)w$%Ub5BZ*Kq0V+JX7PYOv<`sG*Ph$KC{nj z9jPSvUHon2V?w~I?xeJfEDpDSJ$`$+-fTt>x4rP8>r;H~a7(cI>Rj@Cg5j3PV~1N( z)+M7EZVCQ~;g;Zc@wdY*A>fBwQrblpy%87p50AT#o7w&LX1%%V)V8=e+m8Trenvn$ z;!?D}dNW-28*{X4NhPv_E-ma5)9h?g0wac9N}xxAiH!+ODfoex7PEw%5lLqsSEoqcSqBO-p@-1@tYaGQtb=7*w2;p49UT%fXzd@f8ulH;aLC%dWPz*O zQ6|>EuxqPtD-#O3y;~t`$01F^P7t`d%}fZ4lvlswEUKzLx+ySqyU((E@)pz{E4cCP z=eR4V&nP_2dA(UK?a?RazYLlH)(kc5Hi9h{1{V~3kOl=i;ti1#(mL($>p;54@v(~D z{j9S!y2rsXy2nKeW870zL9c-vYMqVkP6zC}(-qXQ@tGs^KfHe2J#L!EbEsW9prPF( zXgVmu-{_)?7l8m%mz9!z2VlDpgn~M@N$DM+nGS(dc>G?t5KZIM$=e4OBKom=M?nEY zJ+B^?OUdKzMkL>n#Ny`Yk@fz18h*cK0w{-@rhuszG#AB=C1tcr?}DF2RdkCyNGo04sfb zXZUf%!C{Wp^y?Lj+8(_ErRB>j5C-&PP4B}nu9)Ge_|o}ySM(13~m zO>et2B;49iObXIxqwxIHH2nHB0pVzCmU9|8{|8D=8`ssC1W}1nB6Bk|!W%u|d)mQf z)r{FX;~^?ztKe)nj9j3#n`~mYM#VNUmQ_iR8;WQce@GL-xR?l|w5GuF#V?8F>nOII z9}#BP;dx*PXj+Fy#7ybxu+0KF7rPNN02uJC@ zi0dJHF07A|#;}`mZj{Pc$Donltna_9c8`nI{Y;9Xa&vP)^S*>H4ea40hU&MpW&Ebe zEu*$=ZyC2`gv*#{4b#R+icYAY;sTDF!4asqdK*;js%OAi#aaU zPCUDxFGq|&dhBEmbQlDIyLQ}pjPA;&?DigS6u9rDar<}I9KF(+Q2s!!U!{56Ue?Ep z)pq^;-sAhR470Gmj%c~L$ z2e6D^&c353zQNX9{ZN8J%Q&iTaYm&O>v8+NF5ZCp+EFqlnF?=0irXQUIvb9_5{He7 z=%E?Pj;gcaRk)~+etUTA>1X5d&2fy!H!F=AF-_-%r;cVwKq9OVqVM}5jPDeW4jm0* zJPA@Dd(3FS$~KPp;c}>0{9N!)Ej?4<+z==j8+C?H8MD{4THQ3fn-vhvEOH+Xw2aLb1rSRG+=}ziGqFY- zwX|6T^|;ifLuZ%vz+=k~`Ys)`EsL=yNO;dK9bA{H8QU%$#&oHgiR)5qY1^f0T=H4N zBkzx?0gIE&*jXC&=VxrNX6m9uWYf-t>#y3;VZG6&M%EimKhy-Q z8`@BiXKz+n?^!Snqvq!P&#nthpBF^Z#hJDmZjp;tT}(gAt%JTNpoL4cNY;#vi4^5l zUbO#vDA~x-l2qBid=-5A@?3fU4cizRYgR^VJQBdQ{&ZTgaT%*curwKKmqD%>okFcz zJ{g9KAYy3@Gq@upY+1-c#Ts500juI}k!r(Q&=VKNTn>7t+WE08P+M)UmiOB=ygUPs z4Jd7GT;xY!;hIq4#lI489HG!Ae$Q72bo6oy-6(=Ax3rE_>*WC*75DbQ9)jrd!~2c< zsLGDc0k3O?zAW(B$loM0} zZd;Qjgy%`h%QNjwcqD7w@*ic2#>C~ZDrT>uo__u2iK9r_8h({$i04|;#sot{x@BFL z+Fe0Qn(QXnwz#;Ra|K?QCRk_XO{Ib>pCaO622x ziU$Eki8jzb1k@E0jGYfa#3R{)l>v6P=jA zo0uCgO?6Bhuz3#AV78cG7~{nk*m=T%+?y55n0QpMV&OuaV9>LAaY>6OJ^g5(2z!2e zyZ)XX$gync-Ny`xIJ+nMETsnXL#!~|BDlZ@C+Eutctq#batFCJmJ4BOaMB!NBQ&Xy zcrB=wym*5NX6^fBgBN&>;BiQvkO%s()zq#DBUzn;k=7;m!Hs z^7!-N>G43X%=*s_sU|pcUPDu0?C<5nUB~pE;C$gxDSH(AsU;37o?luQFHfM}Lb2}=~ zFua=GEO$T4qf<^j(?&c-$Qo&K7Ja-vKR!MlV1y0J#q8$Dj{Ipd}q{A85>7!LxYN`x!jpoQA)!4TvhKz@l!; zOB?)={htrJJk*C{iaaeSsUY)ri#}MY)EaG7hoZ!wsmtx^I%pt*LS1$}UmPFL4^D4R z&L>Cbr{`zUv!8HhHa1}E&wlPhJvVm~C(J&CCFk5eG+9^OJ_PZt>*-&R`2q*RlT}^m zOEa6i?fmQVZnk~)Odc1R6XC<<#oLRI7oVp8>HTLOLP4$cwe8h{x#vxqe0FkVtvpdr z4CjK&Zj&3bt$7UH?D(e#mAQ62k$V9hVy{-)8SW`yTd;-ayB~gD+`L=kJKo#fuXFtO zANI{mZ9nWG4c=G;Ki={4&1UxV0$v6N`RMQeFC=+&PZ8lO2vYpLh#-5q1vYS zV~@6&f4e%qHm1TpWKL&W>dXBpMcQv4fk5F=qK-Y9<_So6eFjQ$4@nNas@Q|b@y!PI z>86ABAanG2HvfD7ZjM`KpMDNavk#THZT6w_RE@K}UCo!%yM0ISaZG2QdJP9#bW?2c zCFSYmAD}XD-PniX84T$sBzJxT`BGl5Ht-n5B`Ea0r9*OWW=}*7l;ew^J9kHIpH@RP z`*r602m4S8?)*J;f%oL^Dan(JC=kZbp{4x84qo9NV^>tX)+XS}nnNbwN@YaZ7bPuX z83yE{Br%bkcDLhSN*hcH09RW<2b_hBod=*JFF?c z8NlpI&z?=+{rUDkqesrJ9jPZEo3W}NZ;svXPz4(2f8*L$b^5uN*lYs{$Dw;M`nR-C zP_Iur6}`rNTC%N^)F)`*nqIY$p;ke<1J$6;YPgh9k(`j1KQ8XS;RBM!I;|qXw$`{3 z0}?s6vckshn0(m=<--hKyzcQG)7cNnouh8?aSE1dLmWz}@cV3Yzudwrx@DlVbk2~X zWE=a#gXHry_}pfP%f+xfn;)DFpKr+VnSiLIT!K0I8NvnMth4vSI4=lgT=+dfG3QWm zQG+e@)$?08Uc85l72tFI@vz*imXJH3Ib7)6fk&mjVm~#+8N#@Q)1=$={BMo_mr{7r zpb1FPxb=lC=6E1QN3EO32k3(Aojb7$QWUxem=rbGPVlTH8rYMb`GRLH0&dg-G?yZ} z4T1k`p|iGYZv&x^Gz z5EP_8su~!Fky0302`@rl6((*7A%4^ly@P4u22)OFkLpC?^i_(CpUdTZiIWt&WsEAr z0hZICB{D1Q6b;ooJ+pJSGTLd3Y!o_#Z}r4PNVuGIr*t@=KdyI>2XSn(;ebvl&?=A= zbqa;a%nASF4>ae;G#KVo%}4~XJlU~wUG6VeAQ9y9Wu0=NbIMkBOk3g6dxRe3`S=6K zjg{pRk$bhu;AJuBK^FSmDGNr1QN><=UyKn3x70Cykj4<~6bDUpv~)30t-E2+a`(s- zo#uXZN`Yn;ppx1iB?+2Y2>~aKCpk`{n?);Zsb*$@M1cUAS#e3HL^z>dz^O6bLwpd`YK76pBB)hxa9ymrEQFBUCd*=4UiWE*M=g zVL>#vx2G*5pjc0Wc@i%10>oGDJz$F}<)8G>Fe>qyz5m_9Hu)w!ICEbQpN31M^rvJV z3z-~K)X~ZN&BNE({l&ZXPTJkQGiS`>(CeuXD~^Qf^?Ir;_0qFvNzJp9l&g=If4=+} zpKJZ$O^OtOv%S#Vs(G%3U#GZ7bdwqrElQO8WQ9W!YSrley~inwE%*lEX1 zM(O<~ldNM<$aKcEC`8ACunqdUoc|5?+H@zAbkt;y6LM5C1ldoGHaFrttc)a&ch+h6 zSg|SGm@(q8sI-f?;yyLRp;Jn{ssmn(+m~yN7 z95q8rFGi0k)y(*r_KC_^B1x@vlua4?|x(nb#lnjxEPq0o}h~6@EX}2IZ~vHSz0D2mHX5Z&uC;0 zlhMd7U^QzZubVkCEdlI&M%9N0q_^o%fc#qp@LGP9pr;+Wmh zE$WCz`8GZ?-0}Pl98?A33=evl4-G*m?K-}9{2q3!sVP)4r<@lFFsFq4^UJX|lEXp* zn*vdxmI@q=ekzdKimE`t!>(7C%k&|#c*d6)IP4IEMh*TY^i7Egy#CeAi!g{6{?)_l zQ#UWdAYS-a53lFlya>b0ybfOIO8tamR~+RB{?xL=$?@sUEI&uAOm#f?B@Eltv-AM7f{Ct0 z>ZL#Qb;EOcixax`4{hy`BXv$EM~f5sQOyyL`(MxVTq%`Cp$9<#ft&?^*;6&MwDdKm z#rdq|GvJ{rwa3TVqn_1($EhAIG$asFbHCR$3|F-`oqq&8;_ZKGnd3C1Uei|@ zr=dZizNA03?C2Ft!hmp-`QMQKUOoE0wC4v-g)rY%+5He*g3wk1#R9E)) ziUnxVqSsd(G5dCwA>G29n1{2h9Ob1ecr@3^3vF)1(jH0SF4|rIt zink)bhqj3Q7O{5nbId*j6lR9;P)7r}vUT>h|Htond_oY$v%*K(k**Hd&V2-~&V2xA z&0s(G4QD(kuyV98Cw}fDs($V(go+y8h!q-MflVPrk9TioU*6`4ahR5;7$OIK)2cM; zgtv>g>-%-_f)_u8psOPIJ5=-GcZ1smxxI$<)NoVSx^6s?BZS2y3AisUSxlhT?aQC@ zTRDAK*}n9&0PLJ|JX-L|@|F}hPXG&_ZR=?cTrEp9x2sR7wM4)i=x}=IdZo+1VB^fj z;Zhw~zKKiiuKj8T=kKx+Y@BFWR*k##^$d;}Ws(*eDS0G_LpDjH1?*DKI6qldZ?rcW z&P|(gR^TLAb8e1N!pE1^6YZK!v;hMab))fLdn}rjIjx5H!;$lF(^;cJ)uES;W@wBc zW&)cK)b;Xgc6M@ddcOSpd3JgNJN%G_e{2@8F3P!^%GiuHM}2g!x{GL(|K>^PwK9Ko z35QPXX4bDRiarm_#rwdeakGjmnhzIaMxe?3X_hx{}(gA6^* z@$gTyW|9`7(zq@qM3(0(qT8Idxfu1_Ad)Pg-d=U5`>J%rNGV`f)|KY#-y(q~y;p^C zBe9Cu1NyXHB8je)ULuu9osF%FE)SO|!Jg<|LBWbWav%mBFp@x=o@yiseP$}LA>)=9 z+n1p!#!`seVl0iPXpA_u*2q5TNzWzr%Ba*_BDMasTq3Fdlw2aIv)*)EBBicWTs12C zG+ZK;;D8!Ae!MGc>^uMow5hkmT7VF$v|E)$u4Wk>quVDkVeD%^QAx|FfsMiXAt51e z)Ot;=IQv#6lCd8B%>w_pN!Pw$O!_UUr^4pQQSC^*r6g+o(rkV#egI@Pdtb^eJ;{ts zSGp}d7kw%zWqXQ#bd!*2&vs@TCGxjF36m#plb|-AZi;zL`g9~YkN*=kXiaCH8lQBe zkihp-ltp?ok56>lKsx6FKR!g@5;6K62f~F?nHoi_1watRt8}6#W15(>2(?t)iDdp9 zFQ6dttWTMi(?tXas;Y?K7+iH;mrcjYJ*_}md+yba2o5v_IU>bS95w325N9vjEz-PX zfw>vSOKQ=xVQ(W4LqnvqrZHI0R@*m_&f?Dt!TFyt!w0Op;K4!4!@E$t6Z6@5b8Df% z8EEduw9S)2Nda~l7#~uX0a4y97*Lx}tL68Xv%ADMUBIF`ieODVL@0<9NREn;*3WO3 zo88Cdk6n5htpJ4v)`EgS5vX(4ArG${gMU9~MEWp7j}IMkSfc?W;8FvE*AE$|X9_tT zJG3K0@ex7}owQndQ>*}uTde^aw;Eh1GisTH?{2jTYy;#L&RUJTCN`?o>h;4IpXc9a z@Gcymelc%43iZq2O=MGA7*#aaA<&|QPJq?ga`LUpfQdvW2XxL}YBH`^rea=}FN74P0ivRgVt~Ic*x3d$`JS9Ers)#S@zl*1#nTstvcu#-}(Chhw;ugZVA*=a41sV(}wcX|nlrf~S^h zV3_U)r|^8wJ;XPgE#9n zp!T?0ez}83Lf^rS+jzBQ8-fxkMF`%;3+ML|Jh`QE1icn zjiRU_u6H?B%Gi)nsf?+u6s!J3*nBHQX+OM~S&i`?(-WlMA-w z>)Y9vEJA`42%FD@y2bPvQdW3wZH zl!=~_M5!ylpJakJtdtD8VyooRvIfg=Zry9i5cE#BxKtj+ zaDNyL9tzn{6+$)#aetw^Qvbtrkf1S_c76v&jup>ERS0#Ke z|G@KcZ{LlslMf`S$9zUE53?rn7DoJ(Yk}fF?$Hn-W{F?>afpQ$cN^3rvz+1CS@baq zfQPl!H)TR08kE_>Pp;#Lno0K%3S>;<5)F{dr5G2iPRD%_WGb>Zn*&4`+-^_;30r+; z{fnZsp$VM#uKv21j!Y|_K|zJHy5m#ZVu0~uGApfz8z^Zu4$>8s6OH+&s$pd7k07~! z1;sr=&v=w}4m~uu{lw@Nu|1pV0(+zrrXj3_!8vLarl=3jSKBLifO9@eeFGVb1K4M1 zz|gc%Py;3Bz|zGKLZaZJ3#Ow+-QdF5GyP~$#VQSSUC=Qwnz4y9A;*D3DqRMVP83A+ z`mo8%-W+tyTyHh;a9gYV35eW3X7LKN z?BeAMWK6qwc}RZoa;Ko??xzQq$+{WjLBkC4MKboO*{#FXz13&9umbjFVvJ^eb7r^f zT5#+j@C6j$ey@6-ea6}2_JFmc|DlE`?Otm*;x@L1Bpg4~P?VX%>Lj39xg1hS&sAHf zlEy2xva`fk-p-4*taU+QPO*Y!R}gN}n}k)GH2+wl$#F)NhM9>h5m|X=je#0d+YWY$ zvJ8`5cvWgu&aFBH=nt5SW>*}YN6xf0q2nf?KzEJx!;SKuc(mkVvYK;rFS&zpbS-%r zUq)85MU6N8fljOKYHqUob+E^Skv*`XyK-!|bkVjf8)%89;mWUsu z>{oqtlcD-z^(9(L^vfBZ>IOMRQ%QzPN~M3mCiwdHsL3#X(9&_T)Ivsw3SZTdn-gb& z$_Sk*P*Tfd&mRRc%494m{m&}kFjD*+C@bL>U!aGEB{)Oax+evw z3`apb-Wgnd{UzSxS893WV}RMi2UdZdh13jhgS1VlbC0EQS8j+{w+x;#+o3jTc06hc`4; z=Ax#Hq+FlJ?w1TF>Y0oIIY=^S82`AGW~Cwx>k-Mo8Kdi(^$B~2NJaqp8E3FR4|j*N zT$>&s3dXrJv-==nDHOT!VJULRJl%3I&pU%TKO$(6Q4Cxr7M2TfQVTi_B zBFU+|lB9KJAx&p)C^0FsH5V!&HZ;XccVa+uI}EAG?RQPHo4^%E(6oIIx`|1PU9C6nhC5c?~LlZ?>8$$|ny$~CH0W@l`jHJ0XAFn28>S-|Tb?|^%woxgbH||mn zf?bzaPG!@vNDX_g#HrYFLG&rEn|eDgL#$dzr9>_JEu$`oRoZSDUZ+$|o2{%!%U&xn zDz+LYJ!_{8E?Gkuux{Q38uC0jTy1}QfQYeqGbRZSPPL%092KC!K#M-95lTla+zC&w;paRdJM6!SG8ydo6R~kCry3at z*C$9AwVKavJ0}`FE|;Uygv$wPx@dwb(`pANh+5Uq(I=E4j?5UbozWO$uY zwf7Sl{r3CjWd~OF6B%`qp5IT{z_thh#=AMAkILi`f3Si_h1##0V{DKL4)j_I=Qa{& zu2|#YEr5lMLjfmk7z#jsqfmeic)UqDf~EJC7!+s&9wp7r5G9K~nSR4$LXd{(`txjd zHa}h*9~|GDPEKLp5E3?wefOrDdfwVbk=a|H`-m;2b=Zfd%k=PMLaN@u>26cyy=Zfh za6A9Hyqj&GJ(I^prU`ZL;fSM*G|bbrAY2$s3S4Wsxfd2k-D@~iNuGd&*K}Y4?=egcy%O1jNc^D8 z9%S@y%2XRSZkc`hIW)~aRN}VTht5+qj{eb|dLzel_NmvX$9Jlt^*_K%zj3sWZGj}($9ak^0%3Fy z^pq!4ySB`NB6DGM8b;X~g7kAKx|*1>#uSA~ueeO%nD8%ru_tB4BxL-hAI-}T_s9cee%navzQ+NbOng9az&)X%}J3JcliH|b*4&o7z&&KlE zH1WA^Z4V$&d#>BsbKTk=KrnpR_BdPX=w8IYsz2Nuzzx`eRfhXf!DmiMo~Su!A5b-0 zQd)F-kUqfAH&_!X{gzb1Bk_;L0paT04nJe#nlV2@j;S57utViG5MI3s8kNk4h4Tw6 zdTC#XA0zcGE0&QUXE1ZyvVRtPjF{qFTj_LZF0G((b7i$jDNR3O+RLL93#Q7cNLq~S~5kp zSkQUCd0uSsKIvVpopg0`3e5yf0Yx_^@Pau-xW!=B!z~6$5pFS9)o_c!q0;~ttJ&RB z8ogb|qJhmgv^%bkSTw#y(VH-jgVvc9Dwc8Rknrnov&9k{#=AR~8J!Xy5Xm6@pXz2( zU{5lCe0V@bvHq490AsBX)r>@JzoDfU0;2{P7OVMo2L+5RGT1A`9i|+?-;nj6z$7 zG=gXvpzKR8*tXx7l&fN5VzfY4&fO|wGzK$OK~am2ogzl#Sh4Tg1ml3gp%|?gRY$ht z1ca?xI23FbW;A~mLTZ)*t|aiWL22Sb&hdlR7fq-h6k*%SPa^*L5coOE zR0Nvxa4({=p>`u3dfu36=^eUMYhbPb6JwS@zQVow0aQ7+ag1?Q2yORx!%xLo9?U;34XkJL3&&)7j8S1 zjFmU_l+wB5sBzKiOQ8cgJ)fZv)AVbRGv4t4%Uf$hsTYj3 ziAVGYSmNdXtTX91kFyozfGS2uOgyY%;{Gf#nP8y%@ms&yz#XaX28zXMmM8F|M$t1p zEE=)qekn=O;ZBW5g3jF31n6)>FU5#?8#2gtgcGkW^0{Y0o%by+Qb~{eBxWjK(xrU; zMNsb~c(To_cM>s))@@aXUx>rc!wP^9{7++>UtgA!-!>6N+^IL8BOSQ2Xvq_IBxZRL zPIt!|I9Fm#{1WS>{a-gD+xucImK=G((Jx6#zuF!|G)7xoXA^MT=WgSpToRpz0St{= z@pFxYegRFb;H@qBs$DY|DC$>ZWCt%M#EpY^!Pr ztTP^}uB6v3OU%-i=#?DS(g+w=B7Z2jLuJ;I-lMSKM0QWTb@pFH0aCkpEJnE*$ z56839Gr9yk04VyNuoUJR!=U80B=k733c^wthfyr?!C?Nis&tv4Xww@1Rg@cFP5T5u z*Rwyf&?c4__Z1u@(YAjS$)o!LGOnf|jnHBaSph<6L5zk#C0Ot9!gckP1QRp~9*@En z_NQVKQIL22!|sRWV)chqXb@Rs2u)0b4@Fj(gSp1$>Ud#xBmyU9;g=#eG>zY8f1+(F zOv6EvY1luCKjlgtlAV+r)VxQylH4iqQr2DYfD!P ziDTg1;&HL-=h}qn6qkZ!eACHR3oMJ0fYjkPyY>AaulqYihkH=V)*$LQyuGi@4ro%u z0YL{2@K=!oI?s#klT8{_#tN;=LTKU>d?>O)f8!kOeEYP{m-6v!ga#DD6T9eBks;34 z-q~t6;x2lEKrG{LC7yJPAsOA<+4FLD+dn?7H?vKAg<|IJ==MSm%l0Ew=Eme2M7VO< zkFtd(A`DoG2>yqn2slr=p+^!!Jc{80Ntgf;&p<=i0!+FfRZmPQ%|t zKIoI*KKIKXXV1wS@tILmP456p-RJ)-GQq~c-G5~AwdtDKny?+HQJDR!$N{}8M(M>GSZ{Y28HdoMvfx9J6@{k#mwtuTR&Nl6rXe^r>N@yR zQw74kW}0)h8smKo9tgU7R`&X5cQ zNiK#ov6{V>&Ze%&IHD?IySS9e(5sDZ4GImQ;^8Wmd8W~$(s2b>^T^mLz$W zrUP7-tn?(1AJ_z3zUDE2!bqLd^~Qa_6Ga+FcE+nGKim^VtyPU!>)vQG(ulE0Wk z%0-ouML8sw72?FRn28nJ*EgMQfB~9}kNZ$ET)b`Zd<{4Iuj7%Iu)tS%l#u9n6Pm8r zv^yAnah|cX)yu&PyS*H!wBgIa@_W7E!Kwti&s4uhD4g|o(+Dse4APmnkfngG7#jknW~d0L^^qeWq9=#Y^uCWhkD{Hp zMP@PWtdCTL9xZUc?zhiL{f3ge#k7GHQfcEpL0d6r((Jx;V7JoP6IwFC#k54ri~&09 zmN6P3GDP3~(rroaDY8V1L>7K*6PdC&PTDB2RCF`FHRh42r`=zI6mAsLZROGUHpkTB zF&~APbcEJ=jT&`&Vk;&eo>x;+F;8yAWbzOc>ZfC=he$LPnGZ(`igp2N>H3BmdifAr z5xX43S}neM6=|p`s^v+P!px$)ioloWC3P#0QhBkYj4 zAJ+CsxyT}hU^^WTB}y1h|MWb!a)_SEb4FWD;n}d_;HO{SSgH=WbcQQzX2;-a0tyCA z6-_XBico^VqN9N{|9x6)7wO^jS`#Td7h#jD55EWwnNyhAH?Y&O*snY$&f*T!OxyOa z7XFwjdI!aH+tIp+ut^u;mlj#f=Iv}gN)$|(z3T^LBgycgRS*#38D3*q!rLls{X&_$ z068mj2q=F(JD8uG_NRx(-ErTY%nzx|ApmHR8oToK^BgUDgxHt_jIdL=&%$3nKOD`D z`pNPA+0kJ?ou2h1cnHxVIZai#m5!D(s`oL%r=6LQ0+~SiwM8ym=;9VrNK_2AIZuPT z2Ppw-m=V=hp?ss>^iQ)^14W@y0s)a(kT-GIkPyKKV*2oXz(F30*gYa*9uiUq?kR3V)E=QKL-rvC5<*}8_6Z*q4*2T8HxjcY zQXhB;vX;a20ezgPO#yn;$d>3lLR5z4Ny|#nw0-MzFliV^CIdcvs*R)xMC7o6{5;#O zH*wib7(jY&fO}*KI2Vtfc^HSOjmC3KMJ%2pX(I6)s~(5vI5u}J##Rgl_+-da!=-pb zDPpMX9K$E78@Tul|3*HPH*Vx(a7^rul}GA^b?7o&rkcIRuB@2)opxn>R4irO8XIhI zhJ;;PgYhVib-HGkQ;NlMOP~g4_(_O6ou&|<`@@5W>Ff+b^Rt7~$>}6K7g|>lEeab| zWN`F0PWP;xKX1OxcF%D5szD{V7e632aP(U+AD?$m&zMICI)maGdc+9qbiSp^y@)YNTDsHN-*^S zRfwnzr+lM?2&EEDd30@r5{lRoN_j?toaIQ$V~-KDC5#H2*APU7Xvz>OZc-_NIx^vs zM}Xmye5nl>>?lBoD+v|5LVncaGC#wjg<|@(#-Hjz*UM!KcPa^uamaIBN8f6kaqhfY zK+MH$B&_r8Dw={SX3Io z8)hEA#tk1g|F~Je`R>_nv0h~lmj}5UZ=yJyn{hzO1jo+7=0dCFP4Fl`V%}CI1DU#Mg61-}oI9AOzV%%cV%->BU8-K0HB1$ldp#YLz zp$~jt=#K`dKqm<`${i1YF#2%196rdHCTl!EGIjt-kzA@3jIbOiE?cyV0M%{7Hpd~zQCgPh#b{Z9RPPXu`$VP(hWBwb!P`(Mr|q77G@?CbjAqQImOfD z;kX`W_ES7yULxa{O3uF|d{n~H+3-)daF`7&^5W|H;{5gP#T#gUux}!o0v!_1ktx}b zeb!OLS@*RO=lx>UE)gy#S^OwxEw?D-Kl^Jx{tYcb!6Sw(qxn9NX)PD7rds}l;( z!~FQPz1_@y@6qhrCu2JEP$VITT-`K63?ne{yiBGcfrvUF6Y%x%nLt1rt_kS)V%M*g zQ6r&(<&Q-LWB>Ic3y7xn2K4ZfVT3FinIxTI(G~&;wCIVSUu_69N*eRZ&#z3-18v5a zt}ijS7PQ~z)<&_jFB4+#m~`?eDrg(Ojkk@lsL*l0scqx8v9Mf|115~&R&B!xw6*_yiqMEC#E2367P^VDH>SPH;yWxZ(8qZZhp=Cr8u!`-79SZgN1UfOuG4 ztLO$)b6~Pv;dCi#hHO-we%6cgIz_F7$KIi#I5{$jlYMRwXP>;D&7uXWHR7Z+b>g5$ z1b2+{KinLeR$yt>gf(3SD&hX9oJ8ud0OZsAC_AUichb|_38pcbh?-6#7%_eFHMN17 zb+XV40xZ5R(?|OU{n9c)8s^ zj|k%EkOYHHf-!VeLg6xmj>04-$HZ98R7-E1|7W!>fYA_XY|!Y?dDuJulXEi;kqVexcFO)Xpw1EHAgHXrO?dO^15aeFqlX zh5+4R5mcS6S-oIX=4kHI#g<0+YG1WqElyLvYTD%b($d$(WLR#Bo3Gm5!(#a+cu=%~ zSM{BPR*h41^_KRyKBTe`L%|GE`nQUAXDaIra#L4QYN3IVE%z{-+yK?%n`^q)OStar z;;;Vx8Eek*?qp@iVJ^#N&}mM+$$!vk5AQ;O`?a@gsA0=)FA(Pmx|BUcOBV8n2hrku zp#OP(d^YJP(|I?W9KvBo^WI88DUdp?paUa|sKRoPYE?5S!`UXq5b2xbRSFKBgS!Cf zXPJtbF;aLYVf8t8Pk!D=(UF}t&F}L1#oE?PWrS6}XP1+=A#*R}xD~1Twybu&@-@}2 zAXz>8-YQsoe!X51%k*SJ2Ax{KR>w|kJd!F4287w#OMj4u#35A5!uh**>w7w9BP`V8 z(N0emkH7+NR>BGjIYNnMyO|3ZE48x%mRzbKAQWmd1PrklLx9In9+slJ=PaO*5Wv4$ zgs(wo!mt+*Fm(;3wdwpNL8JQy=s6Zc!9VmY*2%GNSs*h*SQhJ*n#Jp7ODhoCEcKVV zR$!<`v7k~_7)}}ZBpoNH77wz0%8svzYN8Zo12{-S)Kzg~6dz0SdWw~3QNX7oY9vw; z?hEkdC>kL&1&ErqboR(uqyF(IuhJUaX<%b>h^Vq_fBaX;#-IE(eCWKdijgV%gqqLv z0SMW1n6gicLPO~%^M{Th#;pH>=jC88V3j^0R$z+x-Vlu#2Oo6IG30?_LwJCxg*WEs z0xV)Z{H@}Qqx{FeH)~~o;wWzc2LTEEMMt@zxW_0b0xhGQ5Wd?eC+f+1UT`{ed=yhn z%KkEk-y7he!zeqH*Rw%d>gUC3ei7C>YJ3^G084UQm)Ya;*oYw4rm}9kj5q9?`p+J$ z2c|kk{&c+2wL259$A@tUVm^Zp$a3L=Ezs?&F^(LGo;tuVBrOyZCpVwn_ zRU55lh#g*dc7@RiCiyF4hrtG~w+A*1fB`%6gh35$m}2l4Mf+o9jk&cAxtttbEaYXe z1JM87D4V%w$YV44i&}B9$8F?nuYB?7U;<`{`Y(+H(V!?g8*NZ~U_%!V*jj_~7_BXh zxxI)%d0DJM`M(=wGX~|cM;MgHZRBhX%Api}_9exOhMN z9cGjlm9%wNl`yU%c#<0~lKDc0IoSrcPm8r#Ir_73iyI6`I zPjLYjy?){+Qa`0@LgkL0*7JniEq*2{)JbBV+4CgwnD^kbm(A}CIB;Yk?g&T`q1zg$ zl>8UbtHu5@c4@O9!Fu(|HB?B>bK3?YjY^(A!3&g*IaIR^0F#E_5BU6#d;11nni;K% z?P(}TjFwul%^)|qUcfKomNp&|tU*)Z7DOp|ZP<2)B_YpWT#V*eTG`wYqWfB}Rwa z#sAq7f;#ZxFNos(%uynXO27Dht^+>0>)};iXyhg2WdDLR@Fm{Z0%x)RaX))nJ-vE` zr%?YfUq8c(A&Eb~y1smWd3*Wk;(uPfvOfL){kMT6$53z6w1-TWE+uCkybjGET9IK- za;Y;=MQ8&`i%YQ5BcXG+yXwtiJ6kT-f5JUXTc{m;`up*dbIia_VNldy&K@8~{C2T{9=!(h;prgEyIBbY%;JZ? zcfH+Z&Llyrfmh3=pNCi_?J*ySWF!GcZaJWtA89OH?Z5}6BWXAyD9rlZG1mNqW8P)c z0^gx?11FT7j!5N!zAGb59FPzCLv&=D1pYAn&@umbCMpK|1r#B`moT`XUhnji+2Gyf z&F%mER~XytN&Pn)FH2&Jk-eTFD|-;&>nXK~J`5S99r%%?gy+Ke*2dJw*s0Cx215$` zbN*2`&TN3!{}b+k9ueTR6Y@q#oRbffz8uSoTQDrX^TuB$3?dD=#*jSM&S_ zujW7LMDkwE<1zVM=hYHrgkH^~>(~w^;}JuX@gH^6&;?Ms^BgK)?;u{qwSh8_#C2hY zOX;cft4%@TwGGhfRd~ zQ(XaehQx(mLUJ;RS8i^ve>qR0Edi5_tP1THgDZi)AXyMg35czNiJ?=WF;etYK;Z(Y zQVT4pWJucCjyFg@wE3Uqp#sI&7rU?hW(CKu!R++K*dwrDYA9hv`LGX8pN9_R3Rdhu zU`Ve`FD}CL+F>cZ)<&+Bc59;)WI>F-FiW#GA}&qmYlIS=gjzUAwIJxx;iOHifQuzS zf=EK$j{uE#H(vdb)Lu)l7_MnyVKzfp7h9mEhcg!Z7L1Ti;7GTFAsJK4rb9AUej!#q z??6P1lK8nsN73F_ge3j?NF_feuWys;f1#2Zd+|Hw zD33pGp1#gjmzZ0;_%HK^-vEn;dzSQV8#%Ny67j$OIZVV4^Z1x?=@W&;Jh$5%j2p(! zaY53XNAm!CDrQJy@{2P(cw7bDF#C?ner$yHJCI5aCOuG0>?8C;ljVt@x~ll2o`fdDNM{E`2aD8>o9t` zM6E2oKx%IF1-b(k;kF++c$mQ=c)B?y{8Gk8&jvSY-Sl4`;YGL_H{2f&ps5yO_`A#r z(`=Sa9Gx+(!t`1U%dVONOxFN$-E@?$7`T8>OE9&NeP~tIPFj)D)l-fa4hHF9g^ZOp zIX6k$1&)nka3mPjL6X4Z(Xh9h^`m69DL5F_0G>OGV>q7sZuP~~r3AjN zqy(X+qXe8gtUUB_3Jjy$oK@yrP6`a#1Z@erPl1s#0Gm_Lt1rB#Nc#(rsK4+oY)dc< zv+*|-Av!o~dmi(wYD9B_mN4^Wt(VEi#Exzfwq_&6w#CJ|rMlFtuWZ7!5r>OkZEDWX zl~Aul_MZf(g@kE_T1reZEvY3;Gx~yPK|Cons!=jAGL-vLiUDN|F4`-~pOHFAMvOa^ zZEf9bi#V&SV&i7=ZG6sl=(Lm-Wm(j~Fp`0?Fph86s!>d2Zjw`%A}@ zt_Iw!x7(J+(uIH?$po10PZe8qDi?n(b|19HiJRIMf!LXUt9Vf%^Cc7qZl2+-^<*Et zpjkYUAEMb@lP|J94SxK5e{|TL%#NoghezGy@c4l)fervvlH#%KE3BXs=IeBL(=`eM zd?osJ6WU7!-$i<9h*gfgi=@<{cae&Vy!Q~KnnIpp3fb?*#u>H2(28R6N#dzr7VSyC zElaGN+I=1vW`1dE^e|$sSgD{aSv=rn!vhAe8BR%>cnAt%EKF^Ie3Bj}MAfLJivRi$^8q;*Nps_Mk3`-K}FMCIctzfhaSc)r<)r7*vl5EuRLtEXy+-`QJ0j9c*g zs?MvFXE5gk`Pu~C6qf9Q29|G^G72YNk%R6#3io1hFSKQvE7Ko6&)Ehh4#F<4{UpXt zbQaYE?X9HJRA=kZ>Bz8Uy!9moe$oh)By58^WPZMKY^d7Mf!gg(_h%W?R2e#0W`*ZU zadF)#$m?f0M+RA{C%Ta6FxQWq=?cV}r#gvN`&?)B!dq?fwRN&9(r)$qQj3s9O~Ga+ zR5JwemFaO>k2AnBb-J>M!2kga3}p9ykHKVIV5Vc|<4V=OgQjfK zS_{m1sdV+13_(qnT9*SZ)Ica@2pmC*p%p+XoWJIOy&J2*>=FGr4%rRqn88X|CPew?IcZW`W zfDN|}GrG95eBD3A7xCp#z+3?ZYzfMxif;SAc22K&HV%Ib21&+-wl9f-Ndnd2&8{UO zqRd9Ye)n4jW!3Z6*z!5upb)}(^HiR`_PA0JIge|T7as;~u z%zuz6nU!FU!Nfqrn((vK9zQm6f`g%m^{o-rd{L+>M=jA%R`I=fq@lhz+iecU~WcDBS88!FzAdE zZ3G$`CI+lx*!@3)Qx5~{^z6=oA?Su>6%7OFo2nx59smUt=#ii#HR6vYEm9y&6pRvU z@FtKZgt`W6#9Sav3 zLTDGw1zd^*Ou<$}p|1N7yhz=aZiVnZbrF6n62Ud++fDzU=YEx3g`al_t~m!-sxR_? zmY87u&Aa|v@{B@8A1{tIU__e!St46nFQ?uuSucmr3}kXpA=Eh>Am}&Pyn}cpo>9i- zSO{&(yax1Q6Yv?70l8~p)mcM--yL<7NDd)NvQ4Jo89qLl3kTnB7I5>~^6wAn4JMh4^y2au zG-w)&CV31FxY(XUOnq}$)`M_A6$u{E9b_CDzbuT>A{<(g+p*bN;PAYM;eIR;rAHw? z^{eN;-mx^Y)v(Z;1FY1A9-=5CZDx2-+gbkaBC5R{-#4)C=yi16)%TvTn{HL;6S~`H zdwMYGy2tzLe*3gu!JA9vu|L6L*~=Wsp2kXv71e_C%hhZPd>6@ytZX=wj~-x&oBy-O z1k(VnocBCFL6dXA3giHoeCY6Zkq^312YNHFazYmxfk(WM0CF3#tQnPebQ71Hcykc^ zvW_pgROB7YWZUwNj#iS`kPA;7f+FweK>6lt@{W!|u;!1u_vW*=N8}>p9dj~)RVK@Q z$~)!=)^+7S$dpXpF~{I17@tRV2uXW<-qHO&=wvW@Iq&GO;=XVjwYt1xfrd8kD3MU+ z9UVGvt;tta-my$knVoY)QsuVf9UYCN5q2OZUrp1>dB-xrJzJ*FJ328^-Kg`95&>o2 z(V-_Aw0bpaDCQjpsPqWSZ&)KG@K7)`S?kk7;E}j>=zt7jt$-1Y3GRRh=OiPLi(3ob?(_25y=(yuA zaL#hGo52DOk}{(;PY-ZO6lt+1{5VQ{jL@)OUr2UbG_vIUQzj{+F;aJU!vSdFT|axe z>A{HNJsY*W(6P|jB(k<<;06VdrfmSU*Ll-(%taZt0I!W{zj@SfoCX32R?zlhY< zPTy=64^U+e4GEHhwoCnH*(z}X*2BH-k~2`4TO%qYLiRx`rAu_6Lx6fX0~H13=8(ybpeey zOY1mc0pf9b+JoC>+mB6}PI-9_mGZ^?#80amwbVi_k4Q;H{pV< zr(&s4A>g-5^%|Zh0+aa-5}{Qx{!2G=v&1OBKo3B|Nj2uNq%g-G4`P8FMjH4upC@Ox zJ6(~`^dS2A^I8AUJxm`S4(9#c(Zj=?sS*k)?9)1|Gs7g!$Ad#zU+bRPvFVo5{3C%O_@I4o)0wprV*cxv9u~PscgIaS4fS zhOA3aT)X2?*^!JdJX1zoofwS6gG};}z9D* z9*v<3siBK*R-4P!o4dW_r)#PMTCNK$?R})gK;uP3#Gt|vB9-nh9Gw<;|GeBSo@TqR z@Iu<+ezsf3rv+O5HO(~)%`{VRl*4?!KRE19?v5wZZhm+_o1Id+Acw>5IJ(C}-0_VU zT2c8dVztQrka-EOkh~7kmSPG1o)WV+gA6zPd>=iv74Yj6#BUb(8h-e>o-Ggb?Ge9| z;g?@A?&kpCSK*sD^%IQ24CxJa>^B9|>mLdokZE;Ls@pO=<+co8kj2NF@5+JOZe*^w*k>pv z15|Z(VIO|F`v0-L-g59^pH{G13wA(XxRbuG(!`C_ml`P2HtS2#=Qd%#OApj{v%EjH zXZk~L2Z8K-v0eYU3O`Cd*%QiV7q~Y#-qZ0@$Z((|8bF>_K1qmcVUMGl1yYI7+xu9~ z`}Vr}oZl`zBo#F+Rs^AcgsTuoGUxnlEj~$HLE*|z(cz3NgxI5$Ll8RfV6|qCmRa;R z8tafei3XSR5~@~m#QpH#$9Ziap3$qM^qA%v+`)D``%*~rIA)WBukQfR+rOU*-PIM4VW~jK^6qW{850iW zGK2y$CK*imfnb~kvFW^yHPd1lgv_7r1QsSp0QHl>>5!q z)foZZ5whX+QuuCrA#)`w3hiq=GBk&fT^a@d@Zo{|aYT#gjw&Mj`v`1vV-=z2<)YKi zhx7|X3{+N%e~jSaF0vw8F3=iD3s(`i2l`w(nkM%kW`Qkwk{g>$&G*m!efRKia&~rn zH$9pjAH(Zu!k~0+cY;a6%qi2`h0Gucdptv`vg+)0@7Z+0ey@_7P`74cFu4SXB6F?! z#6d;@Ih$-@Il|;<&TcNQe{KjA1sW}}CPzXWaAs{60=S_tnXe|!=;*^ZPJD5>&Baw2 zZ=ns9AT%ShUlZEGQBDa>F)2qt8<_GfFGZ)5sabGln0_gm{Spl4^ilxuK*16wxJdxs zpNK-g(EYF&GLs|pF)R*Q)MKk@Eh>mo9QX~AG!5yCiMS{7nk62P<)Re1s2wQ8BuA0mjUuCxeScCs3U`+ zt1Z`GZes=JVBiGb5!fSMI6(gl`Xz(!V5J|V`{0R!^#)H64dGsfLaY2{9OyCuC+oZJ zB!djQQ@R7h3tGUh^>6{T+UW({iX9X%Db!y-Z<6qH!Ef_BC{(Cms225iG+Og-&IAjJqI%^YpSJ(%`#*U5Eg}P3 zhrDa#OtlO@F4rr#e2~h)K0H6(r8gfsS5pvz>K7O~Ur{Id_f{#fA_RkORfG$G)s<=IpEePIv$g}`PSU?l$W$fCqm}t_7^UW@!aXCD z28%~GpHi65{b|>qPR?cr^W*!|X@5rbk}1@PmZ5VB$mr+VpciQRkBCqN6@D2Z83y7% zuGjOB%orOXoo9qhjF*samy*s^LL3VZmBWp27n{v`(-x8kYNX?o94!;)u;00uHf{k+Q?Fk&vMtjlZ?aH^r6ZFRKR{3H>}s zEud1rY{n^dip$J0Ra(^*L0+;kZ#T319VmZ{?&ZdKs`!TBqw;l zazq=jZYvnKwm5*z0yCMRz(12y6)2VSyoRS+Oq8m)_&$&En^r#%);x#hA1Z zfkK}kNp-pXG+Qn-_MVag^WjO+=`!}Gs?j7o=y2Kd-46>&Y+Y`DUP0Zk!q`(XM%09i z6EptYDk5$>-ax1UnZ#X>u4uHBc()!)$q35uXq6RL7tq>^`IjEDNa2C~Nw5vFbm< zYG}6E_M>H_tSL*0E7#_3Dc~+6!^>$A|OH8g|Imn;x!n(FM}6>Co-1 zb+Xi=Dp+Ha$cNm*>lh&VH@Iuazn0N%Rydomlt^&ymoc&iB7Ru!e%a3MmLrA$%F0qA zS-D>tWu>{}X0bW{+TZ_ix%~hEzAD6zEraHcjEXUYgm$ZZXv$Zc^&Oe)`}MqCiF74L zOoAkfJ~fI(s}7s!f?j}x^~O%;AIl%S^xS188ekKIg(ubxm9#jxwo;4?QZc1 ztESOuCsesejRco|ZIqj0#y5)%Y}>#xVywIrGiFps&h%?lK2tUu!Di2{xBg4fPZl$%{SPEkfK zoUW)fwXGP-os7yx2#jKLKqLEQ#5l$*e&&=Fv5MgD+4w}-;8eV)&l(eC^B4&;qO(m|%sWKs0RT)p3=WNV(A!lQL zBz_mAH@-PmabF=l> zAaS6D8xjj{vpt>Rgcd#EXvqWbR;MvuaM3xbOhs}*DrC;lD4Uwn_v6yuMU#&bCgU=U z5{X5 zI}*40Qgq6gCLi?z;X_n_jP)*sv-X^hI?N7)sFcMCT2h`9x&K|WU-6JnbKhEK+m8;WhxpqZPCM1JdM@oOlH)ZC`VAChM4B` ztkFh`1QVLSTs8~)zI8c!5|R0~9JL0W-0SJt34dik+LDioCCr4~B6?q~@o6`EaVbkR{jA#@ah zTUAR&amf$!=CBCk5{E{^)Bd4njDY|kjkI`r0xv};YfnDv1w!`?$lgpFq7ro9Au1V8 z@IfsE1pbEEgD@V|xWD0pS_l))&X$~owOTO<#FBBs zaX+dBHQ}t~FwTmdd=}gI8? zi~%3LxU?vUn%dl@bfPqtH0)RI7qxtJtPm*Nu9KiQa?$$GfDRN^=^1BM;i_)Kq0J@~ z+YoeKgG)Zd6=JP9A!$|10t9sQ@p*2&QL$Eaxt)U45gj(*QLj+2JG8&q2 zNOMS`2_e~PYXV?(!`wdI_3j?Kqd|7JPvca{?U=r2YYmCJw~R* zeDp~#3TCg(R_Diu2Z&Hw)PXtc2$uv2zv$(_l)}3w)JLhjm|g5(Vk|@@DS{7eLeO&Z zx(AvqTbZ;?7ow67!3RzVxAz|+(=!kFG)A;F85T8Jq6kP+ zz#b!}zVs+=p1SBLMpKm=rA-nmgX{}C0X&QuQ=u4qD~*~-x7fbfaFt3-Zp;n;$>b|M z``C^J9#h21i;m71SSNw5_^3poT7*WH1=${{t^`2y<@{8Dy}?B!l_)SQ*~Wr0dlcG9a>(0scKohUMg zV=@13mVt8hK9VY3eN$2h?K~w^C{~QWHA`2mWh)6)t!XPEcNm^oA6STt$|L|WBoRIc zI~36rNoeEdG7%gyQSklP+!L-uDNL~QA$(C3cQH6`oG*z*cL_rhBWPT( z&Vn)CD&ao)?vkL|ymza-FO=IZi9RC7-P#I8HE2mfI+_huK-=ByN~36%rlv<#8d{Ws zuf=TEh1;!g`Ij+s46VE|xi=7@RbKR|d2qPlORf<~2V?F17%|=O6$m={~Bub@@h$*PJCax145r0ytShAZ7C-7T!G_vrpq$@=MVyl#GH6$hB z+G$vVQF5a)!S=pws4*!ulq}7+(bpuj_93n%M!RcVOIT!^+&kIc zf9)S<+wm`$mfCy-2@>%|y&@vEQun4FMiIB`ujNs_ifA4Bt>B$FyzQ-bSABR7rh8UT>uvzD^*iY`d+%)S3+o%rf3-$KUlVhL?aI8GV#l4(R{l!?;r zQ|pdLVB$EP`Av@z%B2jUd$e(sF(=PHj*x*?yv9>UPZYZQ{>F6>EqY5-sj{d5FveD; zrc`cxtoR!!?d(l9U|RBXn9!q8Rl?!fuTC9j1F7v(mMX72Q+D zH>MMbN~FgKIKc@#B0Mfx5jX>S!9paNiybf=(*pT%(LF~l)&~x6EC!RVr>jrB1nQCH zb>n25UCS?sdb;|gWFRkX3k-Tl2E{m8tB-_^@ZXfx8syw(u;EruN@-MIk9+#F;tS~B z+C;oy3^gQs!(MK==(#2!9yHA_jUHuv6dAaCna4*4j>4#3q>F?6{mbJlKD*L+goV?- z#hdlh)3V>ZzQ6C`f2C*AYQ2R1jiW{$n)zXjb5>n>ToII1=Pwo>Y2H{^>1l+cWt2_% zS01yAlgAkt=3~O!vPaq&=3^o<^D%uks<^Vzq42KDd1U;q5!=FsnRys%Qn-bF2FgD-aWcT2<1*+ql`C67ZD&@X5P zg&V24j&j=*=wM(MD>lgToz&WS&aoKoqi)6A>ndtL%8oy7p1#gjmmlPdZaEEs|B6l7 z9UnOTJQ(YX(r&(nS}8Vn1fh6CuVB0UC`i6GUPax+s`a{MrG6+^*3aNQO_-(q0fx{2 zxc|;d@~mEx(|6L5c=%%PK_wl}*qbnSfaB$Q)aY5Y8|)lmcsVuW3LO|#ATi^@+)B;a zv?~_Cmv$cc&Ufox3*)6~ zxTl&Y!1-ZK+>m%!)m_z$?sR9ac+o`{xrh9L`_oX_M|{zHDUC<+QA%{q6RDe=^6(?~ z$Q&PIdK$*A_*-f8b_aOG?B?6mdMRAH>6mvNoh#FU!csVFFh%p;n%n#0pObunBlw=f8(sIlSpD2 zGu%%KJM#;C+*3%Eh}gh9#C9j=9l0h^FlP$HF4wDdqZpVWb(l^BB-6wm?*sxOx104- zD}TJc!J|3>h)|OR_Qu&-ZdB?FTuy=%1GSY8LNJm&v7G(bJ!_Cw_L3MC(5ysdE+|(G)VDiWBr>{4g z+22>Y&E?N?p>Rd$zf%mzNl^2&SF0Fj6q^%)JQ#67_`V8Jjm{Vpj#{fccU$f*c2Yx9Ksno1VhMp zgl0*)1M&%mhU^rQ#(SsG&aX2jU>G`sXeLAZrY^v%@BIn>loBl*71}RlerV}q+9$;T z@J+uIA2ARFqy5nVm&EaZHVJ|8EMcyt{WeJijAtF@Ai%n9wLypKZMZZ>4|rRri;oOG zi4uKk(g%ic9=lm57{Z0vu`rFg!E6x4=VKIuCnf`A5@h(hNhO-MttBJDf&(Af3;XyI zF2<7{_f2zOU}zbklMcc!En1*=lRffykAnTel8L1Y7_>;)9m7ocsfXtiU?=^2-9J3E z1x8f6xEDS&FUF7N$U?9bVYRh6=NV6$jZt)Wg0p5MkBy|FZ%s0u(kvR`j|i?J{3iZq zW>$>|_;4%w+C-LKB`7{QCJkbScnE0${_-7GuYIjX6W*&&aZFq@rJ_ZXVGxY?1Q#wr@=QLnX zU6Qap8ff5{e^cTj>j2Hrz$vbN-8+;C>GAm zi*IJTS?EX1&n4Mm69(odOU5kg6i6L;5Q~-jkICmll*Bs?1;vTcza{CGY8m3u#kYR7 za~dV5>R!wRr~297z7;CL0R(DD$dD&>V9<%E68EQ!W!$KPV`kt%9IpunjZ`Zh&}|}5 zHSUstKSBmkMOfhu1#j}h^I{2=D{t4Ef22idD)(`5p>=P90J1w%@>jd7iwmuLy0}od zBNETLpTzvE?{T)_eUJMfn&1R>P~R=)v(43R`{v^6`r`cc?ZunO3&pG^xRKh30p3W$ z@H?vxzzs~?Nj>n@mPQ~ESlT&FiHbX=DWI@3nu6hr$k&mwPBRd6#T5|r!f_UN2gy5d zfj=)+^NS>xe;xE?&drdD*BiSyNta4UcOzfhB}I|Cxd!=~@lzlxCF2vhz0)d^wO7re zmaGdeH4&4mw_kgh8=`&Sv{jf))qsJ*449h$xpste0YMi997s0x10_d|EM^w1aZ-4Wp<>`mokfRs zJ>9s!zLv*LM@PyXt_^$?9L?czhbMPi(lFm`7PHtYds5snab2fC#SG}>Jh}Qd?Kezw zBG4o5lfpkrvS146>W_*cAlEt&Fhd~M{ZXhI?6aiOQvL)HqvKyGlu3yo7~3T-8ZGd# zNsY7}>HG<;aJ+*V7ei0?IdnJf+W;CUJ0VR$XpR7m62sB_2bq!yOmhrIH-p&TLUTOi zBm}DtSQV^Bz?EQifGq^84oHX28LU5Xb zNwH}P$A_jV6xBPPKRx4F>G89(hK=zc$nQR{1Sr$^Y38vikMgg^UF4=nUJA@HbIA{U1eyX{b6w*m!HYdK%1ax z4-EgMksmc>u2PQ{CL$Ny0I=}H$NXEviHhmw%ZAomA~bQqe`$DNYcAJ+&K7atR&0%h zH+%?J!-)dU&3|-Cqrek@4Uf%#Gz@5wakGBdEwo%{QQ$C4=NNQkw}%6&o_w8th9!qN z{pXWocIJ8Y%K2TIS@)3ws{*orIYp~BDhAVP-eVfIx}b~4pj zz4M`zH1<;A#N45ubz^4(fbm+=5mACue98UfPOWUPMKZ(6Zb0Znk6tln4^0 zRRc+BG5RN?)({0FIXH*JM{*G$&?Z14jsL1prfSaD-)4*D>`sUjL;6&}Ie>?c0CBxS zA=MAh4-fr@UtC7Cv9`tmll=CNN)u@5F@vkr=T+5XEPZZ3iGlgIg8u9K-Qrta{Yc+} zR#k&XqApi69bt+jJT%Gf{!&PP^L4gSYR7^S2lH=+z8j<%W#eeZ_yBt{3|!#P0w$$e z5!Iv|%fKe%iqLt+)iCx!h$UpAULSuX&JIO&F-ECED70w1>#YapVuds!1v!!+pl}4* zPyK*Z%IU>Yq5$F9uM>j2ZP@4^R2MOv0>8E}bw-3&k=eWxA|PM9P*qET>OR zT#(|VO-(HT`v=tSSk&T!jC?UumO|4G)`Fj^GFb4hR{*=<%rKD}Pn3O_B~Nn`K}dP0 zgfX7b1A`O<>=v-M{a-up>W6(Ui5Z>lBLd;Rngnf5aS?d#?Wdm)kvY2iI$w80OWjZ$ zt9Vg1KhLK+#IsHYI=uW{Y8Gnz>Pgw}c%GGj7nmBwf2o=aEFer5bE9bkD0}4)D0^l9 z&@jWp6#!mHWM=H}OvQlW7>eo43?I7(@XxD!4tl_EO!AvHz2>2ZUARzv&g z4*MK66-2KO3?Q#Ii#6Ro7}mH*Hb_CF$5<+wOMXJiho>EcR!iw{jk}`z2w}J2_Ui^N zs1oMT#KqC|g8>eWj^S@bduX)-gLbpSohf#?khY3eJOc{V;QK!nEHMCsK;qM*u8p{Y zu;3Jfn}6&1TqiF9OSWM7Ah_cL|5orJ721wj00{ld{C4@-*i_PzL{`O1mz}(HcZmOF}+z6_H~b&aS$7j_Qk? z^rpVZ{-qJglo>g6cFrwo!mqs=c-pcf$J7PfdJ33py7)_H4H$8$VWEEzmg@|hi{Uqg zPHAnPeK4U%*kwus|{{r$G4tP`kiyf`P!uY~w3SM?iH zW$GjMrEJsq^}OG5f}hiMsYUc4dn%{8DTUDx^4xkOx5NA3bEp_$KZ-E9Az&+@s5sS- zH^yH>u(hcMCAa)=3rY~rJ0Q<0N&iR*_mEz=?P1Q2HEkIcNHuOgNtC#JQfU(al>v)d z-X4>$ZCg)8%5A$aQe(xe)yuXx$ZU-!{4xy|b7QTxE2Yg^>2MjfJ$00(U989GZ1K49 z0B)l4W7%S*b$Zr`VL2aEmysR8zkOC>_&M-Z2@MLHkdLVe#L`#$myBbAC5M!|D=$gp zlz;(}Ox#kU50{ZH9jtQgwApAKDCariNhom#^(3?=>08)7R&fsoXAG}nE{>>7?b49R z0J$;2h{jv24SAjEgm!MtgU9O@+h6XM>%V?nB`dqcnkNtu>i{7fP5|9T?3w@Wa-pTu zRXMbfXw3no6l)I2Z@}hoM}K}@+<%Q$hdEFOMZm%1Napl)1t)zHQHeyW{@M0<(?7x~ z(hw9M5a}uGqF55aF#|@THEIA!#6}D#i4?u) zY35q6mR zj_nho(hjaRi9d$nY5YqwN7_`2X@E-Tf`w?DHWN1cZwci*(9Ij?BighUCOdP{ z@ex-OY9pt1f*)^QkX|9q_Hos#SJ_nm>Q$^TeK6iawG=cr>P=jn+gP|oETOS^?B7E4 z1>0I%MKr3eveam#R#=ZTt4lM4oV%OY8*pR01@~i5Cc%oxBr`LNAB? z6*Knsk7hr31R+l_R>#PK7XjuZ*b<;}&vyY8J|&Lpv}1oV!|3h1FiOKCZYN>i##9Q5 z_9dT|8tLgdD?@FM3p&G|bktInYKCIR5gHe6a+Joznj9Sr`ER~m#??;k`o{2z$b^+P z?PNM!#@udZ_kX~##@1yFt8sdDf}^Ng(}XJP4r4mbI?&dJtt~sUn@vQbzPIg3g!i{a ziSoX-DbY1=d2ajX`Fb;3ed${lMw-s-Fg5LnPj>-xOF;d`lMzm1!%(4jG-tcB}n(uz=Gv ztNr-%er^+YK7#1T1iPaJr!ujS9Bl{%ANCU#%L?ra_7rwBWC)^|&FQ(r({wSxu-#@;X=(e2{>CfhJuS0+XesZdRT?wN3xw^`(Lezz z)Ys?HON8yj(q-SxZr*>}vyando}o$OCU8IWbuV>h%et2kK3m2G(p&dLOUV7jr)@~< zNM1s6+JlVfg|2FUdFg!E;>+IdicXFZ9kSpX{3qJM_sFGI>$MM=tAy0?Ed_7iMQrx& zp+leH{$A>8EB;pNi4UWF$v6D0+B=J4Ji9LWZe5TSk{5le4?2!u<_P4>s?1^IIE;XC zJHs8T39mka;h+ipJlkVj!bg0=!=^gXPv~q#L?qw%24QWze7PmKlJ{fU-$am>;T8qU z6qOgLpK|N#7iIGC<~#G?mhw!c@t$KX8G)*b_dQwaD#OQHfVk-Y|4Dm665!=IesAT8 z>4BFUJW`h6My85GB8#hwb-1E2H7ipV5!u7&dhC6_un6IefK zP+}_xA9y!~2KJC$^h7$Fk-Ur!oAV&r=4KrHz_Vu^@-b8%dhk%f_TuR)RLpPS9~D?U z@1O^U)JOuH@6exl2-gtYd#_jD=Xlj!^&F+XU!LRCcEWRvN<9XH0MR^EUhrk?3<7BS zw|*913@~^t1_3w_0%e)-Uu;SwN5s|m`}Jxk9r|D}aA`sq#Ebr^WQK{WH_2|`=C}CTAM{7X6D~Y#ZjfF z-qaMI->Vx$ssnhVy61akQ?Q3F?%UWPJh6d)G_W~;mS%azaG-k--nK?- z2)K*$TCFlnI=(h6UN^MkcC8;V*eeK6?SOwYusL6}^$NlpbuF~Lg5&1nWB+BQw`CkR z7KNCZe>XL&(F!0ow9V350S?bgeUor_0yr_bY#N@M#vTHA)0B<2hcN0P6|0RJcN+}G z&_BxV>2OPtaMNe(OU{?B8S_{JQ=p;bOY=|*OPYre!StD)6CLzChbeFSPCvVvi}Ng! z=|A&_vU#*^XU~U5j~a2=jNBDcsw77zL9)+Ek#K}GXaGkDfD_Ai+USC|&%V8Gm|JM0 zj4+7P4gOQvATr&XZ$I_3Wy1=AOxI&sriO-+FHWDgU!;QfyfbM&0C?gBh)Om#Qq#K| z8>v};12LOgkvJznks5AhUeOoe^pIhj#wIkCE$?tjf4hLIvv>XGTXNlc zQ52lrLqw7y_@ESkdU&nZyqWQ>;&0b#z2k7XT(8#W>;B;QWYY8=4`Pbsig{h*yhoAcDF<5tGrTK~MAeCYl@3+@D%e%riX>YouMYwB5b|;yH#^(Lx8i7cTKQ zUq7#;^ZJbI!qPL3^*bKnbbo0ThINmyv?^TQ!LU6bMh1z}Tb4o_)B7<@4U%O_f3Qql zR+?_4^|@+#d|_yh-x-7Ec$hLda$g=6d;q#L|92VJI4uv%80W#~K{)TJJOWZT^+Ucy zBHLC7@y*qIx*e_r@8eB7nr=VLw?^1XDxVTk-3LB>0)C!Swds$u))RxTH{2;S)qX+kMqyJJK83zlR5a~JS%2t+} zJXNrE${b+xjjU7j+z8+rqua;I(5l;58Ag2(x$EA~?`qf4M&wlQKC5aJ3l3(fnJ-jpEzaMH|ZaQGDxgY=m*Lg%>^_ zXWQx7YsmbsRUV$fkT z^KTtDocrG{XJ4fK`HUG(_y&PL%IbzPP4mty%{1@+3a5GZjg{8ZqG{fN!a%}l-u+p| zG}F9;Wph`)iGG@Q;7GbU%{$<>((ZsMLNM}5eX`1ZC=UdvyLNz56~r*yf_c6U98B~U zIG^dyJa5NDH`V8O)ww=LsZaJfPHnc&F>t&771ezZ3Uk#i7N&_P5*4*1cJ43A_UhaEhl>1?)>4)4HQz}i$#5zy;53g zKubb_$=UgO^{}u+Ki^H}2WO{8JwyWcXD4?i2=K^Cm5`wC)_=b1zX7Vc3rNrbjds`k zpIX*9yIife^!TY**3YHw;5%b}1mb-HZB)6w%w!HkGT*$!JBzba_|MLVuePPg0 z!8J+10h!AV4C6A38;E)>a0u~R5(EjJHgpKl+G2-^FgNRhhly@>4#jK868J6>WK_iu zBSh3k5MjgAAw-DO7DJe}$U%h7J$t>uxG>2A|D`-gPZwKzv5ns&6Fie2h-VN@G~&tL4H>l_bI7>0*h9v|7^HL;uc#@1`z~L;Tjp3e3syjcnZlk4 z%sLZnJl{8uAq)a|cO z^E`q#_NYZQ+=)yhf7J4C&CNzF|29g?zm3&0AyPZ>UyZFqE&n!N%NEseAFJhmkJ9qL zO|8Md8yk!U{qM1=CPZp1{;QEQs`}sKRc%oX_c5v_XZ7v&?lX$W~LYBey#~k-?{x z3)pzB<@S&2A)68fXnjP%)M*AZ8}&gV-8GMQJaTh;XAYF#-Zk>X5q~>-mQKUU&BrN> z5NXWezZyB4hzyV7j^b}3GLKGD(8=5pqTt~FarXEq9txJ#fP>$nk_hJCjjF(ozmkrM z%e=AU0j<^aiJO$5t#F%|v3|v8LJG*(!s#f}1~l?7SJN?CJsijL(DFQN%`KWKZ|Dy!KD zXrI|3Z!yzu|7cV;Il0?E%vwg;EtM5OPHsRqXC53iRuq@Spo?bH3XOQc>{bZHN{7swTvo9t|hZ7;A=Ci9J(&knl@HQW|kAK zDG^=Xl@l5#QIj|Y1MnGC_Q*lXRFK>g;Z7c;G{y_A&&qPmR%d59WL=h)ZK{~8olHz> zHpPNo;eRL&OuTvPW(FPmwBAS#-1{6XB-aCjy(GYSmiEj;I3~L6Y>rpW%H}BbY;2BG z%fjXu7=d5PFIqDQFdGp9O$Ycdwg+>>W9*)9(k#TlV-Gp_%A0`!HgwtL>S6t2&k<@# zr#);OzrB+;8!lR^>L&-a1m#Bta|)r+*Pj)X@l(|(wBcAc4FcQs4!2=2B$zlT3R@C# zOZ}DvzbcXuX$@F$qY36>J!AcLi{A;oMdOrKs&vx63->-lE0H-^BgzMwMebq4f zI{3W(eDqVk0zRkW;a^alg^S(;d$a*2CIfM{umSgQ7y60qXX!$BgQuLsPH<^~Y|M#y z_?Hs#lol9>nXf6_^$B>Vry#9gVpxvJszScGIZ#xfhrRD>SCMVLp}kI(Tbh(Fmd;I; zH~8dh>pkpRHm%o(*Ht1ee7>Vzf~C>RaCv#Ph|8*d#)`Ds+J`2$2zyDTmVzzoJI~C@ z484ke@P^_?h5sVjBvgW)FX6$!I13fqJC=Udfnebr z0=eAbvH9pmA*Krt{Q3_B1)CN?g(OKrP|AlSV0`K$0h-|I|A+N@hc_pFn61`ZVb3tb z1J@$qJ>qVa@MF*|DM`$@z`ghD-FmgSZ;=HvE+QfcBmG*C2In-7c0Kzu66lTTMr)gC zL#SfWH6%xkCCYx6WujEgzh=v&@2rv-9WIAs=tr6M6fY)w4_C!L{_=#6biQ9KmkXsa zO!0oQ60U8rNIVcL8HYgF4l$U$te(TE%ls(fceFj|2Pv-HYZzu5(4yoEbtiif;;f zi0*A=@s7|({R+9o3jJeRzy8Vu)F3Q90+|So4y!`*#N+@pdIGJ-#n)_O@)~U(40QF| zi)kGwjnn#XTCM-~J+!V+C+?nJZ5Pp`&ngsyIvpTr9s#3_d15%>bPKRGBf_YINH%u@ zCDswuB-RzYOhz41@`<`I3~1;m$lIJ4(swyA1s2^$ef|vhfA5|*aYZxRSyZ6a1P>Y> z;8k5$8TgdR3rIG1T}SzWfr9Bl|98!1I+G^w@FTj@<5qdurK3miee1u}Nx=B}=hG!z z@;=)w)~k3W$#*hV%0?)(LmGama>WAu^V#zLc}ZNeyY6|$Se&0?Q9Pb}tg*+{**To7 zu6rL`ju9l4BjdjU+G%hDur3t2xVpYLe|>xL1~XMrV?q~{LCeJHjm-=m8h~?b_Fbl9 zUfs+P7%Pp%_G^R;6?yTIebjEvq9I2pFC7y2!UDoc4I!d_6%innmJ*2+wFN~$RS+d# zRRlNI& zYS$!FEVCPr44y=R?A9uiDF>`vw^WgZHB1#xTF+Dw`L#_I?S$4jU)GWPtz&_zf4ykN z0;fz^s@TE;2ZmM`%QGlN8dWl+#<%AT|)tZ_V}@tS$E)8SJWNDA1xB2 z6?|&%Pq2a!SkOs?rLuw{!mM^1#s`M*{=H9hOz-1ATXbo9p9r+~ek(KA`^3&U>sBJz z`>#j!{s=7SB*OY0y>AHb-}^+z^gjNxz4wVgd+)b0bG=XOT<^CMImH>^T|bNKGpnNw zR}Ev(&_xqBl>s>DmM*}RiDj{uDV)(XK(g9-0RP=0Nq1mo0;17w4%CPyew}sy#LyW; zGa0mqPnJZ3|3!-!g9hDY&{P)DBG5p2e?u@L+9_eAAs8C%hCp~@48bsThR{p~4dL}T zLl}bw-DS{JhTx!E^n$Lzve@4u3?VyBjI;WZe3DNIgKZPUMs(?!;t6pzuTh$}E>97!rCT=$q7Y znL$48Fati!oDf{*U?$>A|M0Xt|L zs6T!^pKtnYyeq~?M3WYS!D!o347J_~C6xiA1goz71VPaY2}ZRyQg~3>?P9l#w}}f) zfKF_JhfXx`E>yqm|JsGKGW{BiJ()Kxvkfs5OY2eX`r07plPMg2L$UnK*+AGv%Z9S^ zGkSb1lz2Cb_cUbc7rxe>(#8Zm^I#;&w;VQFmR@LIaESZ+4p=9u798d%OU+Fm7$mkK zz;Lh#Y&ZCyb#11iWJ}NVhxtQ?Z3>hvdc8MVNZW!|OWXBD0|g2K7Q4Td9YGO5132jU z9Koedz#mmgq@6<|W%RE`G@C|*Sy#Q9s@oqRx=!tCY@7@*I&PT^n&8R2kv^+;jSr&O z!SD<#TMJIhWaJG>QPUdsE~(bi>JD8zJrBRpnlrihRur^pe1smju<9LtS6MdPmV}2K zEJbVG<}V$-@%D~DQT4QGVj*?Jt+#j7y{VT3v_};>Dl3bZ3wW^V#5(sdsEyYlyl9TB zaRo75lTd1*V*Nr)CRg4dt`Bx|E__}nA1f{)RD3!G5Q_Eguf((U`s1-p!@am_Qy|~3w%N~kE zWV59cn=SRAgRT1k#{4GQE}U-M(s^e%LmEZg@nG!m`CAnntcz4|Ft|OO3tI5O-f%!W z09kr^9Mgf>5c)AQKT=;o)6G`Wmz@hWtOWnn<}f5+6t0YkT0XSRX|RXF)WN0=gosuJ0md#zJc z8{ed#brkKv_SD?-MGD^}AMkM8`Dlk#jVADs5zAZH0$w2;Vn(+RlrVu2gItPF1nFuE z7>0`=Vjed!xFaO21ye%9Dhn9_tFV@lT4RGP+0nZTsZ-PSGkyAlYDCf0Q=If=i8}0c z9+$o5m{%4YO&_jt3}>a`zEKkw?n^VBu*`Trq;ux}7(C|)`74+!HySrI)?H=1r$E&! zWhbA_@%erE;QM3Q?XbhW%4m0cvS_;&mKjpKbMcqE!q4_HGX~c~k(b%CCE4AtrQrm6 z&4yE~N@1!-3w8H9OfN3NnL8z@@(O0=PEp;N_GF2mqiAOCjATA@yEE@nSdz5WPw6S? z!3>W-Zl1o*R+s2#T1UH^>5sXKY{t_2c=K}PxVV71c9XGlevBkvRrklLiR-RMRk+SV ze&)p+A4DYk(0;+Ti?PfogOoy?QN*~&XMe4!gQL_5_~0o0LFKgQkjZShh>Njh4~`Z8 zp9uaAZ;zvYsuKUl2ueWvO4i8mpxE5J9hqW z9SxJi_DFnEEH1HX6VfIw2M%sOz<<#RiXQjosqg3S7LSX#T%*ugQ_y>WWgeOIRCJs% ztwFDH-p)4gPZJhb#|GWzAEFWO;Dd_!kfKtu#l?YHlGyOw3OYpCVX!aV*_A`5VZ2CI zN;WYhcWbB*$?8e{wB`iO(@Hrl<_Tn$PMkpE=_HT*vUK895l;u7u?=!tV!{URe6(E# zvC=>*j3>?SDsuMXLQ2+v4bYxG{h`ASb3KeV2;}oI;2@j{+kNDh8HtPQin~!>;hL?h z0GNx(()C6XXBDou_Jm7WkD;>)p^;LCAmB+cv?7QR3eyo%{K0^7(FH4_#Vz<_ckiLI zPQNt_iFB2HqC+%MMT0{O5!if2(2x5iMrwpoH_EMZYcwh;kQ#a^?@`0uE7?&cJ~G2m zqdPLK!Mh5drhuQ*G2nj_Qy4W-8}b%7YgoH>;iOq*hf_$hYWFjWW?C}yh-DF$-W7&- zm~LPuk08kqYa+;^;H=_PS$-x-S4A=UkjZotjB2G{B%;g~$TYa=sI(^I?JfD*mKaEo z?QEx863Yz}cO71+b-_f~PI2GHiBqWF0;QQ%Pl20o$Erd-Cx?@yMM^6Vz~vO`2QYP* z1-ahk6mf&8Kjt|#kMx$x9WcO^rIINdUnOHQ{)=g!4}xVvj5`xM#rdyNfSfB?5h!y= zoQJY=T3Y3)rDLboWmd%6oJIyii{wL4yiRjx#)`B+>?F>oTH2s3*|IZn;`7h zbV;;AQctgRwTmP=mFtu2Q8X)P#gyd}xV&4IG{wfQ6-#kPcGPMt<*5bfOId0W1+?pv zvcAir9Cf{m%yrHK8I7vDrX;jN1}5iR$HHv~N)<;gOf)7?mVu56*d*QJ5qiq~+Iyc> zJm?^Ogr(v&q(}s}EVZdnSyD6UVKo}?j7Gh3W7)@x^$rua%N3~MLN$2HYGm&LMx_;`fk5#*msF4t!k%J6@`jW`&4z8v#H@qF z0fQ0rukY6DKW1Ok+ZAOT&~Si5+d{+N;(BF*huFj@2+cFmpdU#EJeeC!mLfZ|tswm@ zQ#F&SgvWGm)+%nj6$O%o)mEY))mn?gsZ^3?D7tkPv|`jM3-F3dnM|C96_zYhaedV+ zQgv;WHKMk%$`EwxDkr)174ZUQY7e-H_UpE`B>;I~Oc&eNPfx&o@fV!P5oUx~nhCyN z)Q*IKNHZsJAv}_s;?pBMEVSHwdb)_kvDI(vZ!$ge#1V_cI2o8jqGLZSp3Ka?eZ*qH zoNJcZ?5{G-qs10t=!b{JJw3}R9Z*Ru0$=$Vg9bKHL}T~Nx=Dz`SL@=sTUSu5AeJu3 zxxF)uP?h~N4GFi0=JO7b_^PY}i;*_bg)A(vm~mjCg?s}Gi;Mi*zn_wlC>|7C1A$sk zaI(Gs+CR>=lMcUro}V7gPmU%>)5Gb}-NWHs^pF@!uErD8`X1ljiQ{1&7#*JhPTMy%-#^ceAE1{`Cf)JT{r%nH*#*|1ncsrp9UGN15Nhjn zzkPm8t6(H}pzYzQ+Rgoiyv7a)-L9@F=lzG<^$Z8UxZfE!gZB|sC^e?AJ?b%@cH7o( z*d#s_^E}WHUNu)Oi963Yq&xX2nHscNI_4o30QX0 z7Jij!nn&3LG=AcCi_>C5{h~o2Jq#Xk!#Srva?`m=NV)M`ro$~cm>tAWAH2mUUse0h zb*j2u+Hw=cWz5U9Gg#z|BKi`|6qiQnc5+!;(t4?l3b%;bLo@6uYhvF{46P`Re@#R! z{4RPI*h;n!Pu;sm@L<+eEw!e24T8CXb_6a29HVi;)faJT&pm`l7h>UW@a$jIVp&ym zzd{KWVkg{pFM-I^%{>eyT*lYK-g}4a9Z3mmC>XnjEo_!V`LOzF(V^Pa8)sM!u$1V zoj-zELWhCKpqtk)ecw8=fkkvO(GG9lyV~?n`nsU?2wWEtuSrU{(4Nt_(3liA3LNLb z!N&06>Ksqo(i}5=YIz<%GF@mo-3XYm}+0GFLiJ4~tf!GZPve1_Yt$2qVOxZa%%xRHq^bs6D8*Ni8R zr)??6F*dM=F%Hbj;ZAwebl|`0q>CJw$1OOpL_LWE^AwcaBM0V@69?wM>xhO9%%iF& z$H0M&KpvdQfULGIGd?|{wzVwJk@giiFfWNSuu%fW4s4()J2272#_^9G*dRdS!2AzN zy!}H_iYPsk)@v9T1zzt88259v7)9`n|JIs!EtafOSy0)$N4-1%ETW!wy%&wJAYJw zk;f7g0fc!5yWZ^Q5&faKEpaYb4zLe8xWawV!L`-Uo03&b>t)SR{XmUARklc#{-f}~2+MeUDZ*il#BT=b zixE`h(nJ@#`>LW;D@afg$x0FuELB=hz)73xe60X3CiDb&A)6;aPbO$2gGIWeTf90D zkud~gkSUYL{16O{PNIpP_rrSg2zSu@Uq3%zuQ&6>3Ld>k0!k4bgU~(DF&JghwTl)O zTh(xxb#d(?X@cB1D~(;fu)k>}HO`wwX9850=#v&PEFFy))@`%+e!ZG*wNfk<5!h|U$iPgf7gXF8KMoB|gS-w+gsF;Cy$<_wxnUQ2) zrmqF>>SShD!zmnvag2`9-E>4jD5jjQ`G? z;Qcg1K;~%=A~QJNBADM~dRW3{W7x>Jq@>`43fI~&g5`jcM-ZV081-ylCYRiBQ;?P+ zSUbpdB2%)(XE~|H%w0x6X6XveG8AtFEe(L8vR@YP))PI(j;9#l+4Ml|VKg5*hA9@6 zjYS2ksG<%DNBb@ zom*JmuED+s&(z5Rb-1A#pwXG=;cp$038p_TR`cuiY))smg+Wn}V}iMmeMvx51QO^G zhilaa@xt^7kE+xFB{_Hs)>HC7D#@GN2Ty{XM7hTLiIk_K6vbvlcpBcV@;~cXP&O?j zpf={zi1dhw>0E%p3@VhYMA@9oHW-UglFIFX>-|A;w#${gn2u(3d>~V3y z1NRH<& zib2${U{N`&Ta%qScAAw~1}v<zc=tqcsWCVc%@AFph3C}_C?3Pue>y z7H>H1BXH0)Ia^OK-jR$8!80`4q98%c4rGmu*?b^`-2Q7j)ivVoEf|W=F(V7+yqj%yTfD;L;`(RkEwZDuxu^YV zUV}M%Sghu67n|+w;u?&Xr-Lx>W+f0Xiy!{>i&-8!JbBVY#~8RVzZwpBBr9LH`xv`ax9UAC zy;jMfe1yBPu#c5YxYcg3m06r4lF6gEMP4LS-X=~PsoDE3vSZ~Amc`okw~0Lr0cF?t zk)ed=*2Zm35yy;OFFWgZF^ht78jh9^Fpv5X8HU9n5Lz!!j^@x16g)l7djB7B z-@4sKj;p&LWj}&TiW56))?O&OH4Az)SH0kYJT^ z&Y$kM#18;T5ClPx3_rro*%g(f*Dz9qq%`wdTk+Kg5JfYvMe`PZS=#f z#1h>uM5G*|6zmD)6i1y-fM9qf040BM_~h*`4V=6rH)J^Rcy+X4NQMW3WWKsR)@gJ8*20J#Ny*9C>brIYlgBMV3uO}6#eveM$7 zEzB?Q*`gh$q{6=A?!c$=a}}k0)EGmqTS@*7ACiO}odz!WB3X!_Qv$(R*nJ#yVLOQZUcZL&b-9PK>76h8_{s#fy=V>KWHW03`&X5- zSqC_*ybeez>9tVH$GTjOkyFVW9!Ga)Xk7v$9?U5izz-JI=Pi(2@4p40k_(kcQFG%0s)8uF zCl_EEB&j)ciQpBdE-77b>{4m1IwTry=YpVcFp}J0WPg>l+<1GhdPu9<_3`b4!_=C{ zfs;M3X#~NvQ~*WZo};Yx_EJE}+e^z9y}h(>!P`rV(s?tydkvyy-|iRN+k8gOAz&yY zNapLM5X=SpgPA9@a?t#$av%Yei{{3{*3lo~#u4dz#@G^!U9foThy~KZ8bmQuVV#j# zN&`Ti|B{M$D_tjUmsQk)#t*AwuxtKQc8#hWv?P?%cFmuvu0ew1x(1M@YwCozSozAo^hpJ zuh9M4OL-Mw%h%-&X~!dLnXdw}ikK^mY)#Dg(sH&p6j`i1)RIbiE2!n;Zin&BZ49Co zj^3W1<7j_JH8tYHYZ;8f6zSJ`7s22k)-Z#c!w)%Bt%lMdrYjw(Rj~lC_Fti^l=*kIeH0BBA zpp&bMG)KLjbQ(|<~{&#%Ev%5{Rc7ojT%oUtH` z$>BInI2Pf@n)LKgkKu+J@Ct-^h6f?Jw;agf$Bcrcebd8;VN9$7h3UU9?=>xoM=_Np zp-HJ^*yB2a@gMgVH$*aiOpO8joS7vvfvF!MMc;&9M&pY=F!CZ~wYIubec@~^|$4|W%6af@_K|}enbMMLt9yRaW zJ5bf7b_G?=y(=t;!aDa3(;$h;xp#DR&izoj?A*I@D(Bu6j&$5R_xZ1-Q3JOoyjlL- zKG3Oor3;46z!(@zWJQ>F!{$*jl_SPOBv*_tEjnX-alswq3wL<6C%&Eey$4S@_M;>O zOcn#eP8I$-gA*Wgb$;GGdGzFDxw<`nbTd1Hdlf=V(C?kV14DC{>zn?1xqGp_yIbDx z`^0OMfWRmN(zBiESA`U4h~6&m7n|kvosvJELZK*_AgDHc$6E);&1X&Sd#fN`#LQXxMh3M7!T zFek<>qnZ^NNM&A35rvsCs(~;eF>_-CE6z!&EVW#Th_WD1K0`*RCV8r}WLkk*5G*ZU zm??9q`Jk0ulSRdY5$Dzg!tdfZz;_nGr*pxz%ZG2@mdb=#I#E3u3%06`_0#8BURE`S z7I4x;T7ZbNX#pclsRcwO=c0%No9uUzFk2&vf|QW;4Xq+N)VwjWV-@hl_Q9P% za~s(uzNf%9LLSgt2)_i1-<2qt`5G?TZIr-F+8#&zX{U&^1X$VS$tL z2xc8yNaGY#pn_jeK}oJb1;%>^6%ZX4p#7y}KctGo$r1OZ02iiFRB*F7M)rM-H`1vg zL|P?+9Xpu_)PN=8!p@Wdm83|96Bh>#w7yyik$;@k5~qgNs6N829!|0>Gj3@62BA;s z6$F-kJ|Vj8i=++xl*o~3kma!n>Ty(H@|S8vsOu-jfYSutF45>Et@ zJ#~LIaL4fWoBsB&_}MoLfMM8pOcS@p1j->nJ%eU=e{yknl@`B$$|jb$EWa z-u%0{NicpNqkW@zf(^o8P6yS)gPSx2AEim)L(_PY4f5c`d9nNOV>h@=O#+>PKq;Oi zN>dW^M#dApsR*q-ZhIG53}h5O_~8*)s|%F%=pN_h@lVM2Vr@ z?l$K{8k)^6?{gZUJH}g0AJDf2tA2wg^miv9bZ=Sz!#z^2~pW|9*Waumw<5i?v*x?gG&}(g z6-cF__LmDhk@~z z`}@)Q*WvlHi~x;_^lO7uxRdY!p2_{Z-h(=}j0butB!H46!`}@upzr?y?i_+^IB}|L z5(0hy5No6uh&6~oiOX=s=x(_>^zd%UzD*J|SubO_>73}>Xn9~^6mK3@jYT96!4rA# zTZ25b=>(AX8+_NLsh8*;-T_K-Aa_HmK?Zb@KYZP8`rjIR2N$UxXq3c~Y2c2l!}qJz z-NOy&N9!^fSBDXpqzJz>NP-W`;Re~yW-)L#dL$AmFd*H`QH#lYL`&^rPE-6gdbZBX zU_CbfcY{pk%{q_dCm^mdd~n@k8@Sq6>pXOrhFs^j5Cf%w>zhMj>Kz`+TNw|A4voNC z?Fm6GHO=@<(IJW(hLTt{3O_XnXX1t-c!V;A@CM#CZWyAyN`)T-l5v6w-IT@d&f>`^ zVNQzn=(s&&nVq>#g2RB^w6n(jCeyPgOE?hI3sQyrm}Xl7x%0^*Li=d4L`%?e3Wvo7BIdnrzVrKFjd86!_>;Cta(Bf?wf!8ZU04xd?x^CLCo0H z13(%E;HK*|Opq51G$IzoyjYaWVuAw=gzV!)IVCo38-)ZKxVX26ayD*2G!Ubwe}U46 z)_&6iY`-OdQoqGT>-`p&w=NJiLi~eBXy~^Xz)ZWaC!h6O3=+8n{T3sU<% z4MeQh2_4XP;thX@0CV|;6(nz2D;PdcQ9^c_L6} zYPe97@P|MxVkE`GtrLUQEfzMBZYs@Gk{J7;=?L))4O_OJmOd0LFCuKY!jb_65*%-4 zg@C0?j<)4jbN>rWb8lbCv*yZM(JGF+Emd&Sy*R9Y>@J4DQr@WIAEK(kV_AEA1`)#H zkOh3`lS?CGy`-(EhSKOrGPIpj-krt2qGi+g=p~%svX>x|2VcVQ4t)^;jqw@YB#UF< zMFiLngP^zQY=@T+WRd^=bGLoIhNsj+%Tz`IBafm0v->Mhn<53=1$hShw*C9tTOjtb zj~$;f761vBWQe~hC7I#2P=I^}=M&)MbBjO}tl~+eat+j#;!$G6hS^MWT2)?jdfVhWCAXV8384>G`J!NrHr5 zM##|EF}PV}IXb(Qd{N3ki5I~Td<6@}GzF>HH@I=f;HgdW?^>yN+tMT$>TV!_H6TbL zm2LP*D;~Pzi6v-~4I7QYlVJIGrBwFpg)(cRmx)_34S(SbNMC%R!P1I9j*yIRt`sNHpM`{f=UHuweyNJ59HyK+km!@ZeE z(R)$|QFf&i1WJCD1`Z2XFg*`(bij0*1`Z==3LFNIfxB1&ZSCSCNf1qV4ex#~!q;|( z6{cRmfkV7EnY{f(GlinUbcn`?Y(lE^?`%vdD0L?kjWD$Gbtu%IYYV?H9naS$BO1mo zzA>5{-ulGbC`B8XchEQoUjruVdlSEda75L?4ee71l{8{zz(gCu$Wi<`qP|; zARliHVs`D~>BfA_rG7Ok+ewv?9rK`?*ufkRznML65I3A3!SQEtkl-CISQNHDv0sJk zkc2bd;nEHQXQ=>k3)NZ277Ew6((}j_sIaoFprrL|1;(#pDQEy|5n_)9^%~Z!RcItl6h^5*FWV3In2x-{_zEYT}tsJfrbPOAS%Zb`Z#E zKvA3|xnCx98>n_XsC0j z1K1npBzUvPIKjh?%ir(gJ>-hXqC3b&;h?7+4wn$8z}PK!v-N|KtDytvU3}zhJc^=noK*L#zx&43%3I>fVY_Y0oGDu zhUbLQ-{b&^)MM$>_OLQUtB@OgNeYbpnvxQ9d-OtFP#x{i#*&9m3yw8<(Ve9Tu z{HrEjEn$Q}wNzY+P)p_c(6m?@y!ubOI`9LMk07fGEd6xwQC` z;1u^Wk{K^t%hv{b3^X_GwI!XJjg9mfK5n#V(Pp6*AF`HO0)2vy$$@OKEHpZn)pjP7 zRdl6UXaUtR9chDkbhJ#-o4M%izjnUz`JnCnYzBFvcNS#6lLK+cn z@E{LuXF3*&9_?@q;>wTf*N%>bdm6zYO;Wi8v)q}pfu6v~p{itN4-9&4(SX&_z*DcF zBG@D07M#@Uqv&nCe$GlhY6y39q}Eb!F%fJC1@F$BuC?IyPF7d4 zvxjUgC)dGxJf1{xuW)EOxWlt24iG-uA!$VA0WoQu;DHYL@h|~3!vpZY!*iRjcH3_+ z`|oR5Kt9~{$vGzx3{5c}4Dxbdm0H)W=?u4XS^8sUCrG}4bS93RrblPyTs{YH(sV_w z?P-0El}1@-r@TIBt=SAO&|{eE@qDkf*gKxR!UoN72=VA~bKi{a6%!~L1IhoW5!PHX z#^Xo0Lp&jkAoj*Fo`7E<@;__nqa%fZXquF7x4Uoj57p#KVc5}F&;|ypvQI2jRaq7} zQvJyFVyfWg=Cn;U0vdOWA=+fg==@1eL?eK8(Q>d?wfrX)T~^K1h6~Rd=8W}lw%=RK z9?M)+ahdg~sgh!{tTcXYmnt6AQzNN~&hn&>p?*p+Y(R{cV{jQJGt5=$(E7BB7>bNeSIhg&{p0t$`>)H* z#XFY+pH$bK_$a1VbC`0(JD0N%>W*a>LdQ&uJI0lQ#<@7PsCG~U1H0wjhr8vbA=A1U1e3-a8RSFOT~J6B zujT+!u$n6?Myk2OLYSH>I>YqbH_J^A?%?68(6Swm1PjR_!$e&cNe`sF{II?I*}{*u zeMg``$`qyY7=yJPSN#rmku$=@`I#j{@$!^Tw1(wi_8pTH*EHu=Dmb%&@{~ukYUO03 z?tL+;dq<#fnofABx;MuK=0{N598*~bu+2j~p2}=i0Lj;yL{&5XJsjmrdx6qASttOGx*OXS%ENcQQjeM=Xri}ekwv8O=>&IBh zGzN~kgVEQ7RJ9dx^+Y$Gtv6rj`X;zguEo;Na38Edz$C^U;9et^K}|k-ChG0|>T-KW zuaxE4j=Vd7Qe`lco|+J=NkI4R(cx9Re`g)Mj9u?0x^R!jk}T{`Re|y=37a|$?|%v| z>WcfDx=Z@CDj7xw=t;Qtmcpb|7HT>TpQ=lUR;9rcd`>gzD!fL`rc_j`xj8;k?Cj^N zaLFBkO+A=g6BuAk2JdiT;P6vbAUX;PHzQx{_YdN&ft=4wdxv;waEgp>e_@fh{}o=V zH;AhkTj`yA0oV*KbK78})}TFn+3(lMHQcO~p%>^(Sv&1M*{{C#-6YCU2+8Cdp1FFBYg1bK;>tfnCDP4jNr9`|Oruse_+ zAV~~{WK|SQk@UFIRkGaBpu-XpIutt+=CxGOaUHteZ2)NN0HE#00aEKsI-EEZ9}|szL>sTp zsO@c_V4ztQ;gnYR17JirYXDcdJvOI11_X@!^i!1x4pvVA$GN8WqkCo4pil!0s96gL zR<9Gosd&Y8wq^;Wsf3#o!$6gHHh+O{#ld4ZKQrDR#=Ec9pK*)g7GbzPMeCsE_dz7XNw=9qsb0Ktec~+%B8-0!Fp#>2?2QjaNWi zY;O9$AYy)ji8b()%HJpj?CDcf%IM#>ciUz9&eVsG7jG{X8;p`CY^kIYaEZk&g)c#2~&R3(=lS2bxE zMg<k)0S`hNN3%IMk{ z_!E2`5PEMsg}@Y#5diElxhf;7J^|{@4p_SpoQLr}0(^SA+iq-wkAOeAUatNSNGh-N)dkR(^knN7%lN)wt6TKSuuU1g>G(9pFse;p^h#YZ$sX-;SYl22;!t z$eiE8Qzoz0JFoyB!H|xY2Fc*9c9W=pF?#;fum8ui3YxR8OZV{M7z#rs^N6wOlbT0z zo}>}L+~8>{{BQslYRbH<_9|%Wb;+HUoAKvpIMH0gvBW z7g!MRXvV;T>9=@MhM|$bBDob3W;y(ZMnPS5T#Nzjc$SGTwXR2T$oBqbw+Y(#8w>nf z!2%~$MWai*3vGOC7h}_#tpO44;!EaL&>-%IF{x~WGtAQxcXhcyn}gWIHL6QX;8<+4qtxy z_}hzQLaI<;XBkC1iE~VapCEBCcT@lW)<_VgIGh_KX&SWkH-_TQ(G5+K){e$x7};US z>XaXl?5_naU+>McweDWVU~q=v?o+SX5gc^oHItN@8~-?I|0?kXp6I6 z0w&#>suUNu`y}#*?d1W_1{i57)bSM$?m`p3x|qw?P#Qc?Q##uNfFpXPH*Te>4FrpB ztpJZMYYbdzq4@YK8WptdnHPOy@^>-v-NfI;D3paZh1ZmZ_RlISI%5@=2|{J1-GI=1JgA@B&m$ea0TQ$00`5 z!lvNb$F&e#YR0>daYeT}t3hr39@7?N%H8}J)+SQb+0QCbTbE~mg3HfHZdE28f^&Pr zO-+f<>=`&cb{vxCgO^M-E&1lGtU&oLm<)htrgOE?jtH6=7TcyXn_-=M9jr1`%Um{RIh8W$m>dV@=xBt70HMgw#!i*^gmm1~r2Hck|6SkMC`qD5u zOr+a?3GnG?iCgFLYN)iI9i{oUOIjmTiG)qP?g3-0zc@t=@@Xcgq;z>&3JVt|B;Trn z-Dl<^4=LIFkbP|e@&pAL^0~(&v?A0doKW1#R1+30Ofs>E?EKO(x-O|F1|#S!a$&Z> z6X&K(cy>Bf-u3?dW(QZiF248aG1a6f-cPJ93-YPUf}BxVXUA;9!PVJ|CESV);w@l* z&@Ij9L7rwpK(+{!;2ZHWM?S(>L1G80h3VQd#e^ZrPD zS%sxjY0KR!2-Nnwdx+P@CuEqa(~-0`glW}~N1^e9V&!VvD_tYmeOIWdxNBV_GOCWz zvhWAQ(nhmK2&2!%D$_H8i_P--uK)XTf3blx1griYP7zdw$c&Cva5y?D#!)QF(czsU zA6DO9>>k$p>iEPZ5eU*nkPH+M9_?My_^p^5lII}`(L+@JF>Wmi!o%y-s&AKnJ^!F* zh^w4YIOtmz=cW&G?=XMMxuPerE6Rb(jf$g)LzOewn6{#mbSxz^M{z%uMKfpFI9$Q^ zO&Z5L795!}dwcwi1A@Ytxs3a$ zHyRxDght_@D_NXYbvSUP$wZco3Phd|$KUR2a6gqrGoBEK8)1GpGG+GG6XJkgpST~( zRM8W1s6Y>EW(Yl@F|eR_LvF456ksdWlNdH?6L~^hg^fXCeksdkJRt@)L6y{vVm%>_ zyYqyY--;E&@Z8(wKE608_b6$tj>XJs8U9tIO2LoczxMsz^->q{8442z|7V#E-AxGF z3;piX79QiQMl4U=%AN4gVg;9Vh7-T$fJ>)S#V0=3H&qTGhn#jC2!eg`CMY#6~mo=~%IBejyUdoqK2kA5jRJ!$%ax zGIiH-Qp39mbSyE)+_3~kV>Ab+PL#2jyQ?-9lr)dz zoZgI*$z;3ilxo7N1lVqjG{#LW$ecgqRb4qO7Uq(&(p4=wBJbe_*-3&F((oaR(q!wx1u#KO$46X*%y=d{zecH; zG4H{G!qqQ~@D$oAlBf9B2u-X<^+15i6>}ot_MwQZ zgmgO@NC7!j0nRoFM#ePTn79!>qVbEXcDb+pf}ItVcWtqs(XpbNRWsk9+`~LY>J{Uw;c6WI z#ZP8D+H?)V^KdiVrkY9U7v7dnZKcgoXjxE(# z+xx#S*PD7TmZ-tpAW@^Ju<#>q?@NrR#~};vXkuS%cxoiJ@ME*s?kXO7H)**!OloX* zPY*+kgvL93^50rzp5sf3&sK*Ad|7RAdyDVX!(|naf;dI^IiB;ZQKec`3bj_J!&^}! zEtD6}vi@~=LCF!Qq{BtKV9Igr?U2*ZZuS;zU`H3RrY&Q3dy}uN63%vhgJBvlb*_$Gt3w?RhY7`jOTy`)tb z)#P_$i%Oqs=9uJ{ShUtgb5~--RCu*)uOgbwXcio8Hjh9Bv?HaWiZkW7)<*8|)~SrQ zGAvOTuVgk;x<)sXudNbWvzbsCVKx&A&2m_?nUL}NnS5_0Zx<1P4>#6qMuLnYlB$T_ zY{tCX+koLbT{p>W#**3mnfPO~xF(1i6Pc=*&6drX%|r}0o5!DXJF|54}7|uu1%2+b1mGQ@BagA2SL`G<3OrTW?rdrgS=!sEAjxEdJ)_%lc}cD1=6`Ii zhPhamCw44_Z@0Ym-d#Z~=l}9Q^G(3-&(iVxWOs)4j`QWP-#mtXj}c7_?SduQk;1Lz z2}IpuC8C;7#IWO>*UN7?=lrX?&m6U;?Pr02djFZjH*G)~0QJlv~i8 z-0geN16x6O%_j6fWP+O2uwLE1G{O_*5 zUnLkY^ie0_VX4I6ncZoZtn%jnd>pkoE#m8Y(;`%{H7#PRJJT`}+U#<*ypwK1_Sq6y zQ(=VGAZh=Q{>f{L$egmN)}VQ8T9ga}&ac<@_|v)(jHc=33U}a}`Qn>l7D`n%|8C^} z2>sD!*0ed?jsk(79U(O|>wDT&RG)Ox*zs>hb^Hhvbo?82$G;iT@j(43 z9skC5e5(wmaaFZ(md@^UMB`$xFJp)589eg3-Tm)_xMJsx z20qX|3J0r@5XVGQ&fU>`5^GdIr9`40Qz@YpVU-fR8d)iUI~JYh);Je5Fq05!M34D*~Km2?*wz3jh?QG=Pk_}S@r zNYF$F!x0et+TLPxFEtpPXRB3z_iDMq(-J}evDAFDTb7U^N#k!5<$Hg73*9tXK1(K& z&wS(M6J`Jq#aeQ5PPyg@{Zmu6g+q6OPN<(PhCiB!bd=?7sjxmMC%Jb+2eGUECr_uz z1r%r@%iV9A<@e?K4j=NZ zbr(vTVMs^PuSMSUyad(BWl6p4@0LF+-09{^1~qh8M6D_WqkmYbX9^SkBh-)f^x4>=1+>TdqGa?@ZU zz{}uUM!{pPMV20GlR4~rAu;6sraX?^gx?+18k3C^Ue8-TRFh)*ontm&=cOq^n6 z$lQL~EjRmbYpBL{qcyh~CJ}l*PfJ{#-FA;>eSh6Oy1reV^eZyAX{n;LcnlPj^VN@v zkwXV6DEHbddCZ+q?=mOw)D(p`hp!&JUT)xl%O>@vC+|W)Y<9s`lfDdAyNj*%ylAzH z@YHlg2DXTlta1_LtgxO9F8CJz3h#KvF3{uYJ&eV_NN4pZ^WeqeU+-a}eEfcQ|8=>! zfNQ1~i#F!=)e1B7G;qJ}zmOvjnb`ebVE8Za0_DSY_qWyZesd4kwypOE_it2F}+Ch9-IZ$Af~4ntuiP5G#?Zh{z?7^XmV()?XXdeG8&v_ zlqESTjxAQ$QHQR3x!y1D?zTT*#kN1Z*xvuVxP7;Uf52aVTj78I+cvLhC=+d@c8XJA zSn?1vMrApDw%aX#Uci<9z>xlZ6w)s@6j)m?@4yw>UEL-9|MY1f>}!RztMB0Inf}xi ze*(TJHjo|>SO*OQunXU?(-opO6g_q0NJn|lafKMCx5ERkisFy1Vd1E6zEE;a`wgON zN{6y*%C`!?zgw^R#W!t_o`&T$@^mMA3>fZzUmw0MKE4K3M%~dM&%lh0fSupMTItn# z2P5F4eXT>q4PkGVjVKsw&wn0z>zHZy;PCvq+%+JE%?*X_`i%^YEI_%bM}W8~PsZ}Y z0p_@(DXy%ox(+uWocCqi_l8MjMmvuVo(G;_+M>5V-(B)^nfK`fo@SDDUIebZEs0?^ z9415etc+3VcIbOM7#fk>W~1KK@E!(E>ENAQTz>kW{|fgT^`!or-LtE;nYi1iXUx_i z*l^TS8drs3L^gJvADxXjZhNt{lC{A&H%n7Dp4?J37#tM}7zKkjLRU#?zQc zYG<<6(LH&w{N67Q`(!0K$JK#ZR{m|(@A~E4)29%bbx(CskTzeS3F^2Q;sQZ5mjeHh z1Rr1HtmW22(`xAb)A9;cs9IucFF$?!?Zu~P!72a?tJkK+8QkRz=7O}SDJEDRD+0Wl zXQDUQ?642zqUgR|9gfvwN1aTEA@4WEUi~OSI%7TzC^sJ!a@ng}1K z!gVJ}*>Y8pjI*;DZq7Fr!1+>sG|M=g`YGK4uN8xQ2r1LsGs5{l22jdG z^r>j8W|U>H{r2qv7GpnO!3_AY)9)J3Fl*$6jHU@&{=F!f&2w_uW7r~6_ONe`IN{7d zh8z;gLZgpm#&oxZNsKe|yx_5Tw%Bd^fK>nA}DA9y1IPdHZ+!TJRI#Nq0F8;SINnOyLeG*jqHT25_s3;DzWzE+i?aGI-as4<_LBrFjU@jBPI+n20qZ?53zN+cchbm^SSVdyqD5zLja%!@ALQ zlD8^ckrqqr$6qFH5R*9 zx9iR2ec#`_Sk@oIa`MhFp_K=cPtN{S76rT69esG&!=XYvAE4>x9AuXT=J|s9>x|+^3B71#`E$SPcpAg_yB$0kuxEXfS@-NDwM+SI)84ii+#hYPw6$zMbD-|h< zNNK&V9{%&6pTUr-^d6m}$S}07Ouv?SWAiLFcoO3I{#%VHHpNhwxcNVeZ0Nl1KbCvY zx7EL2EMdvIRCfR!%@wgEg!F4sra8vo-)uKu)`y3i^=5e&ou&Bg{=VNm-#&;NH*Pr3 zadE97Lt3IJSQNS&PJNm2Q0ubc)R!$!Vwh83=1Z9$>IYg08rL;us2@XNJ8mtu$fn#E zZ?-><(H8-ka$gJui$c@e2<Q7+4p0V^SZvx9m2Pq@72zbFT_t5cZfnP_L#HG-t|AOr z35>&cdD|a;zTMvRcUe+>C1B>-^p;IwPJNHkjQv}Q!@OHuRsQEY9P&QtTopIxkPqiBzqzooK)Zv|-bS+SDCk(=NtNDmI4Wmf>yQ^bKMSm(d%=VU79au-^=Z zpY!!%i1#Ir)O3pNV~QY!GVGl_7`AEi_7nD#BRb_tm4ZuAc^l`AzLja1;8Fx&LcHOI zbFn5q=oC>L#+70NI;TH*Bf3hmc|*EPkqcXe=~iV8=0`yCwRL|w?2m+$4Ux6(+LoI@ zjE4P^b_jxHQ|TYK8N?u)oHbEyS1I&1mL3<7J5Cd3UZ3~8Y{)KDNn8(@4W8(0*><6h z{rMvj{a;QkoUb` z`~_?3b-$^HAn9^;7RWnxjw3c6o`_l2w#0FR-WH??g86r`btp6mfgl@xRV|3IrBVp> zOY*VI7?+LD9u8YL$@c*H4`P0zYXzFRV*ph$`c!A>Vsh~RYBbS!3wWjhVr&LLEF&64 zmUFD7(U5Qb=CHhrLM6)UI_9|TRVPBCRf`qHonc_)6I_RLd05}x;v4s>p*q752?rys zV16hH(P8A(-XS2Y61+}el+_iz4yc|kzC&~SVkjRBA6h$r$9H*k?*9sR3;jo#5*S^ih;D1YSpq(25}X2TapSQ$JIbo7GtnEjH0?d+yvTil3bQ7g;CI*ZY?{ zn89`?cAZ}B@jIm5|}Y??%d@Ex4}QlRBJ`t261)fVrpsCG8qmv30KfP9CuAQ#b`bu49P zt}&o_;xpo*!eIQAP$8aKVJL+&D=I4*gJAqKc zXT4w@YCfJ&faC0tcGWWEI&(9qhf@0tq#9(13=U*9VCbdAh(`v;;z=5Bh0MnWk#JSw z(QX;qA`=E|G6JzsmTZGmc%|*d9=7{04{b9Q=CpgDwUCBP19w!Ff2@IZ^Drk>38194 z!{2%t$mYNuj=TQ*y8kiKPGiV`qhZ@6Bd!;ZvRy9l?Q>9J+>>rnW8997z*eAvT!SR| z;K1NaWEU@1>@r=|pTMcp;%|XG$%2wD!K4*vx?F%IpTInf*RZPyncXSIYFG^PfcTqC z&m1S_3FiK+RH0;Xn6w0P=L0`N`)Hy-C1^P$Bq9s(A+~|^u_6{;3fhP=)`CbZCqd9W zpv0m_$ytjui50AbokUzA1|`>ujYrMwb8RdPM%m4Jzx}acf0f7C3A|nnrqX3jzh2&b zTgJCnCUyl6pEV-D5K0Iadg#vb5}J@j2`9uWN)RbnQNr+%iV~tbg*F6VbWOSHFBY$& zNve#5wj7Csxh+D{>7MRwzudz?Rop=F)_+*`7iD>jW<4Sqx@Se`6S{LK!sbRDj`D=! z#Q}*T`7<*VBKm6CFo@)kfA7JCIILIt4njLP0UdOb=Ph>>Q#u&wr6!uuqcx16VV^n) zv@}i7DI==t*+?N;8QbVn#@X4#^ao{yXq7l?D){T#f?<9gG}R z{R;)PH6l+umJA1V@I_0>_}~F>MBg?DZrz)ZpBuozH?8nbf{uL&i`68Bq}aE(baO15 zu|fA*tg44iS#9mk!Y=h9<{!26&Z7Zo3F-}Z+*nGcvlBB-$KY%KG**4+h0Z!9}e|3Ttaf*K8$Ns}IRnCB>P!gew6zXhMS2 zvbER!C1|e$$#*5y4yT0x+BD_kv@jYQcYk@}*V(F$CV{a68H=BwRTf_-owM!<2kkO! zhK?B=y?wZY7oMyO-fGM7Xwy^@XwF$Fies0BC{=Vu4jfCt*>z4JEp_A6@#IzAPo4sc z*NR{rJ(h+a-|Vky4xl_QU_bO4oPhpjtP0|IKLQm{A(2W^izJk`705nFM651JKWljy zGa^xGm?b0N&b_THimXX_jHVkU?S3F8aQ#`YvFbs6v$Cj6&|Cl zJ%yHd5>{pSAGP#NxQVCHpgKGOtq?W@#S`%=#Q&`3k$XQu52}p~<#oi~!YDGi7Zi{w z>yyM?+Y+>%Nt}Uzx!GJ6e^+vun>CI|rbV|VR(NjLJ+dq=C?=LrR+`R&{QZ9ad*9n< zTI{xCF*b%-P!6=#a>A230KzLn-`}?J!!)oMdV}fd(I=%CxHrROQGLYVSXkmJ&ezV{1TGYD3!8E`~xBZ`5*6663pbXf; z^l9{x>FO}kE<%z3;TNq8xJX9}dbx&E!f@UdPi3gFP&&cVk>GTu4#flqT91LRB#~rCc_U7LpGoOEb5iS@J9^Jh96SRi6#SqJqv( zxKPA^VPhQi{0Etmi4o)o#*DKy@X4P!31oUoFJGodez~U5q$QcC)n7%S?o-$;awPq<|C>}tQ(CeX5f)?2n#1lr`!qqHngX>Zv-H7)z+v0Jv* zCeX6~tha2f2(;`!kJ7S0rM+eUY467UXE0l4nr1ZjpKa|+d0|DeR)MjBOy+m7G@6J{ z_2#Y>f#&|CYi=xAY85tb$F1%oS&>`yiZOP`lDdT!@gl3Td_`eC?@lB|Q|Dwl7awvgv4|DI{4J z1K0L0gE(?v`HF@a;hN&mxSl%OvO$5WIz$QH*0?$9RdAfetut=*y~`1;-D%(plWjuB+ro?vpb zFYitGmz3aVn@HgR{wJEZN60zvlh-17n}oS~gEGer5_q@Lb;BXLYHes|X<%m70sikQ z+-xTK^30szme8SjOeFW7u%|QVflt^;pL!7nfb)bA(0G42jRfaUGf&Jo-Qtxo z`Ko&Us7z7!(2v--;$HS~sup*abOk4w~l}1_`s0nZ@hLO!sTvXUiSwGsmujRi~ z$Nl4Ae*UoAUTfxP+|hF!)R@4S8BAmjlO2_Cy&rL^*C*#wilp#%n_i}i_}WNt^sOq3 zd7Li76zpo!1eqyuP6SlBqAGju?jXJDMaj&%6jAr8w>DY}s_-Bh4b|Vi7Kl0J<07fHx2@PfEzI0zh3yVAPqq`WYLIR#Roja4x{%!nr0rouwrE7W1Er8KO;GPJ~C5 zjpG$75j^-64x=R45<0?!mdu`??J@Ff_}J(W`h_)AXRcTrGRwcKC7$Es;_&`lzk3f4AMfB)-uQ;bYocwUPY#x~fsEc*s2|pb>v4?+uC+qJ^nsX64Li!i3W@1WgHfv`4KKsD$Hpr`s(?-OpV4W9yb{!i+lv7eI_r<8JtQPCFu5@QJk|U|yjJ8BM4kkFn{4%m8X7iMxHzK^xP#Gze z-CAV`!b0SRp5$YG8_5h0vZs#Pc%?^o?TFMsZF6c`h0l;2f894Hqr-F zwws&F|9x0OI13lgqg8*7$#uVwI%r^>x^`exDUDOGIo=&zrQMLFP5NAN|q+`D>^`b!7ouc7W#y-2-j zK$a+tR8BubmT3Qq8M4SPm?2B$M%FnPkR|G42V{xnNQuJ%St1|LkfoB6AWUEz^q7lN z)4RpIL*zF(1*o3+BTO}7xtnVkxS#aYPsy#}XfS<$a>ZBHXC!fSP?jV?iAz3^D4W|) zA8|QJjbz?mPNu?T9@+DdQThhg4oPB-O{n`X=AwuyDN3ocX9|4QS4(S%*+Ua66XXeL zDNU}6m;uz%AX3s#3k@#Mr>PYf22Q}gfTZ0oee+&5C5I+(Yn$AYM)MgS>dWWHtPY=7zz)`=MOjnM^;8fg`=;y1xzdrAmkIrvSSKaybY`(x-zoR0Oj<~I2 zJa2)SW;7-Hp767w$Kw+#SQnLIrdn0Q?vOWh;dhY#0V-I(fi<`pg{fn6&bb#UWysk!c8Z;{1bO?XW zpDLVu2w$L^rYN=?fD}lMJcKV$(;mW~J1te`ZU)ElJUDF*PI)<;Do>LGDzY;CpF*i(%t+;)MmbJz z+L7AW#yC>#<@ycEi6eCc3j6a{jZ{N;`bZ@@;%bMp6K13m?pKdgVj?bpIN@-ler_|v zI8s|7(6gV9Zh-Nu98jIqr!-POLy)6EyUj@b{LAdF9jT3Nj3f2)s5x~63R_-1Qf=Xu zCdS2vVKAw8X>KJtCNTy7*&>D+xFCU5<3^nY$bx@`C0pTZiPViJo_c% z8K_R`aT?Fh#*F7@zj{13wlR+9XQRgR2o&~b%Xr4ZEdvS1vtcl)cWFEm9W$O=#W3TU z2(*vqR%UKI6FWDa9g!o1%8qzf*qn9_k0H~M?+O#*ddIjcY|ihs`WwLDXD$y0gR>Z* z{yg_3kJWg(yTUrWV8Mlmqc!cj__{D^JGaj`Uo89@cfdix&6S3)ILiu;F~1oUD_KV-HQ(5QY(&*ALZt-L_zICO_MGo%Sdv`4$NiZQ34*e zmQhn)&6BSaZVnU1(X<=0vNjO2DSk;q1o;+I=^wcr#B`0(gFs5;7)_8%@i)vYZxIE+l6s?Y_r{RQ%FdN%R|pLm4{9= z4UUI8yGcwhc_lrzZMty3C0bv z7K|Gc>IJ?q|0JSBWXE-1NB0%@M$mO)XKo+xsH1mfXRi|Q9CRIuS6V{%>wAWL+9rS* zEJy7}%xbby>mzTmCY<0|FH1w&h2|zoi#dJ=+Pf!fz2Ro;?i6)7oa%8=N|p3JSyH0v zaFCA{(KH9&!cSEq#%T*7jN!79`h{{>962PbWzGwxs=D>C`n=hIYDnU@AZ|^|g_e1?5Gc%>*-$RMP^Aa#JR-wSf-g>pZy$)H*yK19|7#FIgh5am7au!sV3@%Q zt&b|#`ve2cmaL!Npi*O{>`WNiQXDn8P2p~%)V^~~Sj_x6x=Q#Y3Xs6ragy3~7;!re zA)^aUB9&tmLB_X5M5ZCLxT=YCyC2G^uXYw!w;Wl zaFOO!bo|2)!J&*yh~9{Dl#DBA|B^8#KLd(n`1O6K?}`oN1HdG<>aWo16ZxaQG%=hBcbSjP?@r2l)0cb~>2&Ao{qK;gM0Xu3x^{-!ZfyYQ z+%^DoZw@GRa8_EZ?u;yTR^E1U_Fbl9tak>`cXS4odD$_WA$(_NzlgNDN9+CD za;^>#=>rmjiL)7UI#c2#46LfC5JOWO*3+BD8LRX}xW8F#%CTce~r689kAEz|pG72@J{ z^*A6{aRR!q{ipt~gB$FD(diUI(9SUti*^AONVEAz(A>j@BUUIB&b@;X)X3xZ_(nAh zo}2oxPHwPMR0R(_A#U9)EHM1|u-U9PUm|m_t0{1GU`mCyf3ymL*CQ|fT0^GuO+4wS zq`*6pJ$j8v$L_CIIq*r1%dgvqyPM~|t5-M&s>H#EHButfILSv8?l@L++?5@{ME~?@ zIG4}@;YgB=y||;G^6_;G&iXap-62+r|^GiIU7ILl7%|Q7E zUn15o@TX$?k1Z+O_m@Yf%Eex|8xurD=Ep+vRd>fnBM;^E77a}-hJb!m ziv$s)Bd|DrgNTu+DdR(mS52YGMYWFBqO5Q3P1~u-o$=Phuc`f)z`UgkWU$2H!j@vl zk-~a^Hz_I8q-=wTs0}9v!%Ie+^nnPTyS*?)L?yuerI=Otkuj=lJ34z=j29>DU{C1% zWeb3_a?BK+Sgq1&&!91jk=;ac(ZcAZ32X)fY7s^p-9kr616L@{jY&yjOClK_cEdYV zD?hrzkFq+SuJ^y)-))ySif9#{F3}f;RRB}iN1x`=kIq;W16Djl3Ka0A#n=E}TnGp7 zh3SEsi*Mihn>ED!{?9}I&|j|qldQ!gD3~t>N|)*6--G__1cLZdU<`b*eb^)yU`W_Z z7=vY`p&#nv(1ktl7)(>6(9!=0L;{3g6rAZ270X%O1oYsbV-!?A`lMivYw|bC{UJXA z%r`x~tKk9ku7>+d!Ogr5xj$Uq_vtxofgP@NkbyyXe)Ok;p*d!}KfGGs^_wjACGa$d zid#WeP|wM&%A%N8Qb0tgJO$%)dp_?^ujfxr zyJ#0fB!2=Tecs+3U<(*jCD`|n5g?F5MEfr?0(d|MF&Ga&9(B%_R`*0lS=$u%h-G)qF9Qf89U&96^ta$ZmQ0F2MqQt zN%E;yyKNJ7Pz!$O`+ZRO*#-v(i2sp>|G0+8Hbv9nfOA_ga;(+2tpX|CNrMDCiP3a7 zkdOx{-Q^TAGmG)yi;Oil^#nzk>225pEr~r$d9loaGJ8QoQ}UXbd{u2>)@Uks=n5?@&bP;^VK5bsAUVB);?&)uNYZ59LW7&$N4E$& z`FHk4tU+sV;&bYF_Dk??idmZ@Y zdVg4E7xW5-p~F+U8Im@n(ytmh?7<4MQF&lck^!Smj#~pNkepC8CB#CSO1MOop%$^q zY3cZsm4Q&6vI4F#YjU(qhE#-sOR7#Pb2EFK!wVreZ z6}>s5bL3gA;vQ|GXYNPJ2N$$(@b(*ne9>Kr>CB7Y6DKpV`Zy zWG%AKioWSEM*z3z+r*$Gffz<2M4uGwXSg7XKrm3&tL2?a=Vy4kIg8GPv2+zO;V#r0 zaPs0vndCBI%70LrkANke`3M1WC`@4NOq1j-Go?I2&7v~M34^eMSHp4^|VAQYg_^(6A}Ys<-5EZ_VqlAtG-{JUZ3Bb ztpvw!+j){7*>_2J{i+lx;ZpBMk*1Fyb>f?6J=ozf*)+%`4N$xxvw(+`!T&FAW2 zGPhw(7$;$P*SF!mFu9Z^if=Tv0;)zY>;u5Gzr4HK{(x6H_HY93{^!N*yDdKYu|NC` zmZ$r}f3MWNPW?1N8qB_igT$xLcDv=z3)s{F`RL#OKO}j%p`GIO@(xl_cUO0?DEnJu zQ@ozg7OU@4)X+0JokT zzAiq#29tqfYYN4)esgm~a_6_}&CRRzZhu&O1cN?VIwXfVyGNl0#_{>jgIlUiX*D#n zUza=Uf={6|>{3mz1%8)mq9jMrC=kZbp{e}CVK;6z*DSo?3K>Z58eA&7@i2T)`&j16 z;sMA+mcgNW15UxkJ2)_=^0wf-vvUGxuvPBPwhc^BI^)vkd*#g@FR?KBW95zS(UfaD z>f;F8O?GVB27k*hCtibrc=~kl?zgx9^Itq(Oko#NoZ;xl?K%@`vyro3f@h2+XF&A zA;AhG#Id04dBel(wP}H!xn|Np*q87};!s z2+rzs_Sk~49?pgErl5+32^}sv`|;}GPPYk6=f*w4U6e+6g^i^5gy@*poAtMKa-b|R zBff^XgA-t)YxpG$UUfKNF4tc+ML)&!dJ^#>T;ie3yO{3P_2b9=$#Qx6`0VE7eD(M- zz2O~~(XjZ2m?N)gPPMf3F0*!LHJYwlx!S=?50EbNkhjZ8;2-n&tW)+ zCs)QVphH^20L!-)Y7;@M*6#k7QH$TG1CsT*_6|~M;z`9Exu$lC%#VcR>!@{gnZvl% zrP#1j*4Jf0*`^S}{K8_f%;3l^F?y{nw(Z#Uwn%W~np@M1!XWo%%pOAsZ3g&BX4(!v z2Bs`M1_-`P9H64BJd)uW=Dx+HWyEiwhhgoU+91H2!%59N1sa9IQ->*Zhx8kck7gfsWqS(4IC zq*-AhT#%KM!UI`BK8rpp*5NtK7u)UbX1#$cN8{)eQyQwDm1d(-9^0J^fY>t$8%hb$37`nAUQBbg(=q zY?s@?mm=Jp9uG=aR@nvVy>l2)L*9vJcU9F_9TS=;FE;_cyuYTbEP9lE9+KWE)C?%Kt>ruow-}?y7mJV8P_w0QT z!PxgsdhjiV_zpgFrE{DlD|0m^7fa8R$h`D zH=KADnP{=y*m1hyhk*Mat027g3WYv>efW00S+3)3jf4s25~$0Xm8y=eiC7I~VHlqK zzmjq2zspskt$;*O8>Ld9%?3aOXChRCeBr=UkhcN8h`tN(g&*bW!FAk=-EO;kv;FcG zo|jE;X-+x~FG6T34*k|r9J($o?mW+EqdPArSCCR3Q>tcfHTf#iuong=#Tf$&Ua;E% zr)|{)Av3TEQb~C~@RIK$9oV#wiz8Pz zpO(T#TzO%s&lQzc_*_|jVb7JsM}5+#=Gk)47^-rhsaOtdP!~SG?#&ukIe>XQ0uhXri6rob1`1b*+FSpP943%i2cdFh3do6!i7>i?(3VutnFRbp*^so^ zK;S6dg;80vsX#^ZCWP@#zd){ix#L_?3zZIsAlCwT!P7r_d~_-rt!zMRKIQ3f8q5&aKiT6{k!F6 z8%K$`HlN{Rzzpsi9`(q-SDFP+r~JOYfs?&8wZM}orX)S|ME|T1M_=|I{rbz-Bx{w^ zbLxL88V-qcihxpy(MMAj(DMT@D;da|P^HnBkTr{(_@hk0jMBI?Yw`j~y~T@R$Rr8w zSg$y&re^Vzm9JdbAIVl&0uA%3ei1ZaO3RQ~;@V1Rpee|auZ0GPUX0p;C>FZ1CW;Fe zmPLuA?83-xYf72giO0ZE2=DLp+qR_`P+_G&%n0cgy z2lO+;qtMfNX}QW2vdRIrxAPxlN+yhzBh)>fLuF<*)R9AcujfCB)H+y9{~vXycet2t zDGoi}QXINFEnevBq^Mj+T2CjXZ7(NZMH+TJofKF1Z-SHA*j05>-uGY%Jy z2MzvzVyar$j44?W74_mPsv>F=s|iHMS- zCL%zLornk_f+ChT=PRIvajgYCG>n$6fB}`oULg#vuH0WbJYJ#u_xt_teQ&SKa(=wb z60gp6km#;H8G^Ut0tAJ8f7`+f-y4mAH>!HgOj;AXZnrx0H=^3g4LidN=3i_@0&LDx zPHqOtPdSZvk2_RkRT|VZHmT-wNiEYjRFb8p5l{1{wA8{@mQt!(X{AjmjvZbNoJe}p zQl_IdIAtny7YJRI*x%hjmezK2aZ|BIHG(jRQ-U^p;I50B&yoUHXS0(h=c`%2JbQF{ zLT@MLREnmcEEJt1{ywp0bf_4Ke4QW(-8ldEyX|JV-@n@R|NGEyRzIgTI9>shQCwo^ zE&V!0ZnTge_Wi@ncDLN550z$fLAg69c`77UHuDu?*tr3*%fmzk#(qxd-C%3R-=?%B zMmPg%A0ZWYnhMZ+qC@8p!Bl4aI6-KN4JSfRZEA`eGc-BTf!74-(M7#n9zLYO>_)}K z_}?+efHqk&ZsUROhPer@%1iD`HpQp3K)^G;V(}*4t7&YKj^3%TwK1C?lV$BpK+6)% zH%8zXHP>E#wKQD-8|bnUxJ{JFbgdeG?&G|VR!_vL;bbyKC6G*m8ba~uYDhePi5enh zuZGiP9n=tsj#9&k0t{-15(H{EjqZ$+RN#I2Z}1xK{&M@UTZu1bH=2VP&TWe_X?c}D zI~AeMeJ)JT-Ix)3_Unj+1r7@GvDEp(PWo`kvA@l;foO5By{#K+IROn)302LL1{!D{v8L6u zgSLjN$#JthC*fwd`@ngzk zk1J{yQhZ3h?F6H)f%qZq4=cjY_RxWjoCp4*hR+T@<}KPUTZ>dJ;GGAySqJ0b@1aOfjOD#0^G%LP z!dn%pW0w6!s!MYKW>w+s^gkd`00)?j_nfBbNPSKYJpR8WOl!{ z(L^WcSYuIgi;hK~bCiBb4~TA*H>dtADQ8bzv`e&wb^4ey_1Vr~o=zH@nV7@9qn-bxqdX`M1X{PN_2K6@#TkY6iW8y7DNaa2SM@+~ zLU5!w;SV~hq2h$-V<=8YPbW>JI3YYyobV?V7%D}@ZVNjb^gzWDyKNK>x-G)}qHc?LDC=apEkgdk z=(dQVR#a$yjE{fX(o>7CAX`j}gbqlM;T==CNA10W6Ht{QesfqJ9`=2l9a{o}zyesA zV%P`ZEYO0nnB)Vxd<4I{s7M$r8ElccGBHrbgY1{}oIn|m7A$)iAq#-Wc(h}P zPctkhZO4l2DDi~S1uBMCrhpA*D5N6K2FpkVu5KUq^YiQZ{QU9q@%i~JJjpVuj~jN5 zMX{s(;=?#OaFh7c_Q%+k!{m5`QySb+t?iNa2ZrvWiK!t%oi#f@sU2@uK*@0GhCtFH zN%T;DWFQY2CX~i(11RgcQ4D*>|tU{8)BJ3+-#DkB;hBiH{EGCr!(byX5Q0 zSiXwY*obtsg{DRDRkE|q)Ec~3ar$MgG$CYP?Sb*p`YP$sf%=Bl7MCC1vd+zQMhQ(? z@(RBM)-^pS3iCxex6$$3%;60~;3-0+Z*Egai-W&~lSBGhrec!M)AEejzsgto-nyr7 zWS1CsvF%-ISLqr_jy1e`U%5{uYiEAfR7gokOhMs-$+Y%uNl1%@XxG{#3(S-NY!ys2 zC56tEOhf^~4gFFLEU9?7&208~+8Hn)%*aiD5Qju}>h5E?1P`kJJd4&aG1m?+h%@(q zXbQuch$-wd#OKkE&L|Zx&Ep|b+=VYK##s2`LOg{pOv}+%yXCh&J&!1r2dnAIhZj+G ze0e&k1rN-@fq}pJ)dTK&Vx%+bG7$=_7-$q4<+;+i#+Up1W}Y1$U(A3Sj&wQW^2di= zf3sd;HIp!`ASi}>K8}EamfL-YI%e7r2~ zzKEn^Q4pO+c690zUK07d-b2%W*ln*h8rIR_${2P_hbyCRfh7`DmGtfRuYG^_e)AFU zXj4mo`j!DnhV-jK3e>?j{jIfO`CW#E#^Ydu-Rn+_8ASS_4HQqd$80&c&K`0|rETP( zDm%#m=^~(4%T@n=w}#tDC~=~sZafVb_>*aX@}xAJ8K5JHx55!l(Jb(ya%|$`a<}oR z&3cb_bjBhTzF>Gb$?UyEDV5v`&FvA*q&?6-Zfc5|O{z{g7EBZ?H)eDsG_upn^){rr z^%!LG{zYkyuSs;mni2TjL}i*$ng~Os+3LtV3;;)6{UM18J}~|Ou*Wt z@dT_Uc>>4RA$njos^wJeF^|VaBpdanGg%4|iC?ENolPx?*tK>wp1BPPj4(g6?K+u8 zqA|b5@N{_IFco#O-uNlZsXGeas5-$E7E<|j+7nJ;A;(q)!hBR}(TcCl&42XliU$`~ zS1cIsenEG2@w2bF**qR}A;h=x$22Q)^2Z8r3Iap~S|z}}TdcwJyY=SZquKzsZ(|Cr zGSI>mmpbExz||ME!$4w;6qgU1FL!W(QNJJ66evYPqE!mii1(}29lR-cGfD>3h=@R| z1T!$_7+?H3iakD4I022_=z0Hw86RIm3>Zvw7P~nH;0Jn*2D^Ji8?gia*O}_>)I>%H zUadx&-t5^1m2D;fn(=ND0qDDkz%S4b96d3QsVZXL5DM$vswMUvp^(HcR228DP{^*( z)h=p7@h_YPhJX%ifI*5x5aIEmL}=u=sJwLc^eMO)qaaX%<1hZGAZ6l>F^t&-i-q?a zU@;Ea3EN-ts@v^@6|Xp`z$+ITl+axIf!&0Ob|s!Z9XeCLMJAFcZb_Bot!I+nv8)L8LHR=IVZ0slv65wGy_l!&a`P+qH{{yYc4&>aq622sHCb{8=#uanVQ) zn-NMKV8&aRM&WScM;|lbSF%q@Sw)R#375dEg-X8GiP@!Gg45fm1gKzWqmc>F_iyq& zAee5FLOVx#MrjbSPKEP8R8}TSuVF=HZPP~IWW0GCD=N&i=2fyM<86KfL@p|m@63EL z-63uof>d%HQiRr=3)YaiZzig4g9)tXH$;>Lfhy*?NuEYCyjZlE-o-*|Zb@o3o1wFB ztVK=Z2VV45)^B)qWg#mpY|drn zq^-EDAiwdJ)*5V*6C2HurxF?>S3qt&+8J=gtod<&$|$oB;L34E$BX05jVp~*c}o*u zAUO)IxG33}xNzCJ1Z4|$#R({kV8*04L}~N}ylXC>BPR%un-B+3@~_#AK-7xG2uc=g zMI;_?ChX>pE9otS`yi?yY-#QBVE(7=4sPZCu*3|VL%)lYO5!0in}eZf#(>d~G0uR@ z-~y;zmNWt2>TjTTcZXMt4tpVdI+Jmn#*TnxB z=t7;+3@@O3vphUot@=9%r60CCNSleK5e*UKpAn(-lkD?&@!sFw0-uTE4MZaG{O30D zFk<^^XA-quZ2Q~W^$JrtM#y*yRTC(Yp!{#`(#HMqYJCURpl{W`8A>Zqikj7El;bj9 zTGKs_POEx`(k7H5Y2)9Tq@Ck9V)|&L$a6e|R3azogyYvFJQ;yc+r#qi`NQhpc=y6O zeH=+?1acxIX!f~DJY4p_>{rY9MTxpZxLIp(Bn17li80yex68ji_CP6~GV9zs+-?}a zB!d65NesMSeN>mABQ*{PqFZ1TXMYE-<^?7{xpQuCpa0?w+^+g~v2b&CTh#(aaj-q& zi!2}6^IyRe0#VwPqDSabe_O9G5U+rm;}aH}N8pFEa*wzMf=dgap<2bYneL-{kn*uV zgQJJnLxqb%MP1SMIB0k~vjU1v4fv$wXO0>$1DKo||7W08skaK!a$Y4a_GF2@whCyO z-y_;~VBA<}X6YxH+9~Y0@uq+qI%Ea^*DMZR#?ACKw7^F1)7=Dx~%rVjdn>?<$vxdjF~a zcHi&d%Bfvn?YbFWRMiH64r~KJH|Bs^XJ!bo%H~#wti0{m?7K|I+~kk}+6HF^m-*Q< z(;32dc=n4(3y)q>#HruajV&I%)E9>C))$7ZjtkeiIVvqzk9I7hvbKApZ!+HOSVo20 zx;28zeC+O1RN8lE^i`(O!L!Ogcia7H3l}zpD~)8%#MDAvLFhtVLFm4rV6E$XNx3SN z(dWzAF7toOIFrif3$}HYhspG9{+=)CyU2f$u@L|FrHUtQ%sP5@` z8yg6Sge2O$ngnHgKFr^~zpM*YKmjNm1n7SA-n1o=b!25_y9qZNSfU2v>|MZ-%r1-} z86Ro9#5P7hHSIq_@?eCMcZs?a79{s6_sW<}>zoE9{;~k5Bg%`D*N9o;>ttnH*%3XX zR5STh4^V&>0OG%t9 zid=PS2WDWlQ&OrgKX(l_^Q=9xB$c&srmV8I&X88tw%OITGMW=N7R9;ri*NfPooa1a zCt`&;ib`!+dpcCw%IJrs%eXpkMW z6O#pwF}xW%ktm{LUq3H(A_3$jh25tY1x{r5v|S?uB9g%(@|xOxDp}V=&L#Pa`v|nv zvP6NY7T8fkTWz+tvys!^|C!__nYF8onGzkHm`b9L8*fQ;a$zxvE_7A)dk)f)&4Icy z%|XS#mo5;LhfC5sF{1l{NGyQexBYHb-^iPf-?9B}(X!lXMdghx?$*lS6T9`#a=TTg zIdJ>W#&-)N*4wRrmffv??sB(E;FEl~zo!c3HAa^Fyp@Rkd_)_b|L$>O>K`nZ*NcNt*HG3(-*0tuu$vS$Xd-6Jd5u|x{k zD%We}2ifF{0F)2G>NZ@UKn{E5z+lOV(?-TiiPqo&w${qAa%_GpnLu8F0WYIZmOCY* zd8Q{NqkV=GC8ISHSt%}NaLvq~;8dxeI{(W;fJaIh-^Mhr&6f@v$Y0$Vq|87nvFs7?552)2iYTVn=~;* zTJriyq$$pCcBP3jZr&2hb&>$KJ_R>$sV+GRz6pB<=e4NzX1`qKn*ygupEt+OfGMrX zo88KRR45Trizw3EQyp@of(3G`T#(^xW_u+a%#Sk({+ziY{sFNg$LEjmNVKPXV-x%+#Cai%QipM?!MIGNh12GV=C$;z!L| zBnWe-P7A;iGZ)D_1!94iQ|)r3n+BFus(B(up0`udjQ^QQl1RbY{Ip&^uBNkP^fp-I zo%U$GoEesM$ z`!kSIA8SA*=?kOSh=sD6Y$T#HU`xO3iCB)4r3Z+gShMAu?6G*>lckH*^<`UzV&RrS zXkI%%w_?PFyJvUI=k*!=ayUP&CvmFX#ek)Ao=nJqu1G>yX2}3CEiNp5D?nHzNir5z zAXhSaOrB@Oe58i=1z)LSN}Vx;RSBBjr*5 zkj7<{tF>_vNclZ8BvO8-ERmGo%Py1h`>;w+Kdr-Xw8Fzzh9XeZkuh%BaYL2()HvFn z7mb3=L9LrfrRn32YyVS`VtT+oRr)R$0$?E7Lc(gTTuyu<8VmthKj6DlLXW3H>WsdOCI#&U* zNc?0iu0Z}|b#oCw$rafpkO;cBo&tH@WBW4ukm?2zE{dj)>BmSDEW|K~9J}ZeDA`2{ zAWeG5OM(Y$tHW!;RDCQ>{P>zFU9GA4A9RPj6& z1XbKQPXuH@=Pah;Su#M(ky3Hr3J?~_sEmabh^UNSE)puS8oPi>nn-acoS}q?6n~d_ zil|(Wl4k|CPac&Ea&N4Qq1IRTqn~AwMpUo`-Z ztp1oZt3Q({8DBbpM%lzX#BK7^ayDCjc{kle!6IQ1W-W|zPwc&!U1t5N7$}yTeibaj ze@rLQ6TP+Mv|a3FPNNqK=`aRzn4F&HRDIY(Ku)vMW0;9<=JaeRhxsWN>y~`8NQ-xx z*~84L10x6dSMh9pl2)VOA-ulFwvT6FsqH7D+S-}zzU>-BUp2@^V@{S14oc7f50ZPiHssCaUgsA}|K9(O0S5S>`M zGM1M9yciaVh}h@v0)|9{)=NSVe^fkqpXx3H>bMUtW$yw)pX!v``tm9W=|LU9A+7-e zTCH%C^2c`i9Lz#6QT`Z!6HM$e-K+sP&1QV-2;HxX@pADnUC-fj)0gNBUFHC6|FXVy zfR1?3Z_#E9DMpu)c$)d~?RNd_B&7SqgRGs|@v?oRL1fxnj5JL}iY}wf18udjNL9)n zmeocy$4xi_^ZWDKh~@wm*IxqAw9ik@l3_oY>vXc5EL{q0reqHnYl+~_FhcSidekk~ z{z$^&Y#ZeOlw%c@hNsXHN-m(t21>Sfv3?ZPR=Y>O=4KLS%Hp9x^3KQREp+qcoL-&4 zxt|;xJSlNVDXgkYb1)Zcb7k?IB))dCd9pfXSv^_pGwq(N4tC2Yi6bz@#HyInC^@Lk z%o6Rhw~NJtC0b*{=q^3+Y33N>!Ouiysy zllVOI1bAoD1Q){*&TgG%dil*$Oiwh=VtOZ4n4aq7$n;cuSEi>rRAhQ5Hl}xy&Gb&P zH^9R52&HMJmpz7+>7BSRy^{>4$L4ZldKjWS)8n1WF+KEgW_l+X+{L2Rndj=H40{1Y z<(OU;SVc^)EL3Hg9u`uP>7j=+)8o*WV0uLVHl~+-0@6(Hv>emRZ=Pa$qInk6JFUX> zR3}HKr`o$RJ=LKi(>t{>z0+)_cUp?+5lYicFMA9t(>rxxdh~u6f8fbH`)n>ZriUTQ zGdrmFb<9VS0e59Mj7JtBC29g{mym!$L|jJ@jy9dK~%^OpoZ_#`LmJ zK$_{Dm1BDO%~MQIG|yssXH}S<>g34uRC`yZr#e(*dS^DKcb3ic&Pp*oLTQ@mWshNH zdS@<7?<|AqvANus9)>8-^mwOoOb>mWnci7drgv6`=>ej0OfL(pBBoassQIsCo!gk+ zc{bBKFU9l-rD>*@J%*L(ox3o-^9-iP=5k|t7@|DWn;ET(r+h3TnI zj!aLrcV&92Lq(={VPkq1*-Y=E6w@P=rkP&$7*?it;llJTGMFBl%Z=$_i1JL2cPhv9 z(8rnST~uXy7iE|pAS%c7vcM{0dS#(1%k;32l1vXhoS7bnz68@F`nNH?oD+aZReH>L z6RpEwe!C1N0|c5(!r|m=4)g0%%xaZxV1iY;;XX908-;jy0_Mde{Hn8(j6RtxrO!e= zGI|NtlJRZ!m^}O=qnnl0=*v-TCS!o?dBszi8T}NYWPG19u1+ur@eEyw=7=7Ri>E8s z)gYX5T@B(%cXcD6RKH9F9kEx}^4Cc+DyK#E*!*?2oUT;}s>IsF8((<1YsEnT`foB|EwiRialmTG;hv-ug^}avk@G7yZc|*cPT% zz@41u7B}(Plcx#Eb?iP0L&oFA{E6yP}gO~sW}b$O7(Q2u4J!l+G54ma+hdQmix%ONL$X(<*CYja#8jx zXZAEjIggG~?3=rAjiddYiJJ>4afSo(|+ zr8@{yE&WCINSx`Udsy}9B=|~_rTb^kD7Z|zi!#m9U*(LJj7Pi;z7R7x%+q&HKm}%W zhEp$4LWN$ShKydaDkj0JoA37K**G{Q&S39^7nicX%pUQK6~)XLGR-bfC6h65d*qA6 zZT58MHs6ixrpUq$PWGtB8KmJ=B8~iBS)`HQD~mKd^>&vNX?WQ<$R-Uhk2G>d%pncW z!Ze&nBWJoi(jesKP)^RMS)`FGJ2JUOey=Rj$nTX!8vSyl(XT=p{XEjh88L@6`c+9I zXSzJnAmrwd1{;;%R(L4+ezTlXDVJZu8B~eQ@T1{*9$Z0kA74%vlfe-#6tFS4$~laC ziKt(Ec;qWCuCh8x4)0Np=i6YhTujHvvftfAtk{=*d?J}jxZx$g?1NqdiKo}=6{>a) zfhb4{{>Q6v2nYP^<;%e{3Jb8iluC1pN=x?1E3b%^U|?l_Q2&76xeRVEjh)8vHXBr* zj8e$uSdyxMw+Kln z`T<@XVUL|%s$DX^W99isX#F$|XOrQ4Fu3zS5!C9lSKGyA`nU)u2eakk@y8w?nZD+k z(7jc(9@2$|fyX1UN)7>FyJ1J;XcRtDK?(sF|M2*2u(}KGXQBKQ8;0}h{exby;wODD z%^&^Q_&UWOzz?oaZ$dGOGn`mjfypWcSECbOhS+j&ja3Y80GNOLWx1Yc@5k8~M%DQw z;F6ejHDL}&`05NxLQxX1+&s>V|CAViu6QXoaSg6tZlWwfup1I%72GV6;8c?Y zNwy!X7OR&pi7hD+AV|wD1QMTK4M%rB_Wu3TEQlDPeh4?4;8C#9c+2{Idy99ZaIucB zK7S%wo-dz66h_!Y*XwuF4RK?ieUm%|9Bkr&KOX$}^5xyPRmhG2j?xKhI|PqBm%WCU z(q?8{6aEJtNpk8Fh^~F;tt!tSf;(dX0X7{>f?UodPpJVPO>$XsmPQ2kH9mSICg4(2FDIzv_zNV4FE6Ee)@I5-u7|#9tzN;lGlFE3on;PmmI;&gat^3&;jHS;GJ5B_gv5@&W%15p>W=6oh+60{M_h&4KWW^hOl__t4Tlu>l< z`w!FE%qIXpUikjwV(X8;e)T-x4;ReYGkqBTzFFg|>Bhf@Nie(v%Flcs6-KwPwg;!a zAHml%xEb|*7$z9H59>sX8s8BJ1`v<>idf)_gXiURLW}_zI264WfM)Iv&Y=zuL7_mx zh0C1@5QdIHqHBv62kI6h3qqs8!QVKrrwnV0;ms2uz4PIPx;w;FcOJ9MMp3`-``ZOY zY;b?dgd=1zWWvKck>ARX**G*1Kvn~Z5k#99aDw#UZyMn#xLn{y#sBP^k&3G)A zW-c6iO0y=Ab&Hd6haCgK*Z|OX%Vp6TO2lqvpGK($jH1LDNq^yaBV2R^Gj`1eh#~56 zn)`@Xo8jpyobmDJ;d^)>Z}G*u)%6{t0qrmyEy6E8xeUhvc*4*aZg9aod2}f^1QpRR zB-d#eC=}|uR~iINj^ezWsv-So9ZaLm5U`np8>1ic(Qh$LJOj9d(M5734SXE-#d19l zX8x3(j-(~r7=2)Db z3?Q5i{6Jw{su%rt-xk4qI%ZoYw48phAvO$us&~lmXnq2R20#0KJbT=1)?BI%jz7a= zGQ^b+)-X6GKQ?%DurUwAkG*&V^P7Z-xVasE7~Tzk8)!Yu4u)Ek1veC;+Hf1I!h-EmLBk;_TuOofT-S#AV1=&kNnt;$IgF*igq$3VO=m(35KPHcS5#d}; zIFSx+CUbDz3s9+Lm{&?5zI>TF1j5%pS#EJBLhN`GOV^vPD;(bb!6YtZ)6%8`@26$X(KM5^>(SDa{+hV|v&&mz7rP7~uz1cMJ3$(+E?A zAUM^oN&Sh>(at*MMv9|tV;U3EegxBi#!m{beoo~vl_yD#C>3WbySOPBv|ltTKdE9E zhEoArqYR2&He(VBevl}5Lr2_1fr56YtSWc#82c53(kQCI_)HwJt>7pkGTto_?+zm+ znKwv;lu~}UrC`-ralAe9H*w%>d^1he7A`2qNglUMmc>Su42T_;A_kP6LQa;W$sD?C zGB>f2AXEZ&&^Q*){n1%`%wCnE>awbtF!4Pb_e;Zw5Lm$tPYm_TP@!6Z*QSVBkeUmy z;$3Y(EV#BEr;K$7loA)W9*x4TmZQ?f%Ce804PxRJoXpvJiw@#$7f{xY$+lw3oc+rb zUT#>llcpdkAu9~8-J&5!1G2$NJID>GGqS@JtOgh0hEywX+jv2tQI^^R5GFZ7$fd*G zAzZrCN9URj^o|S;bIFR2(aGdI~^9OSO2)PM=GRHknOD`D;jXHBm> zWia;53By(MD}#Zgzoksy2C(-hqk|&OklucZx`oFHjDb>sgs+#JPr~7jmpAd0+BZMg zeq|1!0sP4m{#l{5oSy9%v%$HA*_i2t37_HQU>*)JXuf4phB`W?EO9Q+eSyIW*h(^O zhAi@MiXs1ltMyP?7)e}_oFm%0@R=3{SI3_ZZPhe9>31Lb3VAq>bkkGS1&_|0d*JTa z^T`cQC%U2={(C#(c`k)R+%6{k!4^A??n=0NELBe3#ZU(y+|o~pN&YciT}TVrW|I}k zlC<`m(lT%86!N8UN4CX^%hkiaL%p)xesSw0)5>gU4-(r@WS9QW-jZruHSozM|@90LpNVL?i7DJ_Y|Yb5Xe-m~Z@BZ9+M z%}Y5g<*jQew(x^=#Hy$<7Jeqy5eKCuW626)J#bf^T&N!0QH&Jk4cDStD&wRAHsZC- zr$acsQ!8O{6_(hNJGvGhcqfzT!viWC;4y6;=Y}nYGa8!8l2xl(uK%~VXipjrg;G@P zRv(j_0!{=J`U~IV#*>HpesN6Icf+(wz>@TF!U1@Eu2qLp^hb+Pfp0v&pDz3RDsWBS zPO9Op@Ia?KHo!@BYXqts3?l3-wdZr@a223sN;S1IM4^=;yd>%>NQS~Q)dY{>N(5cV zB4vSM(-0T}ic8~5So-mu7Hn}udcxreGSmB(##33mvi5N}O{wlY;s%&SXl4v__2qsa ziv|Bvi(TG-LNqX-8o7oGB5_cuXZ7$u<|}J&!yrCm}D`jX;bdEqXO6Cbh3p`>%Z` zBj#{^Qw+;o1BaYKbh!z6OkRd0HG|RVA+-dQHkpDkW;NQkS&XC#7&U=N#qM5@z?1bo z_R0hwGj~p5{IP*5sd82bMrL8ugXd&CGIrR?v`q9OWD)d9yIjbyw5>BhFCaID$G5LP z-XNzrT*C^OQo*PQ2Z1F>czr0>)3Fa*V7ho5jsdnuLFY0SdprPuW4NlJFviC!I$j0S z_3+b_zD48^ucC6%z%=*wy=cCow2Vz}{1lEqZ?<#)A(+m>3Bt&?R2EJC8QgC-y@z%9 z#};bsw_dbep{NJ47O4Q!E6*@J2--MYnFR_{^e?>B!GuC>spbU>2Q~*eEIo))HrZ(7 z`R1`V4i=l<2Kn;%rFXx5@TtB-FQoEf_;ceU{yzHFLnb~Hmub`kG;Ea{!ohUX`~2M7 zJT1TY^XX=T9qNs@YpC&&zd%v8O>c&jct6@efmvYb=FERp3PW9``H@}Oo$1^n-v84rFicAWyIlk*%%6V-t0n#abbo7=!* z($*CqK*ZYHVMzmXy!jHWup2 zF($D2%_U1Ta|G2pobYT68~}Ld1#!AA^n4zCWrr1s6GrL_*B#w3OBZ1>uwNw7mF<_`U1JVJ)>jdz>)=xhUa4po1- zARZkB(*?Lc3nXTzn7mgw>m-^mtWt7>=;CNrpO(WqyT8Isrwhr%+gvUD>@Rb{fGb4R36V_0{dIp-v7B!c& z{jEF}Rgx=`;<_tZ&mYT>QWSN`BvcKg#bV1U{%h_hXD5_}$~5GLXoN|nd^~a8 z0WygbCx@e{>5+&pj?3_qegr|FVDe0ud#F=O9y)wIgBCgb#7szX+4Vh~Q!HEB;lCJ$-y?5Jt<8^?*DF zj9RHnxVh?_fW&C^1|uCwRn@Esm@!s8uyAoK>ZTxJdq})apV{lT^(s)%CibBDyfscZ7+)K)w%!($e=&ncR1kCx+ z=18|dk1ZsOj<6#S@krXKB;rbV;7(8Tta|BB~M*FAmDrcAQ_i3 z-xRZo6&BpX?#!@b$q|Bi;>`fK;qxHb9T=p=3NZLKB!G#TAi>92UlV#9onr3HKW8ql zdK*eag$iV-47)Q#F`D7HxyOC-Bx@!Dz(PuraKWq8w-uyf8VZsrmOaYS`Xn3;fU#X6 z(ADo683q)cAcOn=I2qU6-g6jeI2dy!L+a3qUW2?QT>4P;C?_s*UK6Bvpn3qEuBEGD zjR+D%^e7!J;liz^-iVuqmSC(S+c~8507Z>+`D97W?QL$P6BZ7nG{rh6N_#q?=JNEb zklLn_3{Gi6k|GFNh*C~E zWqO{j<4SF@=5pBBeaG^-<*U`bpfiLgG~V?vchk5oOU=a=PS&`XxCqxEw0~3-9M~{X>T+D=la!iAl z=MszOnA$Vw>YoLadq`3Vu>(UcEN(g%bY`*|Dh*|ummwEmS!BAe%UjgL2~h! z{K9tpbr}^9R|YuJ1%v`sn>EBCdF3Dwe2?Py3>bd2Gep-&XX(=^N=i8Tuz4Jqc}K@8 zAt8}>#M*M7CwtI`VBry$Osj~i13=q&ae#qECZNph(fT)>bVPGi$u*J?HJEP1K`EDI z#K4fg9H2IHlO;}bLvams>+#Awd7@HZOXfu?*4do5TA~rd#2^uWEC{j$;JTBoOu7-< zywX`lvKQo$o?OJ&!q1Cqst)g?1#{mbMj6s!kl%{9&OMDGLGWW5cFIp=_oN!gLy}s&V)?P<$qo$@Z(}S|EvD^`5j+b#UuAG{V*5Y$1p>buSl(_clBUwsL2)XemSO z%(CmnRL)Iu=Ys}~?P~kY+@T%rjXBXSx2I;FlKTdk6YX+I)w7k{SHtdVwaf+{4&jgx zRbq-dIZNQGT9k}61TA5OYS}U_&Er%Vr`9UQ*|D`#{u0CGAkL6+8M{&z6E~=sotk?^ zm_RA)y~_DZd~MpMR4127JB_vB za874>V@+pjO5LiT(bO0uWs{nknwZQ(nb(vXzUt2N^HZCe0z92p1XaeOmsiYga$jy5 z5Yh{5kYwl!QpPoNs`PMBTWT5b-wsL)K)ON+cSdr;1`JB4))U#>x7sb)$$dOMNvS?` z`e?P68Ye5&2P__|HdsyPKIvZO`U`c2u7doRfiX2n*da^Foqih~%q8oo1ZY%YIX{KU zeK7rMCOg5yeLNX5(~!U|laSPy_$`rjg*iv`9$seLqdVqGB=|J7(&Us@1FhM~l-XOG zUnYUiF<2VkC7u)Yx}l9PPK$DyA=AZUS7} zxD9~ol1Jp2jLj7i5w9bId=m-Y1z|i~Q)mKRF6*kG$|P4;VTk6|=$a7ae%fGjT<52P zx{sAgi^6j>)zYGNGiQFzP>DIynM!S}wA8Fktrapjnf$_Qky*1}_|xQ8heDGnQYPQ2 zni)l-*yH~dD|3!%tD6VaG%StiucZ>73bwuhb-GUO6ZAz}Dp3nSvyc`e#n3hVsWX^W zT2k)SOH)>anyq{i6hAdgA{%)z1-Va*(+^ns6Hgg{`azeaak=lr{SGzdFM+5wjuE(3 z5}!0)5X0m&pWtS-)0_wb;%JnR(ZwO^d?Pu!7VPeOv+ldWlDD)R?1AT9q*n&^_&y8 zhEDmapqT+Vs>_b}fv%lA**+S|pQOtskX0+MvkNShIfV5wBo8F~=bA61{dKcon!LOe zky?t{P<7?G_IwX_rROG_>|)+a;lpodz2y>inpjNA?C)?%W<~Y-0MDf??gs zJHHmJof4_rfU0cjb{D6O9|Vor=4D_vAYiatS!v~O%Orz01&W!H{?;E2I)EabdCp!Q zt?+baLug3@R5ca8DS+yy(KiH1y%hW=fvAx}baEj7`SsN>_CQ3Q?I-5RFfFtG$Msa&~uuZ}&14 zU4X|`u3TF$71yn3rC-~`*Gp);W6I7xfO0wFuxPBxy_yGV;nj6~Xf>r|J*mz>F^sDl zAg0Fq!i}J29(?shpsU4Skbmdi)d{mY5q1Kq=~vJ^3)!c*fr~fp>xRu#w*E=Q4N0vM z?~P|vz1;D|g|0^Ke5(89awadO`76@(ZZp~C^(6|Q(W?OLy0_wfl-GfYGNr7R&*=nf zQ8u`3P;_9X^VN(i4sAp6;(#tr#Vu5v@=$M!Nx`BWmY3wo5QW!q=^(UXZ<6Dq62*i5 z1D-gE8uki{7j=TPg5pQr!IWD(3DlU3LhA-nr{YU{18s5frhNg`EY@U%aCfrNCOmqi zd?(-(6`$G{pt?s?QSqy8FlB+Nb5td2Wp#h%5&(6MAfsAW_vkUe=^Qx)#mDwVt{8=- zlJ3rZ0kUlIvrc$e3?xN3E6XIiL|Z3NmM*^5HI(~~%yPxwI>DxK#`l#l&6;p~e1c3s z_nAD+nsj@Q(%|cKzMT)UUi;n)`!=`uUi!7WPL4avBFre>w=W>pDgFnogdWIaA+{ju zGvy(biPS@h_R9t?PPH0!yPhhpY`627R6V>FW^yTZ*uX|P7D{YpCag*NRY#SQubdW2wXc@1OH!-CJ%4&3WcJ%ulHm@J z_Dbi3!&ai#y0R651^s*r$ixaz&sl6hizG+F!a7)ItjA%Qe(e>RaaP@ zpY$a1a-6YyN2Rb+5zz9>o*bNvLgbyu6IsZ7UtB2r29GMFz9%>0$%5(ovTt^{I%itR zLh$>8F5M@!KW;zIEZ7cov62qVO54wyY>_OtpTO;lweC6X>mHiw$=%&U5cg+~a~~q; zM7w~``g*iarXj0!Gzp>rdiBqx9zy5@f2qeCa$vSRF3=6k=_e6#p!Vnq0<#YNcL4Ri z;2JiV^Ft6kF?~dJ5p7qJ^`3(0!i_6sgZ|V+i*UqKbyZ|JS&aP>(>8gqh`x-5G~jHyit3>jY~Xo;=tDSK)lp>CI#NK^fM{n$+D|IwDKLV zT0NeU8(_UJer5$N^FnO1D*tpRm>SXBr4-W{=$PV$u|hWPRkOp=mCu7E#WF zHC?C!DkVb8gxI+<5-+r6a#C^IQeDk{ttf_Z=jc$nnSiSO>P&303DvdZ^06{51Sj&B zFqrsw6DS;B%@0ZZ)_KK^tYNx~Hc+bI*P_i_O-a(7_q_vCQi~O=5#RADc!7W4fK7!R>jU#!w)`l5m zn!L>1WnSG$&z&fbOUR%^)lvXtRUDDGI z4EzwW+`vxAeVfHHNE||l7gqQVL!epTw6XLq@lFcHRtlaUt%GT_;oMh!`YMTWu7YX% zZF#dK4HQ<9_3}tRNx|*|n(v47{n2sdvC@xjlzaumzUK6>CExPM7`F0@9QN@ly{nNk zRH@f7k`yNGF~xs>?1`H4$(G`C&LmQlDtLU~|1BKDrOSlvF%61@t`rmM+e>>zK0Q#@#CBjsq5JOumYCM>(SEB#K#Z zC`tg~!Q>LX!-3?It}CFMwMnSD>x|ZQ2r~J`>oABye*+Q;9vKuGy(Eb$b)l0aNok>; zJ~N_AOD08c7ybwp#iFP6@{7L?*}X$J0PfDFizs|t2Q#1fL4rjzyuZ3vx3EnQtS(B6 z2R;GB+f5ilD+1h$dmf|bWEpp)y#nFmeT>G=> zCQ6cxu%-$T#kCeL5l4|r^J}~@z!{xOYhd~`2`giNjzgS^SFz^MOQdd9IIrwfck(!8 z59ek*#{p4!Ux`zA@HcTz`5{d1hQlFNF6P43#ZZ}Q@R^^4a(Hu@mOg5e=^Q{5K~EYC zSV0uIIH{L$uV`wejI?z9yUxV2Fp8$$)f!IJJ!x(@R@S7U;bhg4=7wX?HMJMhuY(yK z%Z9*PUGd?X0&g{I6ukMcS@7o5X2&}wS2O81$y5C*<6JhwfgFTDoUjY^uaI5EtsNTY zB;fk~<6`TNzkYrBGL4cHld6vlcZOUQ=$-AOvr1@YcouGD$>yiy`|xqPP?kdR_~URf zac_P$UYDHU1gdwL8IFxK&qDZPFN&+4db$qT6v7fIoI$lOqYimTo2T`3@!5}-{=+nK zNAUSLSOw#0^v%7Co~G+?-p{c9aQ&=Iu|fnuMsfe2!{BAwvf?J|VDT9GR^Sv-I{3!$Z7amC}eWT&C9CWpL)ca34Hw?lAbpYP)%YZw26& zIR#p`Yj;!Pe6?KhxtxzQuTwQBRHMiu?L+y#9i6xuR4}D*Tq5_eORTi?*mbR|(i6^0 zV2Wp^x+BWb94$L6Lh>9(mbX*R#`TGjGFo_mQC0o}xc>|`ta2R;N?Fx?@|{h>hhRI4 zj6ob%$XG0cpo&c&_jWu3@_3b6BYd*)8iUn}v;|k$>`{?Ai==g6X>4(#zTFyC;oa%B z!~tiMgm5(nH?n)GK27k|cLF@aWVPXhsbB%@DcunsJMM@SVpcXJ}=Q zSuYqbH@#ppUG#8u!vE>_#^H3 zjqfoc{qw;7#RtpPx6Sl%p?<*^;-gtFTt7U}KkTHVE^KSc|iZ+PdF{{kv_;?2MA`(CFG5eE!yxcA(^f&!vU(hf32KdK*(7*VU zez4E_^n0Iuf|V|?r}*!I{=r{iu)hCB)2QF@jr@?l{~84kQMitOqwmFs{QGG6C0I|` zr~Fsmg8x3l-QGNyE+!a4{q_+5%D(?&yQEL>gMEXav)*PL%&R> zmJ)F+@*fZ4Pkg-IF0k+H2lK;qpD7=gsbnE~qk+%vh2HkL;m|pN43Jo#5mzB`%q;h? z#DDKN!cpEMBfp8W_@jBSs#$haJS&Q5Q;NqOLZM_&h>BvQC}9HceJ~c+20ggo4u2>N6f7ZE1Gn3aGU;>$A2tY3x33Z*${0TU%!AL#E)iZl-N*R@0B% z(wXUG(xeN#t+g7C^p++~x#L@!H{sN8YgSm&nq$1BSUG&C8}hBT5EORw#AJ=RO`aVaf4KGww7dzy!mX|f2H4_wx@L^-biV0V(*Z> zHjNPfxq2J0tqp#FSG@xbSJn;YCPaIvR`r2fwq26-cH3UJeg4)&cCxN-`^z`$_qM+K zW}V*lm!Fy+w;%1L*2~Km5&8R{>LskoUaQ)c?OyPctdny2>FC4ek@C$D_ZH5OtmbW^ zAri9i5x?8|#BR3m!9XiU$uAzyvM(MhP2hHMXkHfrdh=qBEyx63J{kN8p&sgDPR4*S zaqHA6;evANW4D`5%!{$&k@7CKihJum|fRai{o_#(ko=kMlIvifM+dNJWJSNdY1xRd>2ptzsSvG35!;+QY)WpS(*cd|Rii~BLhHm@AuOd8~v z{-km9;#s(Zmrvta8fV;M_BIVo`d!R%3Sf3BlHs^_X_50y@K~ zT8v;hORmQQ!=|00yMO|oD8!MMd78l{-d-FeU5@T}xK@Gej*>1$pe;$bEV;y^8MHAb!1YqXiIL9Dx>a`GU;TTJ?B>i?XOi>zEg9%A$OcG)V7+zvJqEU$yj z`pRpcVR+?rVK$end{ul7Q|4CQ*xY8~gFDfk-ob_J-0UmCB1#PyR|6}?iBzy{_6({a zS*e(1^=K#P&fGn?WOC@BB#i(*Y!*xR2cIlHVJX|Qlbq_d-G%Lyt zx*XGtZLFz*<&EiLT9h~uPG(c-@nA8z^Bl(&A?HK)1LfgJ+DY!}iq%BQnTcL}xgxvQnX~dKO(B9SMoF+}5Qj?liPnngP21}_)Q(e=xj?OomGJ5ne zlUHJ&^5~5j73B-#!ze=vpR93T=Z%23edexYDR=N%eUgr=QFJj6K8HTRHe{b8N)J`j zP#ekfyguqiO~J@kKU7T9DMVG#e{WT z4e$KHsqaVMR^i|yqOgZ|xY3dyKmxz@uSY-mJq3uUN~L2vRp^`n`0}L=;46X+CDB=s zBV7>kTsFbs>R|7kB}tLCo2~islcQxBk5a53#cj{!gKOA8HKY6WXFL#}lzL{Er2L*S z?hwx`C;n88I7EV>NIy&&`ShH7A|(+Y4PrnT^1NquA!QeriVGa}#n^LEvnBTo`_ zRpp;!q#PqHc+-3P`Xd$iMS3r^mJ9V42m+O4=y2uNGNU?)PzlGM&FRnt=3#ph^fxSD^ry1t{sIf`b{uo`LI6Uh7+-uc8;D92;D zLiq)H1~1|LV!6A5wOKg_7{{;lo=Go$pGEV6>Fh`dl-$9jZ)_*euz;Ua`tE>X@J_va z(ge6Wco@Wh_SeBIoQI2OQ}5{nlD~#{lmrTkt`4ss3;^wWLM|7UF_n6!56d-W{rkbj zXU{&MUCp`TbH(PtaRLD+r)gkUW1dkDV#tW$C6H5+m)GPu6vG14Tov#fCP;F44!#$= zi3%;Ec#XyYh1$VW{B2B-lo0l9tv5f2aPf4DF_dr`H&iVZ+9voS6zY`5Nh@ehqrCmZ zj|i9$=41DjralQtSWROPr^-d0e4SD!-$0#20C=oU>YTf*B6+bvjd&LBd>ae(C+NLT zsJ3<~jsePZ$X2~68mAHe;(%YGkcvtLp0!QDTTe{=<|Y0=p~#Ua!a(J_;%^edOdn2U z^$4zK41i|Y4;H1!!-TTb>q6$_tgv@_?yTw=#$wppUP4wcmWyz+9Y3LNt$)8pv8fFm z9j*pxGfLkCFjllCqi-eRgm|D$5~M!@`7zDI7?}0|?aTwh-a<(pkk{uv+DfMELhvUk zfJ!R0B^nv4;58tC99QU}r@d9J839`2 zZJ-mp4Rl-=LcPG640oxBxf1UNVW#Bfa1Bd+%KubWjrFB-U8uY`(EnndA*KD7-aKa8 zCurfcI;Jy*t3eKO!~{j0f+A|rtQ7Eh7-vWlrf);aaHZ2$1$j;@rHed~S9DO7%0>2sDZF`VQyy zZO8c01;D#bsip*<0HBH^ROb^}y0FlEv;5n_Y}DNF-0dwsSAYp;IAoDbW-`Q*;6u<} zt2y4}d8@_3P$snI^mwFKu|KM0k<0!nV%$Vwmz*tL>l@B%afBtWwJOj|L_o81$dWon z)mrhG7}Nf$IfHL3YNY1r)r;Demvk3QijhB>WSuL3lmiAnC%n}}Af%?FBCi_FK~74; zn3Ir$ZzwHraW7?a`BX6#q;8`l$mzL= zo}}F@6e{xE-qJPJdwN!V@E-q9HSyKm#k&=5BJlxC==b=YU1U&J#}JiTze<W08~R&39knjLI^okpLt?Yj9DL9i-*P?Gm~utuEUVvK{_H26vbMd_ zJ+9ge-FsSb>~?a`f!l2P!g_=E5o***mO>L^R%bPD9a#;b0_Wm=Dc;+FkS@)vtIwI` z$gjZF8&UD~ZF=LpO;q?-+oszQ(<|%}p&JfWS)wGFlvSb_T*{DJ`@pD#pSz;38mt3; z4dxZEMdmLK4h_HiWo^@eq$dGaB&J?z zK1k4im^hAM>ClT1vV-oQd-v1GC*mG&*Xy2y$-n;=g*Yfg<9{c#;rSP$_2*!-q8DWz zdjFdL;g6%QK5kgp@0%q8I3xaR7|~zL75@`#ZGoCXy={c|f4~%u>6g>TFbWsX16=J_ zI>U0Di!~w)>GiY_@gtQ+QUmZM&6b-`Elzktd*d0_;{)VqI_KYRzzKR+*FXDr!w-Ye z-RloGqu$4B|EJs6AK>SB*ZUW6(<3bO7{2gi)^murhJdh7y-%Cv!t;7_e-*KaSDZr+ zQhtN5f^b3~`oS2n8Jpq9Q{MFAJ$n2W%(mg+N_YD8{VReC%wjtJHs~Y7?vVY*9}NeJ znjcxd3f}z4^hO&nOz+pEQSpi+;^j+)i5Ca@v%@324z`?6$1e^Zg4re%KYpYaftJsq zkH>}(BAFiK$KJnv|4SHr<}9D66MNCuKO5#^T*MYd&;=#XOn3~hV1V|eN2Ou`&$MN?1?>WpTA|1&XAw#1=CXF5FnJ`O(A#HAkjx~*q8X! zl|F7_^N;0C8}L#jg5DapkICr z>Od%?>4;1?uK|Zovm!e`V`j5Bi*ZfH>xch2bW@ z1|0;7+lsB=*<~!KlVq?p&MSfcPO}v3gT!JT(mLCn5 zDvo^kODciYC$LuQD75?K!~9L6|%pG6g5Sw`iQhEV#JaIUT_1& zzgzLeQc|3*cR0Y*z!0Q~CFf^Kio^8uOt{$UP(GdwG&}S>LeEL4`s$q0sXx1Mf~AcU zyaC$ahN1bji4Dq0MPC_YD1$$x@5?6R z*G1Et;A+7p=)Kg-u?7XW;FRkVvVcN9{?YbYRRbw(O4>mZKE}mdz&aIzYYu)Um7V+< zWsh3Z#^u9sCf0a*TICiS2aj^8*iFqdw@KjH-Y(y;E*1-7MLbzgcD4CQG{&jBJ#3 z%Ws=1>6YI-QO+&Dv00fdzpZY#Imn|^ShdrCDHS1qY}MGAqj^W0CtM-fRkUf%7+?z?q+tNl8XU zyf3Iw`d?0m7leLzNFApZ1pwRu^#T(6Ek$7?gCkn^95o#bsc&@47dX z4C4ko2_KmIQMzq&2POYO1^bh)&VF&AV&1Amh?vfo#HG<2bz@-E9jO$Gl9-5lFev{) zD_g=XFJ_}>m&+2Sx^q@z($C9Ip@`gT0AqY15j^D3Rgx7*C~-{HR1v`&+9FxxvG(`Q z7M-eOlLl4PLTr+lnCGbkX5ygpc5os~G}(48Sv#f)nwQ!OsJ^wGC&rO;2ioLz540;| z@d~7Nd6mlHZ0-nZ6JJtIG%UHLiOXD9H;QWGdiMs4=B9F6%T_u@@~XV$BW$^iF9`u+ z_;sJGxL;=VcN!#6E+k$HC8Yx~UJyOdC~Xc5;-u%sZ$__`CSeUAXmax_d^qkp`A zX+pZ!B+5YzzJ4!Am5}Z=Qu`FRP3|BOyv?iEpn?|_5s?wP>YNR`@gv|_E(1vZJoui$ zC{yVLBDIGn88%TrKE85dv63nWlR4%jwuxG75AMo$fvW64!c%BeW83vyvOZf2%UZ3Z z<7?*_#8gwRuI+rP`MkANVJfUjUfQV?;kKg=*i~8Xd1>-6;DUk5dZ6+GYFKLimz?9; z1Pr7mS7o(%oaH4AN^8Ty z1;wfzt&u5o`{K>vHLECX{AUr%u4t(vbw18O-0Mwe=aBF7J?gJhhNbni(Z>p<@$r-l z1q!|Twj+e6S3*{Xg=U$TS3#Rz%bqM{i;QMeZ~GH$im{UKc2js14QDTVKaw6nO_A4OKa9kZK*RB{ zA8_-ERc}t%W9r`tu9GlZ?+^ASELPM6leTR4l0J#P9Dgg2xM!3K4+5fVe%Y7PGoFQk zNCoVEV~-zD$z6G2_d)RP8$c)QAt!~R?zhbIbnlqt5qq$8cEI)lVY4 zzUAw^xw&G7604)aN;lsEFkGY*JZjN32Fn1gp33MPXo^eJE7p7`xGn|u-e4P66w<0f zE$F}(&lp~VzWY2^_$gRSX1LqN+c2+vdu}#NE_z_*Bc&FL!Pa54T`v+T)tz~)CF^Gp z@&yUdeC9-W`4VqJO~-f>2=4(rzM_JqqDzU|rR~Pc3HVfHvIMFr9-;M!ASz5oV(mX@ ze))2TrEEBo_aS|{&k`UF2Er6U$nFaKV=q=jQ7R@&)Iz!oosHk`x>1vMIDXYk=YSLur z^>_xC0x$3ir`2xfxnvWm@+_@OWEIx`CsB9eN;j>eQYc(h8K!Au9-tHw(;gGrTx*9} zY7}%H@Oq7WRb}nZrc_g?$$Rx*+v=qDBl4D4G{OODYyBA&soI)8ak9FYwmn?O@qsOF za6D;y3yp&h5$4n4T8(+zTdo;`))ozSGi&m7(biULyi?lNtf?1I+nPA>c4}+WYOjp8 zcy3K?uC2wU!V%k=7!Rq^BN^?gSD5q~x>mcB(o3y!sV&lzK5ctqK)F?N<2Hqg*8x~^ zBifr4@7?4woar3v}otPn}r}@^R0MvY){fXUL4#nmorg7 zzwLd!CTw&>Q8sTu>rB9vz&YJ?gsGfxTp+CdJrwcFMNFYx!b-+4TSLHGr!N)i-L_ie zxJN1os4dPTQ%lEcE zarA9PMa@3`des}<-3~wg+o@NQZ|_Lgy42gBO*j5xJDZ`4_$}4sf_*W+ z4=G(q{hn$@Baw;18_{p6CNvTc?&FR4@2O_zXcny30fj-!UsH`}tmXZu5K$wn75_ce z%<@p(K&;){2KpI-lZ zb(i?`r`Mx9f&~}@!5sR(gu#S88!)_@9}cdo(8<+3G7u=<^9f^tQe?g7os53ThF4I( zIuwdggCT=I{P5!7A((AK`N*f|-)&bj@?@WT&3 z9)LiNXxYVb5pK5QCzRUr?-73-ZVrBEY^B$pZ6dQJT6tqI60#IuI|0T;B6m93X_Ljrz^&gwB@*rXY6|I@6;}|wRSP%m3OfT ziN8UWo-W3rAFh_;C)l{@4~5p$2jwHB53kANZSJA8ub3hB8++#J>ZA57a^JsNjz8n| zhS_xdZO|VK*u4KHb(Y4{t+N;h$8=POmF!t#L@^uJ_G-cnTDcw_GZRP$8p80J+c}8r zB~d=SksxR&89=kV2p7RU=}`~E-#6=1yaBwJ__+ATZ;NF_zj-IV4|fRT#RwMv91iag z1Au!s51+C;UMBa}TcoI9q#+D9eCv^)Ma%M~N!V9|!3lqj=y|~1Nn~4&e)4++<}2N> zVEcCPw;y|)MPhe_g#F78fBnD5|4+yw2QOcOah7n~!Kx9hD~IhTCTHoBq%4qXVqe+? zmIhZ*aU-s8Q2Oe@-*QJha~bg*jV8-2_DKTg|M!)5x(F6ac?#i`is0l*e8NxQnb7tx zqNQ}hF^AA7vV8LiBI#khoLjf{6o5D^>IBUS3|rtn8_nLK9N_yVp}mljTFL389ETTV z;9uLLi72alZ^S$U6#sx1?FCL*=B>=N4;GK1$lM>ImNy|T#k~=2;BSI?$UVbMA!NKd z!Ei@cKK|E(k!KnF6=y2!VAW7f!L@xnzbQnEAH7OJCMMG6Nag3__>x5a5i;QAOC~gg z0oAo$1TTt0-VhY?8cyGzeLSoCdNx~*S#fpv=O6@aPcUKYGV02YuKnvf|Mretnri%p zHbj|j;til88(7LcZGVcHtuDRg0M*m^FoH3llEp6hc{`HaNcxZWcweZI{59ezi$~t7 z5M^#86^J%Xnqsp5P^iZ};W5qa6@}s!qH~6+v&Qj^ljk7o*$q%yZ;5vx;Ko@0<*!YV z*S?%qsv|UBhqxkPf@1id2@uGOj7Lb`tq31xrv`BnyX}kkJI~v1^oHVXpNb9*h`01K zhkl`OQlK>E^VT78ay$NbAdL&AEY|d1WBT`m3FiD7h%Ntb;QI7ox&9KYCq8Z!8C=8n zRqlgG8<8Ng(ec5B-%AeejQFk@3e$~|4>f~h-PfwOu+s$B#A+Ij!!K}i^7sG9IpIe! z3MknI7`XC>?{V<*RJ9_hs7|K^7~_=M03s8gojON~!##u10Ro4cDk$WI8~!N#%B~G# z2jU6)kp2DP_3!>~*H^!O81z02KgwT0yI%hn&=+Vd{D>{fHm)cFt(IWi9FEB~luUCf#m*R-$2qu#?3ivRV*y3!Lq)%aSyIfn$@8>s{ z?0$5Yvw4S;PzjhDDPVTGd3x5jK^R;y{jMmTq)<%ROd6M6h1B-4Wi7i-Vhn|{b!+kz zA@dPc*s9thNO^~Pl0nI&D%~J-QmRWkQ_kkWSKMCzi^YL*-mt?Z9-VE%8RFIb<$_F} zD3~q~mp)#u=)J@RV#DcrcDbOKRKSwdM>%1tPs`HjK8Rgm3uz4TSRB8`bZ!zaz}^6E z{Sl0X7~QLHgjZf~uoVCf0RT2y1nHq>GtZ!IW9~jJezjh%f=6;;F>(Wu1sjSr;z2vz zfT0B&v?_STwXwfq|FqJ&>&z(C_1k*~6WeJi)P z2E#Duh6WN4)(0~~Ju2Z1c9pE-OdPE5L3Gk(6??Kp+4w@cX)-qCdj~3`+;Vew-6ar& zTRgsNB(C{hb+lCslGPS>y99|XNCi~J)xK^pbplLHLb$k=-}V+pdPHXer^&to$exBl zbbq&8!GxkqdY^?4(R{h-7$5BDnV@uq6!r?#^zmsQuwsFwBec*So$n#d znc(do*>U)SuX~L?3EuvpuTKdSJopyDxsgbUL@qyte92-s>cCWb97{#gKnE+KhOxJn zHOP2H%6$NgZcjA8w19brx7;9is4Eh$L=3i+#@Y@#>EhVg1S?_5?P>w5mGsf<20<8q zDz4UcvH|n?ZsEuHfM4FIwf9K)4z8hS8$hQy_3&#S2i&0`M~uR@{BfW;A$B>Zb_91h zO?(h{I*U4vJDx=x%3aP9AI%-lq8(69d*A&r?a2P`lRqXYZewL2mv?B=wj=00(yv51 zxpMg{eJZwiQSo5^E(4HRqJW<*zaRuQZwY${Kl!f&@;SvMR*{T(>DHM<4tt6*rtnw! zn1&*iHdSvraYz_P;pY9@Q+A;EHr_9{aFAwzNFOWY#pg^@zSXyFqBadaY3UX^WX?_n zVtN5x@-zK)gzpgj2Ke6>`g!ODXAXc|(MOvkoOl4IBPbHjDR+Vi9fpq35Wjic6*xQ|SPhEGy)%E~{6Z3KA zZqUH84LiMl*AsYI5@|<>;MMCpHAzsDMc5>Mu>FeA%pCVkw^m$9NY!(Vo$PJ$iOs#m zY7$WE#Xz?kuO0^N^x72kL_bkARTo>%^A0Yt)|-?MTCt?_6@?=}MX34=B{r zo1LDdY8$Ve|=AdC8rPc`f7LfA$-!;-QHI*lZ#a>nFLV)raSN{ zGzrgsgpccB#)ChCMKru;6=6HXRT)U}=3tkQ(#5r21!kYIS_;-~@d|tFgTD^7kN^>L zi9-~DJU${X(C4pp_div_%m;JhZ2reJvTWqQ^u)|v6lr9X7^xlEKAyqW;RR-QGx#MNT~$T-4tJD{bm4Rp zTGD?sM?AareQ&8ae=hGrl|QO>ZR@+!q)8|cQ#hsPGw=`xN++-J;4GCks?B$fjnIgl zOreL??P?h!axICV@081tPFDG0Y4S8g$8@0B6H@wvD)be-?<4A&^V-O}pXypvVcz{r z_Cta<`ot01DN-}4WbJg$#Mx?Xt{rb>9Eb{rvC~DxGwpbyIJA{>^PR5Bm~6)jGh+;Q zx~vwbIvtzki*~!Nv0ff%r&FDc*DWsW1n)U&g^zZ+vP7WiPUkYUrkzfe3LM?(Y}2nW zL*<(syPk<28{`g;ozBz`BDJVpixYjW9rIn~ugP_l3EihHSXv?;SVC0dB*VRnXFsgv za)AqZ54%%>lh74yjNOO1FVORcTmF0jPxs5^OguH$3Kd+7_iuK51Y@GJ8S(9~ff$CI zP-TFk-UMn5C;9NSv_&GSyofEdAQF?2<<=1Vc4$V0+P9*0IBtQ8f!ZmDkWW>%;)l`W z;&-hDCDMv_J)L*RiWMR@Y_7`N>~`ZGrm$+HuCwdq$v}R7Kz2Qw3fOPuJSIco+gYQ1 z)*TC@WT1UpOEm-PTiR7K6uPaYre>W7s~uexHg}`^pBpd=j!IqCsgNo8zLD4eC0I|s z1ncl49vwf$gC)EyKmUc4CbPx)ipm@t%dq>3Bl5uQr<}R09w0XCYMtPkdtQM6>Cg_*~j2=}!Ga z1m!B94);A~PuU|bc2?{kmrETY&B%5lKNurW^XcKz>o-N0p{l_g%K2Z{d z-Nc{Z`uk+Qjl!?uKGXAi@t2(Mv#*7ORP?C`)+6@Uf3I27&}Z@91}pz1%@Z^NwO^t<{QFmoO-nm z9}QU5L0qfS8{%@2|6EQ>FmL0wL9}Rn2>agW6+tch)Y{uF`39-E+z;8@-o%PA8N$7}|~+ zt?o%R!mO<{*c^3q!whuHzj4Mqy#%gdUa$~>{rzAhyhiN;>L~Gw8ocDWkeN`$b~Q^Y z{6xFA%;iKc4i1HRa7msNN~f|I}P3x4~aSlHk_{(k@?L-FEwt290Qh)pK3g4p&7$6-ykxN~nEok+hUO5uh1#Pr?;S z40a+}!qR$kOa88&NQgaT=bN>$YPJPx+M zfr~So_^W6=l)U1C)cD_m*)|+peblzT?_ZJ2W3`-3$KM8hrpiFWJC@edVg6X8`Jj29 zHP_8&{<(5=94ny4D7_sGU0~pY#;{)D1!W&kV$b2!2qqKe5)Gp9)8J-`ClhSn5C_ou z6KdlAgPY$H{gTbmHE!;2;6<6Cu6d%9_#Az&JY0G%w-flZ=x%VnTuk8&nZnz1GbW|E z@*SbvL++PQ(e}``jA(o0`!lA}OF#k8yfgI~o-#3D`vmw#5tjNKuq2PTw`@shsg?O* z!Vi)e-o8HdFUPkxV^&pT03(2@iMyES1QWp+u}swTe$Z3k6bL3HJ0^umfK!U2K#U`q zEW*rK(8Yz1f26mfQLW(iHB3C9S&$w91R6;sYg_=tBy!*=l!P3Gl88Yk|I&yfB(k!# zBZB%D(Tvw0eF+|M8b%SUM_@sCwe?S>uTx>I8GY#X^>L+zH&5pm1jjUq;2q6#GkRkq z^oEJ*tfeKLW1dM0bKEQLZ8&N9)73b3h-)AAK3N33D>_o-fb1=sifcmvr3LO-%X(6w7pg@ykrn~T;udd&`zJdha-upveAnCux zRJ!o{*j`PaSq=Fz|3KHzTS(f`E$-LTI-^`gxx!bcBl+;{oYNpA%N z;|k|_)|)IzHqvL0xYSwVdULv9zuu#m-S~<9N@8ak^(H|G$;j@^;J%|fv1lEJs24N| zXTaOTJc74?gy-M4(R4;ouGZsd*4upBjNuUNZN^VfZE)kme%a2#wfG3oVB+YT{4)TU zaqHj#K{WKO@83_O4SvvFAqDoqFa~Al-l55 z5K@R~@Xv%ko8VS!iEr?)kEQy!4#vOha6AhaJv6}89kI|&NR6oz5dRt1#Tc^pIFF{l z>$*4pOyAyK4L=O;{I@s1%3psP4gY%}|9JQM?zQ}Vbocu0rTpXV^(`zPUv$46jpP>} zuYVd|X#3`qDzv&0twh=vi zO@B>sd%Fok!X*D_hz~~mgWkJ4|JRR~AFu!Mk$(MY_|rB0eEZ8S{dhNIKi*tj(qFfO zpXtZdNA}l<@PI%6@ylJ0U#>k&XCV#?tGFV(lG+`cEX0C^iiYg|mmHoeMxOZP9ws&@ zReZspv^(A|rVq>Y9CXBP{=v!aaT=D3;e6m7#_hd;%T)5nI`_FppRDn@s+T*~32+~Z z3+TdmUEw2`z^IGHJ7G)bZ3~txn%=^}a_H+g1C9~a@|UfVO5Bk}9g^Z~&a^eJ&B&Z)jG*PKs9C~eOIEBtLQ z{(YkTzR`Za*M5(*-^beTvz}5)10pYfzMVzW)oco;Itd>F{6(h-C+dU$wKu01G8PNO zFu?DRcQSCWz~*rV$vo&EWqduHU(JvDgRA*z{}}%sU7XRs9{%Z{oSq$@ADwz9_yge; zSM%fk#qq`IS^t7Qp?3Y#qtlE2`RVZ?HK9+B5BvSIqr8eCSpb z)202@^M93$$oIcwomi6>y*N1Pzc|3@#4i_T_{V#35FgDK2Oj>859W&lG>MNTzCOX% z>QLhEbNWvnNocjda#?l@V3+fc+xdOC{yALmXLiIk=gF?|3?}t{9Oc1aehZbrB2u8h zt>G$K|K+b-+t1*IZ6cm->!IL|!@?-zhPFERE)5$7XJws@h6b9&PB>>9>d#HlC6y&6;%l-S=XZ9;x2K+a)Ca@-bYIRS+ zpX5lumt)vz3?!)0a5?}c@e}3jz&rfM+4O!)R%^I^CUu%rud=)djC1^%#C?^{2<=_@ z+5pShW^nTpJj3T?DTBL)Fq2>!`Kt#^0Eg{IdKNd<*<$zmi>yK%Nea64(X@xt3ErQbdes5<{Uw?W`1*<0q7{2*@Xpb&*jNd z$RHMWIvAaT9l=2k(5EwK9Y;Wj6zs2F6`J@6VuC2;ow?x;(8;7N5?(Z$+*hZzJi@lp z^1yM!=nDa+ZT-oY=_Gm@%zEr6b_qXmqCPOE1^t9iZXS6T7e{Bkf0NR=oYNtM>y8iP z9T^|$7EkIcZY?vsB)&U?b8Jm-7z+|ld>w1yi7)uWrh+yT-_hMWnYi$TRyc7u4}_=0 zm>z$Z8-7m2V@GSR^4J_SF^Y960-xNLgcAOnwb=!}gcI{QU}PkJw>I_YU2EP}g3rb_ zKBAtW+vK{b{5aZa+ob<(osLUye?90q?#aOv+JKY6F2oM;^?c>^R?@Tn{3+3$D-A{^)rK$x2 zFDrq)J|*J%vj75q`G6FKs@W2&E4rGAV=Vk%a23F$FrrXB2z%~-x%_o1;Nhl6-GlAFO}R6u0TU3joeyb<6E@do7M zAMwdCB-jaX280*bNF#xoqK?_SklmA*mQIb%Q}T{wr_A5`Y%uNHpFq0hBnVQFvD_BC zD~J%>JVBw<fZ{f1&%cS*uOyZ-Skv=zI*}(7;u3dQe^7`UkKR}O zk~kFEGLYK1WsBBaog{UpY#+BSIQbtS!)H*8%FUJT=r*B-+yoNx5hzi2NQm2pEIKfa zHBdDpAua$4+rC>!Wih|$B&2;{VS6*^shA$Qj3MsB$>9*r;6BxW7j8$cgyxUCifQfQ=)o$J(lN#Sdvh^N$Cb<5GPntfOO5w(E|LkR9V69TBO@}i4@R_98w(N zJ8^zGxl>?nGA*sM;$4C*K}KB^KuKwtlJxAn*Us5_M1-SX8qSL>rbEM~_!A^c3R$J^ z!G-f4unfs~55xh{GiSOvCS<-d(@!NVRy--zTr&Nr)MKRJ-mZy;uiX+2>Ao;dG-L)x zjYxG8FEM~%`iL4S%2F3OgKzYlL7x{eW0Ao=>eHay5)Z!vfX5V)?6Gn)(G!L5vM^?H z1hRTe+GivHSnIxrt1uWl0Rrm~-7ABXMct>==c=E_O6iQ3>(G~>%UIFrb2!Fj*l>zO zlPNMBX>6m7>fdKjQq(Do)6IB2U7;Tmd=TagKQ{HVey93-FgUP2YP7)>3dK5Cz34~{ z6i;&a1rggJn}x6l)ptJq)QdmVT5f^|G-M$qXi0`m{7Kx*;~%mSFyb?6+9(@WbYS15 zdOXaw8)T9t8?%q&#)oY9=@J3ygX#R{nGebSR*lYSy>tUz6hH9rT2 zIbW!F=_vcF5j_tv5bJ1zds$r5RvQ(v6LAS@6gBn*0_JNEtj18odVQp6Ag^?}jaJ*r z*RT2*YG_t+jhHFCIiLlfepO$3hm6g_#WbA^`q8`>|B17Tza~A(`yl>Dc_xU+fL98i zAOi-R5jl{v-ov67;VnXhbo6k)OLuP@iUL9Vhe_{Y#kdnLLGdNLXq%`PtRGiB1gIcF z1vf)aJ^rpbF-#RhO~WFv6*E4qH@($#{F&vrfP5&eg|A>8d|@j=<_imZ5eWjg$O;yZ zSRlL6(toF{6#glK)#*2cAo7-!D8o{p5UYYo*;flZXHMTnPg4Y*WANzP-+2uj@#DY7 zs}<1LP~|RI@ASIhGaRu0OJyF@E?tTw;W!`pI4+5IscG}LoLe9T0&lQGLa^Y<;fn>o%C<>2(@RJHBwV zqMQbm_u+vjRkU>DgdbD>n|$k$(vIW7i&CJ=`lQYBeJ@|q%;I{Jdk`95O!`KhGb!eT zbE%Qk$P&wh2{ev~Ysw{0!UIQlI6%K zMb#!26`cnC0)C797TzH}K~>PE&z%^&mGp3AOzC;SdW}-_FtX;GEVv-(S%_&GVz0lv z{{$Bl?_V$%JrGzebo<}2*@?`S=$oj6-Q$07KdSfx&o=Z(+w>P(6qukJ=t;ODBb-N| z!1#%aVEF;ds8e;d&S{#D=$Btsi{b`Z>>x8w=N!-azI%r>$Oxe?<0$-Nkf1~T+gZfE zjhpMkocu<_g7R7;pH++ELirFrI3&TxU63iQS>3`UckUY>7YrL4@+@3l?zi(`?CEG6 ztR{x4aReFOUgj%=uSDl~VnmUBgb?Bw0w=Wx)56;7 zjg_c?Q4_K_E{%4+9%L$@<7W-K{!353*xJ|FngdfK(W{;0~v5*tGXDU8*wz^*z1F+3^H~WG)MVCqZJ=Uk{n)dKrhmWH-Rk35i*FgLaOMKmdSA|Lo6p|gwj<_G|S;- z#5J_cTZct}5Pc2H20^KVG6ualjGGF< z4@7|mp&FSAgt6|*`hytUS$!~Ot*JeTxl1b#1`L&Shnx{Kn#~dX#sC`EcGeuS2FOz! zbV6`282>+eZx3WulBEg004ghHhTWle=oxl~-HDx|Yna~Xu7HfpjH->PjjDofvWl&a z1g0%A2eSw=;$;$KBt(&sHDoPag;_Igm@Q?ASt1}{1_A;C0s;a8LI?;52nYxW2ng61 z0s;a80%pC(ub#N`0?NCx8jg}9yXNKQL)M#HDvNh z9yFx$X=u!l%(&!yiXnq_p`IfK*D6!y`fyFG1O(#+6wnP9-ZP_x_i6P%b*jH>?_$bO zVX@Xwfmme^6$sm>p#tsjSH=mjWv?*;%5)na;P0BT0m}BUO)18985e*^*#Y!p0*}ra z4|sI;SiqCejRVNlBZB~2qA~*TOtO1_Lsi@Ldv-OueZw@h&-cu8`ulF^k{@>O>pi#> zYPJ1*M{ut`-qo|BgLlMLJ#O~GeHxp*jy;D*YNwvaqnQppjcLil6rDNwO3$9$Hnfy( zyzsuReK>qmvtVD0W9WPmy;xL^;n?AQ*KRL%KKAo=);oauem|4Grt@o7q0G@mrhYsi zF>hjZI^J~f&;j~r4?7&a1$XMyu3bO*iM<)u9tZ4s=WXDr?!u7rfiyd3v3|3w$0@^7 z5NOxrx>GH7Yc&E?f!rA6En|ujWuPY0@v(1SU~~Zf7j4k-8TR{xBh%doQjrO0VH1jGrAi@UsuuSL~7d%88Ml zUgR#)!Wjo&rLi{9m!XBHTy_@yz@m)L8CI0>*@KEQ5#5lYFjHhifijf= zMVVFhaKcj7jwZ@1YmOx><8DI<^D(T1p+s4(oPk7le93LQ4NSqP zDc(*icLb_Y!#gx;$p1zZ4Kwg1EV{qZG!^$HtRI^%Ke zGCR65?@@PJkNKOQ|8nmy4sjEqcM|*i);#kuD^g7}8ll|)@fLu8OT6^nd~<6~{xv-_ z|0qU|c3^?Aqn#Dmrmc7ZwOl;^6;$0!rOc}wb@ao}DutW@Xq7_t5VT50Hwd+L5*dZM zLX}}?m0k8gl!)Rv@3yLgVM5p zC`P3f9{nAcrnAZ$ndb6I9h+wGX=Zeq&bZ`!it(v+p`ha`uWPx+nleI#Yjz!?q5yp+ z_lxEB{35Mw|Bk*9SzJS~`03)x7rVyHCv+E&ue3j<@3K>}ed@?OeUXoDWo@5YrVqu? zO@-wjRNjF7-%3B|Z%2<9V&=1QD_<2qe)Huby~O(KBflg;M>a{d;^gB8k22fOXrJ0%fo~9U6 z+#xVpuqzTeB=!VgKQ>6q#$!mxW?L^{q)Nt z^ri5HeufI-NS~?0>ne0n^UBHh56#k53&n+s$cH3rZXn}OfxLZ;q%_C3Uz{5-UtH2t zt(mnpKQ8+yE`!MKC>M%1(cI@H>3!o0UAjxGG&%~#arDUz3@L-Ik-o_B%L5BE);mC- zBBBmw%=Gbv4}$|;Q}X^H`dFj+3`_Bu);0$4Ms=orzgw84Q#l= z1}pP+ak4|5W9fBZ^3j}u8Y8)gze7mgkymkyp6*n=CeO@A`aoNK(^`hyX3fFejT66Y z4P)6(YYF=6*0?or-`@E?E4>=JJJ-_aMXy~;Ag8-|ErB57x^=YL=2P6imLQz+3bq7_ z>RZ?nXqGNw`@O%3jU95#=XCBSdPW23j`gX*8BJKJNo|~FaG%+QnFgrInrVRKd$a&Z z-{4sw89CKVrIZ_C17<9Jpu3o#)U1{to0~`IgDsyPr+2+~&6+Fu!VwK!Tt-V!-7XI7 z6`6}AG()p?tjNASFd|;5A65;c7R2zcwqi6QDKr{is*7-0dXw7kxLKWL(V2YNq{3Eae)uaIMe`t9kn5n6 zZUL?A7{qbc=SMzkvvYM8v8e7)HvYt73Eokp61y(DHKh_JQe-UOMAxs(2Ly{53my3} zauTC6<^wq4w@Af8}yFedW^3qs*6U*__2O z3UgU>%$VI5eLC~4d=Hy%zobg-xRR%%5Lt-pLPV^i?WT3KUA@=Qx)Ac~&eR#W*pZ@7 z!YUTgce68me5#nJy4()+<=@y%k*e${5x5W+g zy~k>1A%JczFT4KU-|nUGJ4*{#`_bdtF1|x7E%7m*@$62@-ZI|3HE9CFd*+l7z5F=f zEvjU;&1_F8**3j3rDR)a=WeaM=4POhw+{{So?i9h5_wV2?v(ycOER4%`H@zi?8l0| z317u^H=^pRt=odCRAjXK<^f{;?WYRcbi+n^yna+|r5QE0?UZbXX1APD*(Y?=O>Q^U zY77l*G^Lt}hI7HDO&>Oy>YJs`_EM@*n%G)O<%#9ThPIVz8ysr~;f9iq^y2ZA2KJFE zRxI|A=u_v7?jeyjDf=WkQb&a1 zUOPcbQi@$5B_-t!kdm6*W2kHY($0@vLFlw}uawQcyx~6fRF4uI%s532N{SsGrFPQt zH3ci}?9?`Vxe?Vgmu4qNYq0veI9=msWD7?rVfOY-FS#)OGM}>Qv1(}I`sm1Fd9YP0 zkd}8Y%utKwr(KTfD0Xa|{WQBZmBQV3YK+3&zEM^DjhjJ-bw$r1OG|1JUH4}kX}32+ z#xrfGBu2vC3@M^mNpiJLj5=<~IH`VlprbgE?U+IeFzK=pgFowbVVpp0rk(>kv-VpE zzBge9X3_4z6kjQS*PayvQ`&uzA64(N`vOF`^J1DrbmygFxA>lm=a#eI(j6UHdBPS+ ziGWx*O4w&95%CMD>OGbcI$_x+aeswsC9=%g!6I^FrKo@9#!BG^_OxJ=yDH9D^>$Q3 zGIlqGVoA?QncdW}7cljH+aY~omO)!RIm@7}pP*TDbY9!n&(TV^T2U=@?#A_M=%#9E z^e~!kLcH>5v-^}SK|am2ErFb3>XtxFIekl@C?^t4)QM^umms5JDwjqL4%lthlt4`} zrAweDYoh@HRa3hJ5z7sZoTbxjIDuNzuF}9^y?JbShm5l=bc<4$69M0I(} zPyHHv?f#@ZX`)ZGue`^1w(Qznz9;zodGf7Y=Kf#2O*wClR?O4Dnf|Laovc)nW=a_V zx=$<7_xkx-<&X^i+)z}{N>!$R@Tw`xwbB(ScmNi=mPEP=mY&d5F&mg4rEcKIU9 z7Fh;QKgfigWd9{x^})EN44^wF7F6!w&WZ)B)6E=Nwd+@9SDIO4XU4MZ(d@ag91#*0 zA)7oq)<839-~?HY!OSRh09O?>WuQ7|$#Tro#CftDzE}}!=uBBd=5Jouh%k$wu3ydaV%%wU#7R6$O+4$_pG%2g1JNrj$2ZokbERJ&7kTxaYH{ zzA0Lz)RQ=Xk?U(+j%+lsL}|7+9 z7k{g$)4II=WS9T+5P5Uw@TyfocdRRg8qUh&Iunwa7^mztLH zFqfL1JUmptCRC?$)bc5gai!3L!*x3&rKY7g!lkAq>!7x9s^eQ~@ybn$+@sUsEj6uX zouh$+TRmcIBky=B8%cH}J`8~-b3wsJm!>LwXAyO7dSoVgV5T`Nm*(ayNJ z4yRb{o+v&vSMS7Dsd_Z$wM6mmr?t30ElqaH$7lGj-Op;3`KWC1Zh|eSb#^_GRbp(0 zg0vh(=aafsz<9ybGQgio9o!KX{^i81Cyf3oitXUNh$|}|bd}Y_Yud5m5b*mpj z&*=UOj}q$N+9epL8#uC_-=9jZG_1x>VP)8&yqiEroNUL}aoxT@hDg|qXz~PB?WWPd z`K$EWG9%6boW5$tIJAQkN~>H;O*c&wC$G}EV&STxb61TR9s}HP%S%r_dxTwkb4=8M zIf+%CHjU2)^H%+qS@}M$-t#1TGNH>hNrzd3V(Qg#e1Z8!Su)K{Vfvcv$TsP)RlzIe z5Ly$$`H66^lU5bcawddu*B&#yf=BQ7-_89MnB|w9bu4sN>O}KzSt+#*4a+{RWpvYW za4Q+LB9vwcqnnEL7BK3F-6b5=A*tKpE%_b0dC&dA;yRaZ=EGuRb>DaQ?BBNMSNO}A z?)^R=>S;Q$ch`F;wD|e*((J;Kl_SMTDR+OEiij&@h@|5S#M?YhcFU=JOsgtysVM*b zonqC9zO8o928QuNUoE%yj?-!wDA7V8TX?Uz-sW!(zEeI1=If#On?r$Kv6@R0pyGay z_?EIK7o7C+68)M)@_KPdiJs^xcL8t1XPFR)Ymxr`^O=L9q$fU3%2{ETjIO0{+ zq&y|l9q_8)6J}J2$GdEIt2^CQ5lNiwDtlMCkA!zsk8seG)NIiy?y9jLRqx$brypjp z=kJnetB*5e(AFPlup-yJs|H`H@3kbZS3`HGA&nk(naN2ykK+=^m3Lo_*VQJ78Dg)a z4GHoo4mTuFQyy2Qm zB9bj(MQcmTdKZcOw3!9BCZNPlJADEt1e==Z_B#kP7Q*Y4Q5+^adpQ89-BbU(Z5gkF0A|W*@M4Gu`WfiuE#nXHzWp-sXCr=snlR`&ZWtgO{*iuD_qN-m_10fnRQ|YHCBp+ z-`a>=?uE)726XJ#^+}d~BVV+WqGdbO;ZIX{%3wLetS%n70d)|F+krp^#0@NeK0QA&I4y5ZLSe()?0Pe15V<6ftx z44^wp6jbiuP7?*J)6E=NI__6xSDIO4CyKJ{QC`5Vf2Jr$goHKlCQlVL&`cUQSCnHg zGie#X$)ctVROf6_j(M6mU6jKYtH%wUFKWpA7>@lYrGf8(YO0h=Nd+N0(Auq~lmB_smpn#!089*1#}@e13VS*TJc(bl>Vm zSbK-Aw3PU5T&C@t_yb=DZPxm0y$bs6?%s6EpUu`-9~M8q)s@ieyx+GuWbb~v%Q(Ru z{0oN4(FFjCf^<&2#sDg5ldW`kvFFjgcj#zewoK+MAVzZ?f|)rI$%h30x_n5mY&&~Q zFk1qDt`Ks(C-x`ao285DNQ{)rjULg*Vuf4#oWdvj^KtbSQk+7c1|Z{c9Hs zX|8OxSVqI`BSHM?b2e*Uxl zv$MaR-DTUr^pTTav`>zIa%6ES{|?kB{aq7gOZCgo+q3`e=;BKIi{&HpZL&z1sgicr zI{?m~`26$s@s$!O&Pk;6>5-EkANjN_66fgXjDOl*nLXYqq3`g zeE!5jd-ltfPbT&*9mqM@)GCqCG2Ojv9AK8bW%2l@@Sxwe%DG8|j(_?2$L*730ZYOD zR8e@heQKFv)84#qPPuVa%aT#C+%;yUG=~7_^Tz&1>z9->T{I0th-Pl?9T)ms8-?a_ zb1Xt<_qS<&n?k{{;a6!=z!Vm^I9`3}EGEj8btpoLd-;Wq$C>V6jG~^2S|?X#mrs0A zvgrPa#pAOlj~u5Kv$V9-!jDpkqR%0sT|*X}lToD|_^KRz=58O@=JX~hA0m}03z`7#j?JSq%#5yQeB;!@F~mG!nOF7_;1l==4>~<0npj zeq?EudU+auoH+UZG#S7g9olQ1KcG{w=1*xzQ1s}tpPcyec+uLp1xCg$?|-~^@1fbO z$YQG241Xp+K5=5{r>*wMlcecNDVD`pyRIi+1bW}H5TSe;&3Yw`z`K4EwEGC*&@4IH zA=A#xt@m`^kbFPVwKcx?b2?RP-V8Op!7dvBl1Uv|UTz;>*h@Ean``3_ zuC#yCr8E7we79Sn&t7wZ|A}SmSO57xR~)D3Dca)7q1pCtzC5xt`N@%`FWTHhNcbYt z29S4bdiqz@mPUbN@7|9o0=#Q%+Oky4_;aOl&VJ<2acr<$hlnk^b}_3WUIi?uc^D4k z1&2~eK6GED*ozPA5NncBMc?t$GNL`{M_qzBCTqm{SxNEo?xAezU8F76i?d!>t-fa0 zcXoE^pwx|aie}wSx4ST1(V5b~hnos{_|i(Ahfk(D_)`1S;{1tEPaau5x;RfEm_jLy zXxkN+-%Te{x|Fl6fcD>)=HCxIw9*J@I!r-eX}(K^cWN9qnC&LxcHtgx7`6xR0Z$j_ z?Jm^b??VGR`19FT7j~0xeyd74r+;Pr zv>5ZOr|@S+VCy0LO@8a%-7TWu+w}f@myru^5t%Q!bPh)Ty}SA~Pz1!%$c%=vCzijU zjhOdot$`%`;)@~JOetrJF|C*KyQM<%P*RC ziOKVHj$mM !Irh*_<}YT?fR^d=bk;L7o~8CMOex7|b0!W|wcO~12u-TZtVb4j|M z%*@^0T=HE$YjJ>8chl-?(_dsr=iAH+)mpy(q+2s@Q)~HF4#ze1Dz%n*1Mg8ASL(U@VG7X8 zMCCQcgR`_X_xa*{1K(n(YMTCLFO5gsWel`m{zaPub(e$M<*kq=G&iv)es;R5BrP=d zzN@vd?=V#PrW-eMTr^#Eg$R}Q)Yv=I>6R!TRjvQRbTa>hgRV`!EnTxs@XFk-3D+vy zv!8x><7T_x&Wyklv6 ziMrwZ?-zKM<>qg}MlDkufD z8Xu+_^AeAax5Rl(I|>r{*kR#Stu8OgO>(uSM)BxK(7Zxt>LPr(&1pktMT%3qrD*i_ z@%Dd10HzakVIZoUsH7vD#3K3z78{`ZjY%EY$k&g|^p~oq=b=xh7zyR)bSZByl_`kP zWWuXUWh#D}Maw6;_m;}=gt1)WOG`zi6oalLyOvMz(t%o2{o+j`^mQht$smRz$3vwg&Vpm%_m*=6x=X7MFOZ{Jv( zS%695U1{b`EyAP-;3Gu#XEE8kdUkSLrhm&Zq0Wk#hOha$U&n0D2D*irP~B*k+}Pqw z$UEKC4J^=PiBV~9jV;n-iQ-!x_09DcYO-WV=-``NtZAgR6r%?kl+{?W$+8)-9K`K* z&Dp5V;!T!?npnWeV%+czca2p62BqO0cWEp>E?(5J!`JL(ozSvoX@_1TYIJRf6-!y( zNwY=AZ5@p8%Zn}DroQFbK?AIlmU`C4I(EKA`{VHIzhx_zDsEN__##pXD*$SDzvRea{bJ>78M(=1W)!n)oAR|JR!X_N2G<~d9XFGz z0-9leC|P7j$qB@~x@?C-5}JO-x0kA7vE6zPd(0M7;jiHyQ|D8YyZ3%V-@|i_*;BSsw%JCmNH^R_obv6<2y`(soZ7KY*Ix?M3&_`8jW-nt7-|GRe?O^ z(@QRH^xSuoBofxN5;v{5#v+FYyBSIBT@^l}+`MwG(uZ$TmHof&$EiBg+S~g5!Qwu+ z;wB{%J;f=TzMZhbEic^G`6RbFc06V_AP=sb{LAm=Trtk1oGxnAS!`fa_ zQfqm1%y_|`6JLJ3)Gm&->+6nQl3)Ddlf~n7U(iAesgn8GSr=;5sgOM2r)(&3Y-kTGp?0CmqA5IooE@k(I4ITo{rk%&InQnmoBDKoi!_9K0Q!0kEEzYSdXpati@f8Ouc(?#d$)*AEyZ#?x-_2 z$`J`;DsI`-sri=e1ufdO$NAUK?C?T)#k!|g^>;dWXWqtxRKF&H?2U&;IC`ixj2y*t8TMHgN3 z-)v?%kf+`JMHfU{fz;%b>4%D(~*O%jhOLm?U5O z@|AJZ=B7uh{4Zt?(v4Rkr}bcg-LzU5N;Z3>p?klK6@(#*yFaN>IBzKXfGc^>A)kM9bo1!a7d5z4Mt#pWpYZWg#|6Hg;9+UZ&6EMI&r*R*pZ}A$BLpV5Gx#o?;=JY zB1YM%KVOue3h_%~v;@UbfI__4YVEM3WWQ>#>z#$gPd;g%q)#`sXIH*jZkw}%KP#4w zaDCZdR0gN!Qv-!&IV*)`qDpO+j?JHJQ(sA+2%9}JyDQMcN^fSSb~T5VxW;D>*vmA_ zz(BCdR3C!+7+(IfJwQOh&}xjQnJG#mg3$Va6Xe9l$7s3ItO->YH~rePS=*f^^GLG* zSrMta#?tc?6CbRIFIMpPb(B$4wM4-ry9P?Spp!oQv}i*MeF19W#OJd|=I3$us`=u} z?8=c(S-*hdHyO-| zH7&o=hg9DyZhrOlEG2$ttXLr|zDBTTtYSXDbSVB% z9(RgAy~oFmL`@(Yo1vO>iT<^G)2UIn(0f6ypQNjHae_g2jW*#~qeeB#Az#(1LIIj_ zL+ZRC-feqS1@8YkCB#tGPBCOJ9VTkFa?+_+>!#F1s}at&L@RfSzVH3Abh4;XT@xu+ z^#s_fVg`+TcDs0kQ-6h)H4PscF%iVPYMB?{X*8|Ad&|t~wEGPu;To-jK=nBFYCV(* zpe}lbg50w)RkrTB-<P!XAM_RpiZL|ltJBA5t)-_CtdD) zw;#+1rU!4&md;;vnO4~ET3|+__^yS1c2T`6(0o;+<2NLVZ`t*I0y3F7|0urReA0fz z`6QitJ+WMTwb;zAW@)9QMJJ3ur-|GbbPT9iX5kM-)3IYSjhv-#rXN`@4hSu@mrpF3 z!?yG_@8#A%@_!HhVneI^-!}d+)S5=}n#-EM$;o>@i&O3qBfPP-yyXf=UuM|G*57Zr zB8eB7jxHx+9DwRT7 zNk^r^EoODk$`AI@lP|#%CJj+s2JCQFmM5lJ7LU+j!#h~84y_PA=f538H6nL zYt9KcA$_4gRE(7%40=|LMLSA!Moh=RdlKv|N9v7%M>-3_vuN zd(3h^cREGGKn4UB+w4OYge;AcoXI#LE!Q6^#!3+81 zqxVf1O!kM0u@Zzy847G=U3NH~qL#~mz+$C=f6T#ZK$ch+jpvMU*(tsL8IUO+oE_yS zjoXmCv(Z|DW_b5FxwOe;UEt*S_gvNtCtv%lk+%s0?>pd4PTuxe7l-X% zC;pi$b(oV2K5Ocq+rK{LCz0RuFKpIkep1#}PHy*EJ2*M&v&K2O-)GHma?WQhadO#b zUE|~ppLLUycYKzW%Kt0F7Aj)dRm2BK&bf+c!|In@MYLh{IcN1YO#H%Gy$usDuw92* zZJ7A7&w`1!ID58X;(b1AGiwFA5-pe(cBL#>XvNu}4GY0MRLUE~rn;GB&Y9%^lDC{$ z7T}++eHJWr*I8--mOAe&wE+J-LF1sC_1I*GR{RkB+6w!Lk{zEW9#dkS7aAjWX4py$`o$#Q_)Xc4CWlheXxKc;t@b5_P>> zT+~CNTu}6Zp37Y>>LF1sj~ViupM{rAvdh5*RjxPomi2)>{8U7}i2xFn7u2U6m#FIv z27)2@f?lx0T+~CN>SNq{)^Ult-f1rCAyF|f~nr9Ua%cp)I*}`V}7;Yaf!O#9xm!3Q7$Mt zr{{8ri+V_u%MwFQ^Rw_WO#VkxI^0#J@Q|OhUK4Y@djTXWFQ`9pT%xWw7zmaWUg`yV z&P6>Wsy^oNTm9rcX5`IW)I*|NP;{rB%XTj6AyF>l4B6wjOviMY3?NZ1(+rv8XW`&- zl}i;{uQ7$&{8V)7Hv&jhUQoa5xI`U%Fc2(|J<<#IfQx!aRDG;Uy>eWlvGoNP^^hnR z6y59>ykf4`;-VfB<+6<-JNa378P;0if-2WrVhU&YsfevB0VFCfsGoOSqOLa>2o_?m z>IJ*RMLi^{K2|?h9ha!<-R7bm66J!T5A|H`aZwM6a(Tj#7miCbwmu6WQ7*3;vY8i& z3tyI-3MvPmW(o^#xj8y+oe3aOc|m>Iafv$kU?A95II9=zG#B-dsQOsTzvj3^9sDvE z^^hnR6uqtIa)XO{NR-Q6hCJkF;boh6yb2dox!%-f8~RW2lQvF~-1D&(KT#C}U7}B{P(zzF<1AU;xrq&-X{UPdBgG60rwP0>?EF>W`1)8|! zZwm8}rq6yK)pU@kTPz_Qf;2_4q-oqY?uMG)j%zwd)IF9EE=!ssS<*D_z0a7=bAA#X zA6aZl_9KA2aFA%P59-6N|BG?~bq|Sh$$-3M9l%8s$RtMbGR7-r^V*s0LnJ-tuXn~Q z|3;E&u}^GwzA=wvX;|{ejU3P)QOJ5Ugifh65PB4i*x(4$_jnD=y-mZyc}Ub72g7BA z1)Jn2y&2WIf*<>xNk5(DWb1#nPBzr~R1N?rOZNYiCA)gcin*zjX)}!&z8S{f9!xOE_en4spmj!+&~T{*F&wNA+Mt$ucKPRx0%6))~+j(vdNRAOm<)OB*9k57KjN99cNe@}AE^^0~{JNAl5Mg8UMaTYrSCc_g2^ ztR*C0xvY64$HoC%8t3F8mo<;%VVAXZhLd-F);&&QG(bAaF&JfG@O6flav!Qyymjzk(_$hDKyQ=DPG(oA?)A$zj8@nyJ+3ImLpLcT3>q>oRXYI z1Sd@oEipRjBuXRQPSL6@r;&eYm09Me&4nMsiFHy*4m1mXHUtJcm_d<=A3Hgd28>8T zkfNNFqsWx?Agf_qC`v~c#+c8z7rM zNRAs?Ke+;iplkX*Eu`;^ZnHho7_ADF zW_%(sx(4`wIiWFYI7v(zr`OIyqGx{|bJ6DzQWYH}N~4m*=v0y@4W}nUC&dcfQvuNl z_kvNc`AM7gu~q>{iZe)zPB?JbQt3lt@~wZ=cGhPnKNVNNWI#ZDjJat1PGWTRl!t;` z`;%(78I;BrlPuRheJy1`p#9M#D>Q@BSYd|cTF_e|0|M>OR;+NH$G$iCsq@ATv}hTx z11-hko}^_gCMjvGDCt;DB&BTqXz4JI))L#h3A--~TDi88bjT{%^(Sd5B5eqnj`cXF zgyuu7gMEOYjvg^L>Z)h{)bcsZPs+Np+h(ouQ_-QHV}c+|d#;a$E)M@-;tJ>=W%{%( zwQZRjBld1hUQF9df>r&{FiJ zl9tg$Qd$T4QC}*h(%I@U+q((7KM}NYZ6)d0zO;jWiu#kZ6wN+_Ovk#4XF_vDUz!0y z9Zmd+m4|xC>zusdvtIH7@GG|v92Nf+ix0x+OGmDN{%xjDeIPGAdy~k8*I_OTYB?B1 zH4TW(Hld9|GC)RMr9}HpKwz^3E(wqkp^GMPNsK}=Koaza5{FsBVz(bZ;DmIBX6Apf zes`LmMLGQNJ1dLWS-I_Y%ooF*l|?M*V*{KRVB`BW@10QA@Q*A{Y=Bc%xQ(*-V9b`f zzRNxf$?m^xe>~!6k=f#XlTG|AGQ&;s#asOM+vRfM4$C5Ts4sUI_qHx`TmLiBtTE=fBC560~w{ zCFzhR+4U!BDPl+niS}aqgyxD)I0GVs64~YU@2?;P-Ql=ob6@bUSCw4X{5T<7q2xes z;cX5W6q%BKk*Otr-Z%1+0_UK}hux|o`=}3Gf zWn`&06LsWj)}@(qlJiYCq#7=2KJ(hZ`^OSdX%9?Xt8^ z@3v3My2pb(4E`wV31>a!CuPm>sLmgOY-6B@gEdqN2WfCtk+Q-witTMY*uz;HDrKed z|H@7V^|Hmsd&NLZqBQSi00Xa~IFZ0<{i5!O*6^0mi@wI@ZEjQ2@)D=B$1CQB`ck}Q zCLzR#&ep}m18R?V3_@XQ_3&R=yrl)NgiGdeAa9lADNE8;_%uWxVbK-m4_*gmjZW1= zNVKtqkbZLMU(G>}3Wm796b4XSyhx6ok|kbKTi9FP6{(X{S}6iO0>8s7n*HuERuGhMdSYtv=p-fNy`{b zQqmYw(rH+~Y+D^>dpBYCIYBGeR+0|cD!cw9EyY4`2#JQJqe64VLU0BIb##ik(QYjE zfF6$7Mxi;z#ORy+B|z^u{88A77-rV!FkF8!-H=#gPy z2-R3+LlzKj-cP~dJ8e0<%f&qy2vyKn-R=)scHSMGt@Bx>Vh+|3)WBB)QZR)Qkh1`_f(<=?iZEy zq){`n91E=*z189@*RZeYXoZB3Xjcg8my^7(8I)qobdkk^c$x`|#ONB9MD>r;C83kT z4BI(+j#P$wu~Ggj5qoupsE69(;(U98laoG6D{(z4aF$yYpN3wiD>jrzjCD4W9B4m9 zlBX<5Te0gR3G2kU%8Ei^1)~~}o6Jqo$AL=%Wb_*(KHHxOZgVAG2epe4Qp2aH-1%1{6rPv#2Mmz;0=zq!ET(K)EQ5#yj zqsRP!S;^wGeo+&w4A2~oFP*Dt!kwmp{8{ZWz^HiJ@(nI5oM5KprLAThdzB~kt3^ib%eFvA2#(W%OCFV@Pp zh}f$$L_O3f^Q2V>ynnZu-@{WZOn`SiDsUDwI;%Hm;|)QZ3nBNjkTzGoC#bWW%lS#Ml~SMnVX_B1eXNJlXP8LSq-8Yl)?y-kpi+QOQR7+ z)oW(`pl9Pj&rd}&+QUT= zedsE2wE89YGV*~KPs=Qln~uGq8{p{cPBcz`f$WL z;7fj53E=Wa-?4v9lM5UuFiY~3C21?dHxz#Gr&b(A*L;JE`pSs*P9Y@vR$U0`Cl}b& z)`m1~otlFl83u+>ja4>e0pahoZMEK%y1f~+%42At5BX2UdL({4=1gkvPdPxnKFm_(wW!=>nF~{(Eu1ynSRJ< zPbF&Leonj1r@3 zSQ6DgPOpVd3Nv83y~9nnqZJFtRtNde2R)mTp>GQp1s9#+zyK)4zz~q_df8AkflCO9 zT400)8sn$V0zg4FivkTSk?3fF2GEL*WTy~%s1;p{kr171kO>+o92Z6RCmFOEl%@p_ zj?*Mt0G3cxtc2)lX-Y5}1Zp~|dLdyN3Wi$?l;SK}GvX;2LI0cH=8E+tiQ3S5JGwdu z%=s)%>lby1^?`)i^(Bd;mZh-#W#)$ZQbbJ&(KTV9p8D#dm7-Vt3tv;Wv~UICwRh}L zAddr`m67BrOVXyS*vJE-ud=X;;CMAKYjh1KghT}kA^qgiznX&{tLX-YP>oeKWC3C8 zd(x5W_$fGir!6-;InsxLPz8cHRuGt@Bx>Zvoa3)Y+1)QZR)Qkh0e^;Dt;?iZEyq){`n z91E=*T`79RHSB9TS|K4M+7*Jj6Hs-9N;4?MnCTfC0pe+9e-fi>SQ6DgPS1r-3Ny$k zs#B>Mlp>T#MheJg(J$yULN9Wd(H4dGF!3&#&BYsKxVqlv${XkN_!{SsTuq+jY4RjT zjblkYi}x`l!y;31EHWia)$5$#IaRT3Y>ZzIg?b!n9h2Homeh^1q-K<*l@Pq%#JU^d zI)je%DrjiW#n7IMp*^E-hmHrlroro>e-#wGp8Kp=MNKf_J^Z970xD?3ioi0*=p}yY z8hAa_au%;N6!cjOlw$p=8Sxa1p#MF#Io z>0H?)S#~R;|l036sKncQ9AVTu0 zll#Aha{pH;w<3apa7F5vsvSUazXb>?Y;66%@ed$Dtb0!H=*HAdE_#=r8(Y7N^9e!J z&|_xk0E(LdVxg{zkP_q60rXFk(*v&5r_LWfLlOp6I6ce>ucAev2SXt3=|pee0_2%< zwf`^fY9WX|HW+h&4xqSyLadTTTeewFTluNz1JTV5GeqUEpg-b3%W=zuAVnkW0E(Lv zVy&=v->0e5H^ZNOGaRdj9Si_aaao^)sO;AWNHh8Cz$k9MQMSUAt6fD!bpYjXQnau= zEY>tXHFgLwyP}P<4h9ZH-VnC}7}WwPX0I^VQ8t|7uJ9U=ByGTFa3C0AW9v8Z&;{|5 zKnrYUfE4CF%a9AMhH^edD5=o2_0k`%;C&W+)6nL|BI0G1f9a@$M9+}! z;G)oj-oM1#f6snsrKYTy_#u_)kVJ99u^VG=NqFp&22x;?%5!=wyRT&`7a~ zhoYyG4B8AzGu|E?rzN%kETO1a3DMQkvS2g_)S0B}g@kD+7;Y_4iuH+R#8WUj%eG$S zr}oUJ#F1Yp&U{`I+}LkfimZYs%n*!k%&a5*rv)&KPngNNftPYk-|7s3;WEdDiHCEY> z1%#XTQ*iiBTW&@2&@2puDrl^39|W!P7~syv% zp>?B&y*6`o`kIbbNC=7A4b&l^&fS|qDaK4AYy^m>nfytNP9=%zAEzBcCxsbg6xFHJ z3`!BoBqIf64;x{cpE`|D`ceh;WYk8@=lry^9{r`weag=~4#o{6eUm4tYurUjUz}x? z#EVQxU3KaeUD{U;TnEUAWOlaPf6;ct=sXN2hV@=9ovrO+nP7aNuX z!qXu9lwF<{7(nqnm8&=ls+zW=S0Rg<|>Uf#CM0p*H_J+n&<&ddyZ)EM~prqF|&Lkw}QH z1p_tZHKI4b5Am;+O73Z1#KLqjj{^l^NuIJKZN+-|>wD6XY_9Yrou7ikciQq;K`v&&K&XPo>h^WeDvu%Vjd0s8 zR;2J_r*H5JoJ63a7$9q3wU`x>j!x|*MCWBYSYYUohf;((Fc@WqIz~WEITO2JJ?FDx zgUOJ}G+L^s5;btYsH`WAnvvyLXx->y);L$Eujy!ogpg=g2 zSu>Crok|kbKTi9EP6{(DFl2?FI+dD1DMFcKq<|dF(g^zBs@UNk&*&fW(^}{Gk8Bit z#ZQ|%!S~5ex_jj{cVkMv#yKQclP7taJjqexSdw3{m?aq&nUZ6XDOsx4!oc%V#kR4Y zq#o)P^P*KQsU2lW-6%_HrdS?>gy8ii*4-(#BXp#ZUue&z(4I@7J)=Fw`GD6nc-`j) zNXs4I^@3ZUVg=*^6Tar0Vg^*uh82P3Mkrp)hi^0FELu+j@Ar^#twGn#7S`D3;cq3vO>3YA0JUO|MsM6~)rp7G?lOit&+z=vpvPhrLF$ zw6@H@E>v>Q^U~Udq;q1D1I1-Yp0Xru%8G?75T0Nm6@hUp7xiY1E_#KKs9+(apIrJ^ zbI>Ehz!0jj%7!c;Y`t4LlFgOAq-zP_@SV2Y@Z{1O41_9ZtZugjt@0Qe=p_HCSRccW zJ-)%8;p7FMC2L=`v=)+%E;LAp&da7)Q0S0{QiM7%*vAZYjDR}q?CFB_X`dB~%psL& zv{X+eYT$lRSx*`@Bg?VSy3wVzX|7IR)6ohEA+RWaCpXAXP77TTPsUzSW=rx zT3VBQjdMt@CQtG-d6J{Xu_V7@ZA>yOG9||%Q?gVot%2vQifv;(Nj=m9=0z)HQaj3$ zx>1(YOtG{E3Bl`4thjAH6@Om_A-G!Drz-zO9Y3&9R zUUg0}11f04iokL&6ffq(j~ViepStK;5A{5YR~icXtOZK3;?<0J3Pvy3)}#NM^#twG zn#7S`D3;c?Fc)xp(@^_azcjtJGfJ_vHqJ%CNHIQ=5M2uf>WtTjmewxtuN#%zi@cEn8)7NygLPAKiD+F~2sPn>RP>M0rSvCU1)2vHKj7}wq>K~_bLMMe8 zt}+BsRHsriC`Blfj1-V-SsFqAhm6+Q;Wn4P!%xL!l=rx38l!rsM@dS7R~icXtOZIj z32sI_1*6Ao>uvvg+H70m$N?3z?bm|an}(WTE2il+%qYcddxVREks@SDh%QtBwd6IT z+4dR!b+wXvj%V4}D$e6TgLFxrvLtQFijC-|>wD6XY_9Yrou7ikciMKDZNosQg2w80XV5B-p@Ht_KNVAE{5a$r z`~^-TP*Dt!wXd3Ohoqx(4++tE*)$6b9r93$PzMGx%uvS&s3m7&7p%|wtXO0YsZ67# zdMZ%^_lwGU(x@3(j)m5Z&bH^cI(!F@!@k&EMpS3_KR#=)5Pr>K~ z+j{ihTYpj?oDewj3&m2-7UlwOZyIVp>zAh2c19_da>ltR7%BQ=3DLD+pw4)WXes9+ z|GHJl#k)w@n#|)s0aTKwEJ>TPVu25$A7&vHJ^Tb0^=6F*#t;$}EQIuvOaE#PdSn${=Y`Fn6l12dYy^m>nK4U@P9=%z zAE$FdCxscVG2|9Mbt*N3QiL+eNCCN?r4jUhQL)2)o<-x{U27dI?BKlyn>)q}JXjCV zSyJ*f&LO#)Jjv7KNsb!F0>6h9J!9kTdMMbGmUEZ0@gdZXYFu( zm;H5%pEmc}+cx(mKW*+){`IPoYfJinr9Vr)W~?N+nmozV4GLG`o(pq}Q<}ULykHb)_Ey+`sq)l0tng3UI_YnP# zvr%*p^ip8f3`kV4!E)(e%|VY014F3BDjTwZu=PFZNOk-a9KO?*o1AQKFc7MsvAVq+ zw8~?Md#n5>S~XbRgdg{OgWoCw6%BP{Bq^XiirAFYEhHV?s*(_0G`!2QLx((+Vnhc9 z_nD!N5l~N@iCwVX!lqV4=8(!XTB@fKHE_SEtS60{k>yxu-RS1*L#|<8)6ohEA6D`9U}JX3{ej?=_LGz ztADt%%)eGDxmvlKpasW41GF}PjtfpM^FZ};@HTDSkmaXLZn%t1D z$&J}AC3)Y%nDOn)KmTlRIWNIAH}F3X3sEWQ%lpfrnxjC z)KKdH0>XW_cXuGhJESrlQi%>LAi0+%3W1%@Cn*ioX=mLJV;Y{~qMnf^-hqKfY3c;1 zvwHDRG>wr&DP9&h$1+{wr!H~<<;64B0}VL2juvPDtq4vRgwR8+Xls%XootW^8YzZc zD0(Z&pv|B(W6!~Hy2ciOB@`7aA-Y<+E*K30bvvngAz>N{hFc4iV(Xz9@f3`p|JEPa zs802(SZSB24XwAMqhMfO`r1w4w0=={SRY8J-Q$oro#kIMw^DuG`(4!bEv{XlXnF7U zP^=r5AQCWv)jsb~gqq`DXDhi!c~1nZk9izuZB3G=EJ<6j0tbb6u#k$Nx`~Uzuvw7k zg3w^O^snZiM}~nRRAZG5SwPtOo^&LeD}71lr{M6Nwj62X{s9bxDrl^3hl5sm3=MQA z|7l~3M%DN+<{SJnC(rsUS^EVv7Cb}J(fOH#=)7!{1%(cIC`H@?gMH32F6=J(te9Ow zD${6lo=VhI{i3p-G-^hcW1)4UyBw2ToxY}{6%skAvAbCqULZ?%Zm4~C=MAlvIC8G(AiD9de1%`Fx8jQP~XDHa5tXR?yG^~DN? zORHvyvei5it>#?ZOSV0v)bf)!h3#KuvXZ#<#R`Vox&yKJ>#G~1)dkcrqsZ)6H~t{r znsae2=99`#;uN;ul*vls))y-nF0Gm+%2so{HRs|sv+W_JmY>8aY`-OwmBg(tRxsQS z)^1bl>+74Y+~Hqmf9Tpczfp#8Hux2h{-5Xv<@SUOj**xlqJneS<<$Y6=T0$C`)e?h3pqY z_KP9=#gKjUC8JShzlWbXo8_U#1TSs9N}Nu{3FfxKPeok-a+)CVigoj@74?3p#0XgV!@|CcUt9o@rcmw7z~Z6s@xhYk;~_kr1PZ zCw??RazE!^BmdF*1I60}ZEi6KinlkI&`o|SLNIL73>9cgjHRlSCG}K@ca4>+CtiQ3 zn2rZ>dBtaBC75EUkVmd!qH**#Ywjt31S;?z#bK!jOa-+;CJ%=;4UMe8Yu}$)H&*kC zML`gL={-FavavN5pL#uK`U!kGKy>zvDFDLT*qDU^l5~+N$E8WCf_!6j1-ZQq4@jx$ zAgfmU&CZo_s6d92k}<}Blo)Fv{pIqSeKUc}CN>@*nt`&!C_?mBW`kz0VIwgKY^Iz` zM7Ie?xagRJv}2ViAsS^QMxl&^XxQusw2Ag1I|E460OJgq;-_Mb29Oj7kQjx{K>m=E zEUL`9g+PZny)GFLP(S6kL^tElaM1-fQ27W+KZJ<--5jGmBz}sY8J~8twqtD-Y9&A* z&_xzdH_}GwtIjA<*)DNW31S8FRPS&W#fZTSF zXr15UqTr&d4KM&o5jp@_)ysyW30y)*)B<-|pojd_SpX==W>KK=B#9Pi0IfLAa9;?m zn1)D*PEW`Ljm$Lx(R0KvS-Rn*$@D9MQaDv3kZ33kxkMqa({+Kd(pDgvL21T5gX6TB z-DVp<73~3#G~;by27^THNNN+1FbxHL)&iv%tTrQ_f)Vt;>>R0mfv=3i6>=10aEIe9 zcbi9V8lRBt)Z(#3+=J5DlACfi}@`(dhsZHNZKBTy!>zni-H32ap(r%|QOT zlPs#tx`jZ89ek~U-5HEUnmp89w%22R4x3%bA8h-24qi`hCmIq=C!i*7m{J;HwiMywdjo;?J{dXrkpcJhYW+^ zvX2EyYp%_p6fOEtmUt4io*2Q zA(NHFtuIzETv|0tl&$9Y8I@ez65Ae9YWYc=!uHFVtR!xIv4Y{wvv#@{FYBSsX7Nfx zp>&#F^-$+nFGURxjL`*_>9Uh8x}b2Ki{8>ho^sLWddSxQWJiw|_-W<>zrQldZ>0m6OrlisNzj|Y z>Ks=UqQ9ccyvUHd{4A{Zn14JeXU6;ll&(1tg$Vq(&6(tatDFQ!$_n`rRLc)^Z0nPx zbZru{-*IAo7>fC!q^$@Mmzdy|Key^wakg_mJd)HOOIk%$Nm45B2c;%VCu!w7kfcMKd5Sz*G7`C%yLhmy8pEHfgM)rlifDqjT%I;eWDDVA@}DgMC) zPG0s|F(=w5sHo%(L5kjMi8(N1{~nNzj|Y>KYsHCO^N|`eu0Mn_>LC%h_+W z4ix$LeZN{f<`9p#`11d0OAfUbCVAXG#ZSsgr}9Zi<&zkd=Pb)YEm>YLm6oG2kK|UD z^}%*dj`*wzPENY4=w>x|feLxv?cZOKgluk1d(hhE*nboX`H`fpc;n!uFi0ICL8}Rc z`#}q?V|A21sH+Gm7oB?#tsY$wZr*fx~WW{Vu)=2B~0C z8dJ=$Zik(Y(Mi}&F6ya7%_1Q*7LQAdPyi9hffSt>PzjX=$eY7xg{x?o?**e?WP&>s zG)qOt5>ojjq!R5|&ay18ormSfa*olL9F=(_Z@8=vZgKLq&w9Yghb}AHv49t-*vKUb z>Ean^-E{0f3WfYg(pGdV=b0d^P)A76YC_?D(1Pn&9i|n*<+*c; zC}UJ}wTfaLi$p0p7C_*zs*VLx!J^c$ykOm4Ivt}O%PJT3RH9~)5LL&5Pyi9hffOAJ zPzjX=$eY6m9m-aB;iTrnNqMNv%p;ALL@73^wq!AqsP)7MCL8tDbV+e4gG=Y3c4qNP zL!oql^NCsT9G!CyY{qV63np{NBK#MmGO6{I)VI^G$fuD9rKf)KF?{pWT zYXLF1sD0*7YMM889a*(KVtjr~T+6K9m8{+n)2D#%$wn0wtQ_&zt z14y(QKz)*-MT5kTeU5dsL9RDC`&snEPK9WLJQP5p)>~r8X+4*f021W_>KF7}&T>%? ziE=^F%X%)?x#(?vT6f>XZoWCm-G|4lyKm>G!riw7kf@TNKElw#-SK18v5va?dZRPO zqE9&$qV7HsK%&;0X2_hL%S-@?asl-fJ(r_g)I*|NQ1pzR%Xuz(nV;6(AMxc;Pxxtb ztuy<7`oZq31FdK%!hgeZQW|6c_c7C>Io+(Q}aya%{!?XOO4`R%V5tw&~sHhWIe4LEdE= zkMst*A3#2cxfG~BW@ynM@#C3e9qoVC8=dDY`fH~`v_ZZMARol6w|TcMv7MiaF~ZgW z66FHwV|p$-xTuFjxr{SpQqN_Ii%#ny`vOQ*Fi=0N=Ypb34l*69$^|a!AyL6jG2|RS zZEIiUR(>z3wclqNPxz_uq=x|{Dlw=(WoXgb@#BSK9c}IFjm}FJeG}VUVZGM@Bx=2_ zOnrx*%k}^g(Vi^?d%~;~+qjUX zsv!uZX((yg+8ntesUbgRv8L&*vRR-jKya9#83V8wDpmfvw5Z?FETIKRC}2&?2^v0Ii$in2g(e#NVVl{ zQ3pD|&O_Z7ywsP>LaE{RY=fh*hvMt$kC@$4ek!ho1msCNWr-(I>xt1;)@alRL&c4SN559A8JJ|M+Qp-=`6t>@)$x7nZ z7b_TUinXKh*S+{<5%o}$S-jFvD4nKPGblw34~!A?-|uby;_sp-{PR$Im`55fiBec^ zUlt>YT2G8%vN>N(nnMO$IuA9I#VZYk(rFUbLmg(l6!kkWMhh&{vXgBwwsv!LAP@+2 znz>Q@r?<0i@vqyJ+?d2GT)Ijt50xju8J6Ijms|06R%g^rrU6OJ%0&FVhbC#AX9+HP zZ4_^3bw=G_8qkWg88EF&EWvets@}8$2;%nv^p_hd9?Ey3x9BZ)B+qgInuVR`MC-3+yPPs>%*L28h9=yB~-EYMZO7QDyWSxUf2u^g9 zWgGu}sC5WQZ_rOdS-RgTB4pX_2>%x(p)B!2(o6hbViKe1DK5C7wX6F`iG|6*@PY8w zlvCi-m}oU1&}OKm=8^!JV95c|*bJBi{RazyG76I&V*Qu+*=x|jE(3_?5_NeA(O9_- zriL~tq78@*3_T#x61-->lBE~`qA9eQW8Vj4Q|s>^wW5&|J>4bOaz4Gz$=g1QQ|=*q znP#Y5Wcpr~X~=TJ$ujMP;DnUrGUs3Okei(J8cnZq);(W}Q|=)NXULKPxtlIn0%Z9| z)o~WOYzml2PVn9Qv`w^+lNWuKvkoURSfvL5VCQ{YPP}!=ld3XTK$xUY`Po(IuT`q{*W)Cv?j9 zzUC;MW|>f1s&E6)Wd`>cT%#TU0iOiORmWw9Q|=*S4!8i)YhcxYWVMv}&}qR5smvM9 z2NzY@@@Z(ds1e{H zj~$g9jY2AKnk=R_mFCs-urJuIsB2v;0Lr(CuHV~+Hv_WC4eq1Lu5L{L2S+i zv-u@Xp7vR1IC;@$x%R;c*-RwiVv-?A7nzcHk-5g?XIN2hmg!~AI^}FIeU_8weO65F z1uhCp&=?GMKIf=Jhmg%sIU2|^4Ovhpn&}Z!=`RGvNicN+WXrDT;^S$qSz3HN&&lns z!n*E{O2VTI-O&1t^c1%-EHT?0=41J(k2(FMl!xd$%wij?{12^I z$^f~0?CS!uooRYV)H;KK>|?>^_&L-%!72BU>H~tkGJ1KU$NUl&$V2UCDbjdJRF4J= z@ussFNz{5`1e49NW{R4X5V~`s`%*G2mj#+(p&*=!lLRTOeK?1Y1g#@Ju-7Tpi`w3~ zp{}d_s3M@27)1xZ&kfN93H;MNWJ}M*EilDYeiElJ{LxHS61Tos!EkBSEK#CM$_sU#u>$R+so`d(u_@b-$9!KiosM)qc>r%G{{ySmoqnpT#Nn zkP=@dUWZhrozue@f?WaHh0@>UrD8oZ=U7vQ9QP=s2K27pK{u3_uQk3VP z?$J$?e)GA;5=cG|IUhEIK2JG6RUgTR>Q}O$EKq;WTojE9f>)~?1TfFiRj#Cko<&ka zK1=ByvJ#u7cY`@WSIF^#^Pw&BonV}h@=1DRZjgG#5Je3@npFpx2O0v=L>)8Tgo*ks zCV0mYo_@_qPk4GWx8JR91z?&BxrfwymH%>|pX42isU%Q$8Kp1{Abn>9257FTmADK*Rh_gt?MAOm0p7VuteI|UBSO5u5c41m>^^ahv!8QUFQ4m|2w{yf%9 zU;8Zf1ouENkc1CAm-zrmzv6r}Bz)9StT{g%&i962Ewcc3y5$ow^CbC;hzE-!(pLs>r!sdPO^upX(L4vf%- z^I-YC$Br^If(Kmiro?W7rxJDKkjf_^m9ASWkmVf9P?Cjn+(Wux2w5jwGMdvramXF6 zWZ$TxRapbF%G`SNt#Hf1aDm#7onX;c_mqpiaFD3Q1_OZ(JGoo#b%qF5hGg4ZR~}Uc zdhc+Mt_O&~1(E^!R_k}IEi?bF>l!t1D4)OzkOYM$SrMFrRP<|m1f02J%!?4jly=j)q0lWP&#T#33))%&%PiPjm0> z9&(JE0J-`?Z>w4O@8+1+SW6bJFF2cAwFnbkxJQIt##HLtqIm`PesR=Hb6leT8i8m7^cWf zrBuhp%}F(xWfh6)@rnrCeM&G=*=!$!4)K#-qeb#4XKiTxaU0U7T(KD>&$z6GYn((? z_BbpHp+mx5!&x_ouF)*9Y!EvSrO;@(Bcs!t3v21vOIj3$LFg(I>@oj@!9ptYA(gHJ zkM2~~lPn9NMhmfcagI%RQE$o+61AIb6uO#k2BmOU$w&dY&i1;)Pn|}qT>7rw+Jk}I zW`Q2_Qx!Mwap6ZPpoaqoCFun5l0Y!P;6aMW*NAWmKF_&gU+{C?K%TNd!*0~v_1rY# z{7Z&x(nDHYbTE(vT_9Kj1Ud{F5*_w5B3P8mR<6nkSNjV{?&B=8-t&~xuY9psZ#%|C zL9WMzEpSB?1!rAHQxCO=#Z2RshC=Byy_!KOLesz)LH`Th<}bQm0RXSaLoG3nG+xV$ zy2wwuKcV}g76d#iSbe|s^^4XI&TZ(r8V2B92HxYRqOJx5xx)fI<)>xD1HDff_e1K|$hd0w5o zD&(bBVvxKpu;y>I+TRQ>d^3#SQ0{xJB72pKJrKpEmRy`mxyO32Dm0_5@>LcL+Vncf z$I)ekA!Gc^b5l_9p56VV12f*i3{fHE#;cs=#n16<5bmIn=hcvBgO?}#of7}}j|lp( z&LC<6JiG_Ckvzn1wW0O(Fw%3JM+@Ib`hLiL6u?*O43~Eg+4A@EUqG$LPBqLELZ%&g zPDn1H_|f1SLZZ5$KuMPc7RVbZ$~dGl4JzlDT926uj1*E?2&o{4$@)(=bf>bOWNAZw zZ

QAht!lh$U^Qr<&w3PUc=*0yT!{g*JOC@GeCne1ewx|$!JTy&}mVgZNSn3!c?=c)azMK5%#uW~N zy0U+(-XV@L`dy_~U`jfaZd{VkG9qXK-4o$9JSxy0$RG?GM`>F$h++&3M+phB2@RDp zPofMrnnr|>!J`roMtM3Z+C)tPWw`mlu4zINWe}pkthY@)MoWn0Mic3my^Old&!H&0QCoZ+!4#&HAj ztPLCMLI3|}@BQQI+xNV#eeU6osHlvhVo~j!T~VPiMn*-oD@q*k(LQ&06f;9befK$s zJ3|c?6%{2ldmKt8sY^vg9V#j+Dk>@}s$Ef0p`xOqqGD1}QBk6zqPEX>Jzr~``(EGo zUZ1tun=hPm?;rQM_Gi6c?_ZzK`mD8o@IBL7BfC8CeQu`Xv-lw}^J7~Zt&yPh+(OQ+ zd0D68q{<&uMY{F^zG&LS%RUVFzDSboSd#f8r7aUBY}G43j@%^K4bM%cIijQ`nH|_8 zp(7a90jZQ*q>_)5T)yN(>VQY}1Cw;Xda{zRI#tP8u8L%Ri7Mb@$#YC^V#zmjv0TO5 zz&Enq@20&}(q1y}_)0s;B~v2PyIg&e^UMguX znMEt@B$rHy-q)9y)38<8hqY7zdtqB7nYW#EluSu~{#sPFe&!L@wDzb%p0=JZ(jd)K zCjz!gD+z1f7=b2XK%lhbP1bhRf~0H`3z;9Q3HVCaN}ef93z-E-#!b({mcY|g6=LR# zl~1L``94$u@2J|7UO*t#KTFSpK1q9$Xr`4&xkNI~Ra09;0S$kyI4XW2X?ONNPxrz_ z`UCMbY6^HZmSj1WWWK9e!c!bG)I)QB(npnB(w>`Iv|yDi&XNl zlgpQUNFDGDv2KzMcwc8FVRb4eRTS{a_Aa^AVZi4plI+Kl%xT**QNqemfE>9=au}YQ zOmjp@OENofL_()9tOHUhw@4))7rA`NhtvTJ_t+#IuyCy;tj;R}-RG+4+Nc6Hwzfzz z-wmdtWJ+%G*P>=U=4x7dR3Yyio-fh^9Z)9%mbR6It>kXeAF&-5&83A}ujJ~14lzOcH6u$C&|L7**?%$+eEB~vn-zZR9P z@4~{G)*e;JRrGw3$}~@%2-xGSB&>N;1ggS-Kxs+lX4-;e+9Vb-KUNd4|5(X0g=rzP z0LhH$S=bVInre=i`C{c$X>q;}RlsL9?MW{nkm_He=Ru#wy>QVEwH)NB>4l4qspTwB zO-~YCv=S+oNVPnl=$x7YE{rE7mm|(4DcvUR&i>T&g^M1jrR$eP->HRd=}=ey#Bm2THTa1C}H*9c7>)(V>d`{O|OxIGv+Pd6t{jdet5; z!=$gbc#YqL%rGl3{L@;I_VTG5P7%6Mgbr2T z7fMZv`1lIJbu9c;he=%@b25glD;<7*3F9P|x|zdEbus0o8p}Dz%H_ktYVkAc=j~u# zPmOEQ`f2h@WO=u}`SRxT`Tk%V)a-A2y$&_@*LBWqz$SMCd70wi9qV1!Ws~o#c!ET=1hrYly9EBAkhu$`C7JhedB2LIe0;;iLL~7`6pzNhP-Bz)Dp573TwX zZb_2FGB-$>CQ&Mt)cb(UT($dX>j}u!N*eDim)!T3w4h)`U!geq?*I(*4tWYTo>+9a zJ`we)(UlVpFMfGEq#lY|Z`N@ocKneJOW!9i?k!4QW>D|MUOFjR36D}uCFb4&Rm(h* z98tDXQ8LRvKym_`yoXj|?@Qu7)cJ{JN{&+HXUeR$72NR}asx{(O4|5@LWg^?mya(w)Td32?@aFa z;OQax;99;!tyjGkhd2oMoKO|TcH`oqFc6f+wok>Y(=_)hS~JmhHmEz_2C zFre)cb;r{?jhh&DN#AiMk!1ezstfOlB=g5jX-Or{hy$D0gA9oFb_o@Dk)x6FlVqFu zX~+{KN-XFqQJh>N)ge*iGonGdG6Wk#YMyAj+l#5B0nbA6J{BIOh0W1Q-fq^aLbTOP zky5e=XD;F;Bx`Xs-%Q_H+>fc1i1qR|Tk9vNgdOtu!h?~5h_>n{NcQ8ZGxvW*$sv(x zQcLD~Y(XOLUwHUcr$pPaHb}l!_}+FL<=6bb~prv`qV!4YK&9oXU+D6}F zTI0=W;3J@w1wH#dNwg8ad(ONN6z91mnQsi0*mhh?rsUDgPrxH+H{OR}(9*G@fT!c4 ziPM54D78{5PUbyh0?9mV@(;)8!myH{)MoR?v67%T)l{6!3tJa-j*H+4lJ&UJnOCQx z1*jfBN#g zlJR(UGFSH~rkb6ATdg+lsW?jJ#}a9YM(~mTTCB_&-6?~XOvhsF4|leyQX zy;Rd)lpXHVtLDfmHQkz{@*agvf` zUiE27=88Td%2`}X=B=v*$+3wNv<4I>=~?FYJ1t1$J!wGYmTa|R1HN@RM{q%vvk|=t<?Ly(QsCoQGIz#dl1t`=D=bNRh5N#<6j#13df(2pV{QUhL? z=!ja9g^{@lr6rl0&^}R;wUoIEBuNs>+)~2iu*y~2L>5Z3XLIUFwUvQW2}dV=HT1 z9ceGsc1IQB;{vr9g31eqK^|*OVIqw|4rP0N*9kv-SMMRW*cu&CldE6ub*~d z9APX8tV4NgG8ytxLY<`V-pH(^90%^CL^XX_Sm=(Q)s=1I2d(~p%Eaa?QIiME=amf6 zz;~9YISeXsGXE^TA4%hGoIPPvscJGW20ix7BYpdO%_Ux}eQ}WE7~0S@_105kbGCk( z?AP+r21(POoGQ+;DY5ZBF|LdQTi`b12e9$mt~!U>0Gs^WOM$nM$jjSot)HM0tSBJ3 zl?27nEi@@oQ%xz!cQPvSmNO5q$@fc=+;voP_3OWV?=QxQRdiU0Z#wR-9N;COVtGm5 zL8@dGLrc&~%2+hHPqjg!eZT46W8+BFUy~$_J&HIrwz00Z5Q?wwN z8~45-i7xSZq;GeMC0?w3aggH}cFkH(`R)tK$A)flEAb>vH#>=P+!rL-rgZJ-`R)sz zm$%v0ajmU4s01r&a$itzD+!8oY?2F@l3OGXFz8xrizr~Hw0EGOmC z0IwRK&goElV&lF%%Gt5l%Dw#sI37&AwBWdiI`L9rB!+eu<|MN7JZ*|9oaG-i5Qv?|XM6!}*->*DVm<7{>eyVL$qr=&F$X##N%XlntKai0` zU01Zmo8aEh^g^K<7kIDxH?;CpBxpeJD^s;5rpX-M8HrNNAyI;jKcXSk7+PGzXG$eH z6%fTr0-`LKC}r|!)KcScD;eS_hH|xDlD#1Q4?!-)Uf#&@b~1Fx;c+s=Q4AZak253i zYlZc4Y|MeDnfQW6*(ik&Khl4psI1UWkW}&gLE%S3qpWmPq76Pt%-;@JUy`WX&Hh0& zttM%5bXk(Qxc-U`7vmxK(^MN+(#FN0!yH~z>UJDBvrA8qB+GZi-yWF^h1txXnIs|e zXTyB0(ALx{zp0D-BXq~rXcfe#<9)zLSPqgPFuTQ(Bi z*K$Y(v%9jAKZ=zEM5&u7r8qJ7lC%;{SL4Y@hcmI4H**{&+pxcM$VL5>w`Lz}8p%)` z`1?7Ep&do(%k*ivw%5x z2Q0dr_Vc~(@Z*lsb(Ow&O!FFt) zGe_a&rzM%?x3FMZkZ6;5h-=Bb2K4kg%%f|wk6Sb`RuiyOSV^11)X%%(3I6;*ubRA9 zIWv;pxMvj|_QgZf9L3Nok{2uau(0HRgY;z<_0ysf{CcAijem$gZX5@;e@~PRwiYd? zY=9^^Ym>R61uV)OlEQE8`nKlw#I0!hwX$RqcOz?(oF{2^Eqj_ahv_v<&~j>o(cx@d zpt~npFXOSq{UBHpbzRZ&e-JEBMS=zdUoll{E}JxW-AGDtiIq_f$C4rCFp&hjxX zbzF=kAIWhg8H(i`cwUs=+n=h-j}m-480x8r;fIA^)%}?~slK;^p`Q9E#lsmVixAODQdJFGER`S`x+m6!FSj35i7OH14=orb;2!it8Nl4d_BWLov?mPp*6@hgft zmPp+7=1Vdcj~*hDD49$236fk(M{#nAWUTH5t!x!P98YNcEyz?d#8C`;9gc8jGM2cv z_VRD*irsvEpjS<9l~&RnM{$=$C4ZDzBhef*64T*W9M~-{z>AvI=0Q{v3%$S4eRFB! zNR%TrNjep0k2(}5Ahm;(#Qj=94M_z zbIIKL+8_y8_X=~8KQl=}=Ff)dP-^P$eRwr(kc1SYFgN)#lO&|iHcW?7Q-Ay8$D+*j z+y+TVF$&Y2KQl=}`fS5=C^hwWG`yNNNJ5HHn4$ccNfOd$8>U04slU_V)wDqpQjEe( z=Fd!$kUrZm9ZGG7Do(6kn$$VFy zmUJ@8WBAORVw#kn`5Dt4k{nU`X>JlFv-|-hL-D-0zjf3Ds3b2gN-2N&lSt;{@-sWu z21&>@rZBVlGm|9b^0#3+l$t(3`obr*S)Uq7q7R&cK9!W{x#Dbx&&~>_Nov)s7SxdB zh;o#QlDVLdkzBwge?g}$K$4`E7ZT+(y!_$c9(`e7S2uWi@-lY?D+#(-W|?>`l9ohGenO{ZF8_1H3yLGr zDx$`2$x#fuT+}bUMynstHa0VQ(cTk?LvsI}|I*Rgoec=4p3JB1Jff z=g9r(t}3cynn};gw<}D8 zmR$Lw3-btrylV12mX#D^NkxbH^Weri5&gCDX#6Pd?$OrqK~n1kb##C3#xa^3oS?UZ2_mn*8T( zHIH9DFWRq{nYq@dw*8*w$*IY|b)kt-@Ej7EYAFV--zSNl-eZNAr$%Set9UN!B2>jM z(aYy|Xj@XqU3-zDRa5KhxP6}1$mup-$Ca$9kz_l+B#Gj_IndRjD2YTHTb!TWxUHnw zpSasFEfkYOBGWx`|Df}ou?r5eJvIIa^cZ7h z)bwux)xT{-NluNw+ev$B^2a=$r^XwuBa=~+_h7!4O4>{261P=-Czr0bQ}MF<(%J>Y z8jE4Cl{3!hLTg;Ru`LHyqQ`wbiv~Qt>J6*j4TkJpR`dSDtpAQ^ov1;2)#L-!Z6g^& z+mPr`8&Z>RL_9BzJ*+qWuO-S)<3Fbks1)?`UrNjY9P?zh%$kR*w@ZwhUc&Ps-w_g`}v*#AkqB{^p{^ZiH~&(8iI zL1+f1Qq{O0GfJX|%z315|I=AZyjc6|N58WESnOW z{0B58*+y~z8*lXL947b5IYwgGHf?i8UfyO~XHb5EO0c3PZ^>1Hl?25(HpvCd;w_Q~ z7_hC~byQOSow_wgVS0%6`6rG|{~#LqiaZqw8W6nvyEJ=|W)Nw!FL#VY(Hiri zLp>!op3$yw_yC(cw%J?;VoChvPU85D9AC#)Z|*rvV!88VW2w&{6yh&;E@H=@C|2Uw zz2D1m5w#ln`A0%Fzos7((dD$C?|p}#CSUHf+0O)ZX@_q1O%9`F|M^SG85BAF$jTAWzsR7#SR-$_ZbVBBAys>w<$hh&bj6G>(*Pgs^} z@`r_=?00{Np=uN-N1G*Cp{gd2CyKI!siFj>W<>!Tup~KBlc`b*s78`?s>&hJ+%zPs zs1q;Ry*QEl2kF(uEza!3fioq?m|nz^%&qzw(|g$LSyGugo73&Zy#yDEq>#LZlhkDFN3H^(SxwbyF|62vyyEyse1E~@s>|AEt~GRo(e}X zG_9Vb*~0cTO_rP|X%=SRG@(DKMu)TUko#7`dKr%;?pr=d)OAJ6|CUdliUbV^Ui{sf zy-1_rjppj`Brf621&7-9ntWK{JC6SoeZ|=ECshuUyZ@()44uVR?t_{i>l-R!DDg7O zVG^sVL&a=-KD3Ng9X9#M$PXXCeM~NO_txTjiDzOm&c$7SzL$5k9e*)&nfhLyQqe%1 ze*6}`7!SEmd&;GR>2NG@uP7_Y(ftX$CyTzSMW6gfmb6;2P3~F>EHBA~WlFT(cH{Cg z=Qu6Nyh75F%=IYAYMfYRlp3aqBy+0LlFY<5h>~&tOftk#4BNM~7xxm7k9SBEIJx$o z$xD%>k_oLUP0?1ImSirjw4@VJR6{bMnN55i$r!DifX$xhFe$X6k+z?MFFX%j#6xdx zIJ{4WIErDXTqj0i$wxX&99PqhGdBlinq$f&Q38#>VbYix3 zo0bG$P^$b3O(-W#P(aZJE^#8M_~Y~(y0z$>sA7Ylh3TyK(o|;WR^^ z|K|a9JQJHu*ErlrhB%607lhVb;w5tjO-nT5MoH(I86_>zh#N&UtYFdPowt0XC7Fvq zEy*lDEomW&`_!mf<~UdkFF!5GOiXKRCytUil~0i5Sjmc#L$XQ@Icix)at<5cZ5Q27 z=CLWfPf@Lv^g1QlG~H|brmNWGH+AY?TJ~chGEM6~ewuuMsYo(Srnm6}b)6LL9%@Aa zaZd21I4wvTzx44_8~#0A%JwbCdDUb~w36Xi690=ackxh_qZsOm^^zlS5ob9hrIh3o zsV6wq`0P)Im3Zh=9d5-#?k=W^6f1ed7JHdWyy$Q?9{RM(VG_&zWJ0mhMf}Ko%FB;1 z62s0x+DmmV2M?d z#{xc{`dV~)8a94=vd-aFJmfA78*4F+Rng&M?B$IdZ^T1x-PW--!p0Adby$yMeJaOE z#_pQ2j+JI(T6DM)JAO*W^7d}WgovT}w&^LC&p*w!RW|#CTYe^qFbA95xh1J$x*X4v z#GFWO!&Z{awVY&1R^!BeV4cH_WGI$%VB4f;n0hSvW|l+`CP@_cj;Zn_d0MV3WTrBk zJQ6Cfm3;moWLAAv^Gsoy{YYKqsO3xX%5pzpvyvUkZhSJU!xc8M&m-$N+1P$W8(S?7 z=01PfVD&gy=F(6}iNt-U`M#sHkXR=qn>1G)YdlQ*f0U=5?Hf^J8Az|GZ}NO?y(E&% z^{2pzB=f#2i4tr)^XM?~qMKMj|Fb)ryd;uN=9)yw+_=A!*xM<~(Xlh;IFV%TL}^Lp zf|2BwXaUzlTJoJJx*j9itMb)!?8CyZ&E8cnC{|16!@^oCqJT&@MA9V?6v>J{C}b|r z7b{VV)qoEQnGdRW^i01leEWCC`p4q*&v-Qb<73_Ttf$7C0P82R;2GjNjLOI?dsHGDJUP*o)hGd7G{E6I6l~HTfu4C0I#NoS9US?ngz6Q$v!x z-=B*c!h!8eT9Ww;l$HcXNgmMXDEG}F4$H|t#63<@c`Z%Mp#Pk;Z3#%@cbCB(&n)Z^} zgqM_yzGqVztzCL)FV*w~oY|MOmsYlcw3k+L*=Gfuz$U+<&_z{ZFBpyY1ot|e{rz3v zw$ujVDBsZGUOZGi;P5aR;wXj|s&!n9B_HW9ar`Fj*uC_u<5KLnqQk`T$7#ozt&o>B z95q1~ z!exuJp{wxY^+M*{D%f+VX2>jwRSU@QIaNz!n9NvE>#Z!T^{XaWCsf1NT||jc2+PB}3T9&=%;&itj#2tT&34Jb$@&AK!6Y#C%eOGEQ#9)i_lS za%7x1ev@|m)yjA{>2X#=`!UetOp~8PX>uh=8vaST;qEUoilcN}R38f{K*p>q;8Dc!Sqhzk9wn#EBhjbM8`Ar>@WS*KDZzR%v&-7A8JsEqc z%yF1FuE_C7yd`C}S_X+1`Ne(mL4_(xOEQ;DT9Ub5mC$}%@f+=1$&Q=3EYe=8X)l@6 zp7!#Ra``k}QRalCEBYkurG+{AIPE2KZ7Y{rGSl(e`j88$; zv*y@$|AFX1V-SwOF=*@Ww0&>Rd}Ln=%wKg5nK~;@z0YkwP99!9%6r(@Rh|5w+kTon zynK|m)|u>wAYL5S2$mTt8fE;S@mAswtwn_?O&GusrL8u z{{cS2!hN(acEfEr{BxrF#2B>k+wHF}XMEXD1?Ibe-6C9qYtYvB((Kjm(D}L4^+tVJ z^Lc{ZC0zc4(YmO?RoMH7qVWprV#-+`XMz5X@Ougif&MRY`ai?}In2uc0sr0Dk32?o zm*F_vgj;YIF8-A0`dNo|eOdn#=r#iNlP}DE*~w?cslU_q>Z3P5c0M%Ez0CLOPmShp z18%|_cn1f5T4a~yZ`uT}jpeyrZ^3)-hI*smt~qxqbI<9|x@dJ~5F+i>`$>jgXi!XD*h<($6y)S_*>|- zjy#>}d2YRpH%%ShbBSj^gRTna;Ii@8s(uAOR)5R*9V~KR9(3-{o_)!&U*P_C1NA;t z&-FH+8g{F24Q|10xC2}Dw-Kn9ofqHc@7Wy?&)WC%YySaQgnCY~_Ufn3XVrheyd1+B z@(9%*^V~7^GoyWCnER^kvo^mA>@VRJyo2}f0k-PzCQvUsFTTy+v+JgQYd(yo9w6Y6Y5`f%3pbS`FGlWmi(1Zjn`g2vRgKGo4mIDm;FMA?C0<+|LeT= z^10&k3%%d5?`OK5=X?A4h3?O~zuNaV6Rcl*|F-*weV(5A1=0G}^R(8xSC3c667SC@ z$z$KSo;>}6(eF9>N$h6etm=mIa3e!M<>(jDt-L3_UC+u>_0}@#lb!mhK6w4iYcIc= zZ~67+yZ2Ayz5++!G_>{hGhT#4a2QHI#_M+LRo61>!+!31`CU;x`do2{=jv%V1MPKK zbDqDy?D6J#pKALx(&m2Hes4SeA0DF5Px}8z#D$+9&8PN7yPh7|pC`}_psT=jxB)%= zkkOagY~K~=-^+W8e9qy8liw!eq4u&nMRy6W9RIT4=KL<)gU3+*Y`;VGC-|{?`L%tp zd5`^3K9~EG5jUXqcTJq(K>M2)X5UZVHvgJaZ>R0m_bKvH-+K$ub*$&2HQqni`8X!; z3z%iUjol91g@;gn3dHY%-O$FLByZ*K=~T~i>utOub(G;aoPx8k3O#*^^FweLPC)r< zRX>RztCwG!XC3=vcmJI&MR2VC!b z@4W_>er_~ggQ5QJoPK!mJ$sF}n%^XK&BF!N3D@8{wDn0};ruk5fs1ejwyIxp^zv)- zyvF_p_I@pzCmVl*^H=ab!+!IH*`GN16r6fHZLdDs{;RLH|JF|PG)4Y%TxW~A?tWf0 zkDD;mU!T(tFTQ85@mBMbzMp(baL~zbj`3Bv2DjiY+=I3s($8~#5iY@XD1WW$H}GTi z@|()@!)PA6;1IO>ef&Pc-VFPL7iNF$X&2lrtep29O|`z!rA=QrUNJb?1os{Rl^ zRxiIc&&jTL-!IScQ{?d)CPhWQG&ucF~q4~&uocNQl;^ec&_#WJcb$ANTpzWXZ>zv<&TkrtNU#t2< z{8+vG+B{2qZ!ice(CW|eTjcymhW*70v+pKfn}6AOOyWaSTu3 zDYX5~YrjQ5)R#%VH=2glzs75vUxynR_A{KX!a2AM<xJ2$I{C~x^>*4`ee~wT_TSp6?}y~C>u!PTZyBz_P=AX~KfL&! zy~bP3@0>ik`JI0s9DueS*@?0X{b-3r`ueyqyFTr`3S3mg5 z^ixj0Ta4R&ciP^Yw+Hgk@6xXLdk*`%G@I`=I_b0Q53xUjb$AXH|BU$O@WT1~l2vqC zN1jgg*!(-KxAE?%qxi?8-xUnO5$M_9qkB{zuy(rzjt5WaPH5Zzays~dF|z=)%>Kd zlg}wUbMm|X6VY{i4-35C=z_MNdF}6V`tP)Tg}SETG@Nnj_3ZV&%=Slr2Wj8G*ynlO zZ*;$qKYRbt^P~5^O@DW&-$~nihIn7L1NC?KdS7Vm%h-*>2{;XB;4Ey_UnNj4J1@S? z-?LjFp0!`&eeycogpV-PzTPJL($9|Grw_tmxB+cGp8a&2>@VXWrvqag6&yUi;oZJ?h5*oPyKP`p;`G zzk~Rzm^jvdUVHf+!SAGrWBuo~KmEl~e;(i?Ec^wmBNIUOSJ>Ubd+Ch*1>>Ri*N)%N z{Ic{Wy~0<`-uAJJdG2=RdzkT2H~}ZyWIvMAzw#)XJQkdMI&D8jT;)^Y^)#G?UVb&s z4-7}w+aWxHcD-)3Xy2F9|2A=U;Ssd?cy>3~XVoLWdF?L({hwmjDf@f;Kf*5h+~drj z=6RX(n&*0keUbA+aKy3q>}IgfiYLE$?JI%)N3k34ko_@!&)_AzhIg>*d*6M3d*AvK z@>Bj-Cja}4{LeYBx^H={y6yFw*Zv}>|84rb56|G0(|_6T8vFA$+3(;d)W7VMzw+?% z@3j3M`756bUVHh-u5RqQf62Sozw8f<{UfjK`pIj5fFJq4=JhSShh9ACRFCYudOB@? zM83+WKwrIlWOss2c0Gpj=dzP;UVHgj z#oroShg)zP+Wx$6y_e^%lW$)88~pTh{SCm9b3OJj9%}E|4Lbg{56p7D3g_S=T!MDK z-nZV%v*zTR*M1*AN3af$;Tb%Kwm)*3K zX_Ngrem3AH+;;qX_FHYTANZwFe~PdKhoJ3`XFu2``x&n51K9lwqx?$H=Ckm^?6;hJ z`kegp+N%$1_}hm^j(^!t=CmITv_GfbD|ibZpq;Ny+n2s4S})sh=Ff><&q15d@C&n_ zC7(Gs57(j1Kd=2hevV)r9>Y6$4{f|GU8wyD{!ifqqwMIqjDN?KiR8g4=Kh+IsWaU*V_c&!Vqz6k7lNj1L*R zvSTm1Va`|JOo#2K9RGcTQJqCtf`f1rjzL@h`__ATmYsa_+V9b~6R7)!t^?bTPTN0{ zNB5r{&07y#fx0eh&h_c(mjm^R_fqV~$a@@4zCrP&YX%zuvO z_64{Em!0SN4aR%_;%Ghg!6KZ2bI{Jm_AA$4lK(Zlfjv&WdF{QvPME$fI`KSx$+6e? zXrTWK_Sq|V4R7EBe1vxX-?!e&v+K`|*0aqwuf6#x)HULJKPpS|Alm36V^tdCCH50i)T zStO5TSj)(-Q~D*RAL^Hvr@g*9Z9hhyigV05xN+8_&R=l;3SPe_doK?!|Gf5()YbKi zqWg6>9D;VfhOr-mWjGF};52+`dN0qalW$)8UEWvh!2_uM!|qS&XU*yND&y;L3m(2F zd*!iV@;GzyvGzyUdG^P=&pU%x@CM$(q0x6gUw+l>ubuw%JN@ajy`8`FjQN@;&l=o> zTTcG6UwWnX3*;S|e_s0;{D=0lj{PaTgg5XOK0v#lf7R@5zs@rHv-p=p`_vtLfL(uS zG(G?aq3!R=E7u>9|1ms)x6sy`*M5P%EyFdq3Af-bwDG=UAFV^LKeoRs8U1|Z{J>b` zcLYvC+yDN*EV3JfLvR>+_5++R!spU^aYF0$^i`+cPTMaNw<~bI^4iyO`j`D0x^=h% z_u&z=>*Ip)Td4I{cGll1SIyr!{b^VK^7^y=w|Vq1 zZzcFr?E9U39?ZJy!cKMA{3kg-4QJpiwDxn1@54I0bnI7h+RM)kx?A|@_;1zz3V-+T zA;W*Dz3goMHjY=%^j{I}51X*cKC$KO7xUOHz(q$t=jfNQufesP`X&6Xz*XqwTjYER z4#FX5*V|w@>c=n~fz#01k1~&AunZ^gZ~J+{__5>fk@50h73FaTFQAPtyK&A>!U|l3 zOYph%Hr~9GSKY~P;IEGQP=dqo4zB(+(fJK%<5jS`&S}39Xupr$0X&4K(B|{f?EC0j zKOBH%xCytQt*6BJ5FCM_dfCmP(>yA!jW>zi6r6#fdew1)?hzKoqjhBC?Q#A99>Gxk zIrf+E8pd%=z(MkufRk_vF2Dy+lU?6hFIwMO*XIe>!6`h0 z_i*HwMc4NzwDWa=-4(pasaKo<{0~FLwebp^?}oiFRIfU!=r-XNwDBewufS;-s$al< z39dlJwegNQe+ow@qW+ITYv0XyFC2y=j=k*qI6n@j9Qz{UgHU;t9edf?JXD8tifijB zeP2}X5FCMJH~}lL-THAS&NSn*a1L(5YiRT7w7+fQ?!iNNjJw=cm=PeHwoR)ms@xT2Y+Q0*O(Xj|N3Zr02bj0wD$9iFTh232=Cx%CGxup zci?mTQ$F|PW#ca~UV{&?%gJ|#^SiKw-JoMHyFKh>H{{sMPW_af`f2l*{XYI>KkWFI z-2wKp8*%Jqr+j4Rl=~(b2yIOgk!(y z*e^Kt3x7l8e-SRj8eE0z(AKlX_!)eJLw{rBw_Wx-`0c`PFC2hHC*H|)lt=FmL>z?^ z(B_xd{tW+@Q2xgp|F?|a!QLN?^6G~+p998+ekigVgJt;K_DAG%4sUbjSI7Ru=!=2% zy>I;kd57kk*S?EBg!)$>H6PMxz1a0(?MuY-?5F;wXx+`gS$F}h|Gf6A_}PNnaL4iQ z+3jJ!4-Xu@XIFRZSN`Ux{xjG;8@=v>w*JAtB|1M0N8mKIpVC*Y(Lug3TZJf@Bl zr=CvRZ|BS>ul-(5{{!@47S^HqWaqEb_M*%`a~~yTrRTb$2=S=e0k|=|8XiNlyP0)U^Y5;hs~k?58+C z3#)J*E<(Fr+NGZ~@fI@Th1$!`t50#f`fB76+Rwc9`}jYGr|=Qle#`!d^L1$T=N;A` z;9vQkWyA}$mz`Ii;&}DhK6Jl{_PJhIgd@=QH&kCjKbYZ9^XTPabv*r zDb7#B8EExajN5os#^>Q;PW>JB53oREmb}4niC69J@<+4MX*h z*mvQ-2P&?OSK<6De1xN)M0u{mP1yHoG+u<8a2s0x-RRooZ<+k+u!jFN*i9Zb&p{`@ z^)~w(C64;iH5c`(2ipEra@xyJKmJN^$noE*eXsF9nBhOvUUte~e!cw5#GQl{IOXIs z%lJ0j`exMsZMX|Bp`DLKbW3nK!=KgHuwR24IrWF+Rfi`T`D$I;^>#+wY4oA>>pETJ zdfI|J@PYNJb*(rT#IyYvN7pWYy6&}4E#ZH~y*VAwXu0mVSZkzpG;cuLLu84aBkN@^4 zzcY9Vuc6Ja4?pelw}ihVcuroI>JNGJIr*$TQLnfK;@!e~X!|nvcSQYKfVMwp%_T(kFe`UqdaW<-JJIF(~G}8SaSTgYTu2&0a(oNA8IcpM+C6^~3lbg=OgF zyMTY~OV{-G!I_WMoc8k5Lx20=xYKXhcX7TOTKzzW^^erAeET!vh1$!`t50#f`fML6 z%kS9V!#u%BXyeKL zmV6%IBkV%g(_#I!iPxPGFVtRkUVVz=)i*#Mq5aHjuX$M`&eC!;Z_Dri-atElv*@aD z4toBqenD~JN>2STd7Z-ZjC?onzXj{?7~1?U8NY(paN_Uf`XXKzwEBmf_J{aAg4ggy z@l1f;zc0$84-UXlXv_WAr znp3|{ew%PRBVW~dNt|nV2W@^`e}B}^9ykT7a2_thcIy?l7yo^*2nXRX^x|8+>_^af z`D=UwyKT7R#FO0?=P%*ad$Qjp?h)+%2cr4xg|=UL?GJPMuVa4#`^cl{fLqxd-|@7{%vqwtG^}ohce8&-%S&55w5`vXy?P) zuV>inIWp_{&WnG9f8F1;f9w8U`Uj)+KM!rbdTy@qyn6|+p?&UEp8a|rH4dlHwaZ_T zI74t0mYw*m+Lw&~u?+vA_Oes{^6TY4Mci3fg>z0mi;N#YZygLc^S_F24X$VSGt*tz z#C{v@=F~rMT^7i%8+!R_-Q5!>Z@pTVb=K(()cZ{NE%5$9@3Z=NZR=l0-!6Xx#2JJm za1@r|1ho0IOJ6kc#xvrD+RM(XPjS5ZdU!wE4@+pEw~G9fA$$afQRrB4*WyW{i6u2zK-1qJjYP7^ z7w{5V`#Z)&k zDLjK0ZL*i2JNf&usID$(^C>ev1*hSRW52-o4%~(NZL*i26Z~DkOUHk)#&rva;0PRr z9Se_Q8Hwg0`Mf#^>PzTxyfO{H)_|8}2y% zuNc39x9}c5z^-2t)ottPXM7S?;B=epK%fo@CMp?`xqYyv>(TA z0#3pTwEpwjdwype|5e84;5=N1v;TP1k1DkJEn>F}YdQ6bbBJz+IEriIZDF?q_h6`A zb*vNT7@m0bF}@6IFjT*V{SMrNifik;=lmn=|8-IS$6%;^5&IGx{*vmascQ>v!$YTD z+0Sr(0WQIHxB)kz{M-J2)%?xT58JmD#?}8FUfX`XcD?GXQJ?DEbLxF*_R4#We3kdU zlmAPz*LA3Mc1Yg+>(M@G*PG5?Vs`}};3F)c?}5+duTK2X{CYF;lfM)Es@@ybX&Us> z>`%$_3@YziC;yjbe?gv_&pTe$lVPn&&y@W0ZLvbLLlhYaJ+W>B{J)GxU4J^YoJ)((e*i@rQ|{{Kt9i#h307KeF@c z&1=7pU-_?)kLO=@C+IFx}wBK z-l1N5z1#Ks+V$F3AJ|`esk;x3z)@)Hf9-nJU7)@$*lp?_bLxNXdarJ+g8}L;LiJ(7 z>Bm>ipRN|U0bq#Ms&t)TU4BGu7uf6&CzB-%GRCyw8w#70$s`xDIVSuU$V&U8;MD*UNAVZbMuDYu7JQm+IC$ zZ#eb7G<(gH)~WK=yxIABY4&~WgA;HPPC5HyUVHhO$KO4CaQw?|m-8n^XZu;>{8pg- zDt7C}{)X4qf2Zx0hw@h*>XXgK+TW75XJ7bdc>aJha19nVqw{^x#*@Aa`#v}zy%jLt zDSP?tHhBy>`E=S|d8jYSV}yLv?^WeTpSzuYhx)6@pXvYm)+?{jdh^=Luhy^n=&j#Q z+iRXH%tw)VEjjb6yzO---5|PhhJJ&1s@v*EI;3AGuHyF-NAZVv?ZuaF8$Yu1>dkAv ziC_62B_Gef?Do;s;Vm?mS7C?oJ!60Qp6r!}@>d>S{?`7AyghsQJ+yYt`pRp6fM5B) zQy(4wRmSJxD%{O!zx7J&>*RR?NB`OAemx1N;53|pC(y3nQ2jdk4Y&<=;Q_3}mlCf` zK3V+iw@?C<m9s@ee|KK<_Ff9-m&Zmoky`cR;L^iy^V90d+QyI*RpFfDe}VBexCyr$`yC(y<(GTy4bZ!4<12*=?BOvPh-2oA$B$A0jM_M;j8 zy*z9kGfsY!j91_^^z5sgpM&#o9iGB7X#2Ow_%f`)P`&I9(49cVwehw%A8N0>AJGl{ z3(@)*hSvWTb~o@2hU&-gTZZGX3K!r$wDEiX#VEgC*at^o8LmL9zy6mZ{n)=8u?#2R zB%Ffn*545S7T&=wC*A?$J^u=I!+tmbOVH-~RQ)0Gk6<01LmO{qC(3gL*5E3%_EpB` z;5=M*>~9(G{a2$neXt)||M%EGz(?5Q*!TZyk>3G02*=?BoP-rP4QJpUwE48l{}%qY z;jR-eG~abcKgGD}tMYoW!}fEIf8`lkzh~#o&oOa_|Mh4cjKDEy=kpf(JNN**J8b_* z9Gg#xxS{!bcH>U|2aKP?d-&+s%kGNv*YL)%-`|b;egkh|@!wz^-a=ddQ}v2d!vCd- zYvbj$m*1+Xw`47M$ zI1I~h98SS$I0xt9GF*Y{a0BkZU3dtO;3+(VSMVC%!w1;C7xljf4!|NDhF<;WoWFoq zZL**Fx1+qa;2zwEH~(&Q{vO)=Jlz3$Yk$u8z`qmuEx}{>((TLSISrTL3ar6ZxB>U! zAv}V%-q-Gbm~}D%=ivfegiEjnx8W|_gSJ1f-GASHwC?-iIGljC-XX?E;54klIavDl zBEMEY9e1rw`z0mV#?dLP>L*sYjrzgYTHFfur_Ygc)9cDp! z_QTkZWaxW1uXr07_7~)T39sP5fAsG8@$7pY`)S5&a2@VB_KS=!!DSe#zsCL+-oZy` z+Fi(NKl&d>eVKwwa0god)_w!KO}Ld)Kc8XWa~S2<2m9d=9ERg?7al;Hf4lwl5=Z%E z#V=v6{6}~_=H&Yw`)K~X{uKU`=zJF(f|JnBe_s1h{EWde9ETIoi#NdeB0PpC(B?P8 z_$;i#IXDj&pw+K1UW2P}4X(otX!V`?!yBZ8vhpi2UsD` z1t;IU_A~gIg;h8Q=b;y`oAW)e5B5Xb&k@E);TSB#aX103zVM$#^R)tx;Tg2{-7n0( zOgg}>XE(- zt$qr-TA=+*i}p)_{%5gU?2!Edez*RMs4si}WyE`^K8-v5lKv1s$M6)|{(5#d*k{F) z-@Nvhf&S01>y-U1{x_X|+kSQ0eu6wEVFgaXS-1>qa21}hPHv#hU+ZectSeoIT2~X! z`jUQ|csp^fzChW}+}KJ9#T+J1;UhT#Yt zh2wA*&cS)u&$=6S*554S3vdPQIrde?=Z*c=d$Ly^%3pbS`CI#K^7icIcgfhDIrZkX zU&N36@ALW))}a^git{({7T&`L_z3O#4b_$YE1oOhILzzssrITPG#}ab2j*YEuBSux zoA}*_$FTHYNBy0EQ_%LS-TLz<#(!V>ZSwA>PwJo7uTcAI{B`{|(R`HP5VZbf*UR}n z*zee1>HKlze*jis|9{IkwDF#*SDY#0^$@IUC(lh=M3zbkMRDxS^X z+OKEWZ*zVZ?!yCk1s|Y|cgXlDJck#Ky=SL5)_;DS7d)WQoNA@c))P4~A5jg(LdN1E~^4NfzaNEhR?}Ymg zEW#mZ`;pgv6+dfm58gTct^G-c{XXXp;32F-o4@tHjh&az8tZ5SZo;nr@!i+Awcmcv z_Q%9Og=g>{+WvIfev!T{!DYDa^z*gYuR8fZGT!$;MeAi8PC?uMMaIwIIlO@5zdrIa z0j<7<-9e!JT8s9(f&SOA+v$+~J$^4vqrN;s+owsVU(!F|r+~g2+WvZWCG0gXUOf5D zYu_K}zX!Wc*$?9X9NK={es$WuMjoqh4X(p2cnIt87#3L3y|AYF7|8D5T8|M5d9E0O<0!~7^ zenWMO=-1&!i~jP)xAv+dG#}Z|1?FGDZl*)_i@z~iHw$MGYj7XhdS(BJPWJ1L{R(z3 z#r}wVj^PQsg|^J?{^ctgY)b>iicLh4=75dXu1Q=lJim{W5V^U=40M`B?ka4Ew@)w7$DxFRa3z-xi(k zgQi`Dr|P?$_^-|F$6ob>)_+BRZ{RIl!hcr(YS`_=BX|LA{o9Q1 zz+D)s@BOXOeD=cuI0$XLy!LbWsli=%?)bO%$Jm{~)13OP4Eqx6cn}W3va`Nli~XpR z{~qJVu=3lZ`JaV$z84ukgXi!9R)1%tpMzFk!|ou^eyv6O-9Z2A*zI)4{u;lh7g1l% ze@Dat)2Df-U((;;=N>*n+h5PFpZJ;=FP{A7weJb^U%;+Y_5=7ofwteaU!AsJB9CRb z0&8#`?!g0i2p?E4z0Ug3y4pAEO4p(0c_Bl8M!a))32nbTyGQJ^;(7Y3obfz+jfdtV z`@6vWud(ZteSvx0bLP{|N2l#)$YT~(;T&9q>u?ip!7}S^+F5_AjBmnSc<$J*F}`8! zkKdEM@=*TD!^_{=pOCj_FTdNy?!l=yul*K&lzss;MkY_jSg?+FLr=gA4&-f4=fuoMSXQw#Uf2ZyD$@2t0z~SE$t;-6Wfi}Mb z?2jD%bK5Hq)svOKwV%qUSAMTD`ZVYC>lEF&qqqI)w7v3BJ(_1Pe``NWou2&;=Xc>A zJb|{}eZ~*qVTOJ0?`56B;_r)I4@2vJ9lH&<33s5i@4Jfp4ZtECf={)t;b#@@!8^yl zwLi(Q-{<@RJcM;<^SA!DvGej-;QR*M%&=c#URK}+?EaslK9}GKwD~PN`c1~I{T}0W zcnnV*d(ZB|u^%VT2{;L7o%~;m{j`(+DdX3$@Aorr(Dr|v@ol&RcVXZE66yP))lXqp z3$&kU(S9k=|15Tk9kM^h@9uTfms4o_G~o10`V;(|!3${n>)G97uX*v}$!}i!n?V1U z*mcVO0slKrziq!dZ9hdG({KjP!g;s~*Wm`dgWb;hSYmt?Zo*^7ewp!_u|IfE_R2%~ zD-SP!Ykx@Ip1u688@n5)-n{l}_>un;UZ24W=*8>%U)e8V5stu7I05bY_4Fm|2jMW3 zzw&qdy=~63zT)Js^W&VKfU~d)=inlIE`Ni>3(apS zBR}~Y#!mHCcy0Humu5dgo}*BCPdWL&H2X4nYCflVJ>%s6((E_L^8}v4b0`12_VRO! zKRt)loaZsw4RU@0>N(D?=Pu3<1lo6F*K6$Ocy0Z6+Fp4mf92uTYwhRB+p}Ned>!7v z{{JI-ep-Xu(AF>gI=XGR3!mFwd2EjGb3+Ui%V$<^P1&o`2bmVK)hvpxxhw86P$FbMMJsc_@G7;pK1b=gHf%m)~(? zx8~HF*S?G&`CsO>=l`DbJ^yEP|LTQBXy;4z1HBy+@Fmq(scR7~!9AzmGsZ9A zC0xCY`aSr6M;w8+-|t)hK)!S2I}dAt`Aa_>Xg`Tv1x`W5xBYo(_M7Cp1-t&QXny-) z5e~s&xCU)~q53KG)36HX;SyYdHMk02YW!aE%j#cf{aN*T@k-<|2sM9pzFxcD)~WS5 zO5L{Jmu9a#%j7!=D{valKwHmi*Q@Rc>a*9st@owbZ?kXi!acYT58x3zgBQ@&_f_+! zzSK=$u6TV7Z=8O;cD?F8p+2wfd#C=_u2!2EQ}0W&-)7%BhZpb)rmpXt_VV+9 zPS4$=&hvMf@fkP==N36p=X;Oweb{vu z>1Uv|*ZCsnOK=2^!3kJ_Q*au-FaO=d56wR--yZz+!2#pn_V1^69j_@=*TD!>iZYPh|9G zhV$$25Z=I<|1X-41!(&#{Vetia0x!Qz4EAWlKQ{k|qY^}FiyJJjEm zQ}6rME3eRc^V-X=*01{Lt=~@DYo7O*k7ed{#hG8_t#zQhrCUX}ouR)Yo~PgFkp7mq zioZx4<-f*jFTQk-_>rAgZ(jR*{L23(`FQ?i*Mr>voPc(JD=^+|>_^{|z4B20%EQaw z+K-X9XD`2f#%{)`H?Ms!e&m0W*Pj1l&R@bScn9r#$^MM<7f||ZUf+I6^&@{Ey1$RZ z3AhYxzm6EM!@>JVKL*EP1x~?zX#Iuim(VZ6Rk#kf;11k{d+?>kA0fZ2{)N_`Rj(Is zf;=Xn=FiU8YuDR4wLWL4+t&Ni?3HJgd>7y%T!t&q*7Mr+s(YUL?DcQ!eQEZ`?3<_X z44%Uacm?m_BeeB>)%>Y1*QPIBtcPycpQ2t{0!i45>_1l(~K{|6x>Wop(x+OKOC_RZyuu8cd+(H zqStHC*4KrfcKI8{-xAyd;vV4Vn7AkKL2>EF2HbM`vx=W~`IDbI zewEib`4z}R^QOFZ86W>+(R{8#+rMt?dSI{dCw=XO>PMY?SDbto9Qz5!ev&TK(w@)%TK@&G*E~cha$6bL`g{-+-HN@0HlkF`tL9`%gyeq8AnlAHH1@ zebBCt)hFuhyz~)w4lWb-*oj}I&+~8ruEGJw-_a}em$#lNr~VbE{u<+}a1Cz168j?S zQS17Vbw` zdhUWY-$Uv;f^}1;^p`JGf8*qP;pAJSFPcZyx9!;PFun`-VEvWYFYp|^4KJZS=g~S@ zqc3;VHOlk(;0Mt@I|A+cS;F56ties_`5*p@_N?dVOI0QRkVL zKIi?}OS9LyzF@s=(5DNib-YYHTE}H)J@4XY5AMS(|4UyH|6YF=1M8Rml=;b;582uI z9COxZnelNr0cT!`y*}5r`?KoT{;c(^{lHt#H(%p9`NN21I0@~3-jDs6(T%prejLB2 zf&OK`9B99Z-4@)22hi60((F&^^Etdw-@BsuE5RXX>*-;`xqa9B{&2Z;2vzZz8}9{d>d~O`(?NSYtY(X zGkyc_VE<2v`eW@6Ie!ABAI`8p541nR&oMlKm+%VS!|CoQ&nmR}w%cEwxXLdp{yFx_ z|C-mg(B}Ic`)EGB{_HZ(kFfuzM)o6c3eG~?-}kLQcw+wVTYv53Uvm1L*M0>*$FTO( zqxoHjc0TX1oBwH%-4b@vJ-2;3#_s3*E!$6y&Q{mf{*2Cd%Hjia~rRmS(=0i607 zQJj}RVIS;=C0K?Na1z>jU%UT0bzQ(m)yewlg59tW4#QD625o;{yZ?Ra zD*mi!z3=u$+=mz69lgGSi$6Phy$o$X?%V8dki6#LCV6ecLGl`dHlNWa>J@hfKL^A; zgg3;!gEjiH=JaO?Kkf1-Kl}JqUdQC8yfkmhYm@v&`l9(SVA9d`<7%#(dIQ>fOdsru9aDaK%b#?Z0qV+LAJ*z)AdVL1%dg+rNScD_c z^LO$}{pGEvn?Blpt~vFuGrj>g;od8;*Sgx!dZ7M6sC9Jh)Kf**s{R6fKkIskxZ1Z4 zeqOYmPoQ1TH&4{d@8r*CpM`a3YfAm821@f}_9y{_@r{ z?$p2F)W6915?qGsuf)EW^{91y%R0D+@w%cfc0CV1Q9qAgT{i>tZ3b4M*0qhlh<+Ka zz)iRVJ^!!GU*38yo%)N;`YbU%2!~+#mDuZj)GhC)PPqS{LcMR==6ynm=i?!0*FzmY z?eZr-5BODHdd~6k8YRCqJ$FHy@Bh!<`^UGoR(1Z-TZcNgVw5sgEEuF}#Q;$QM2Hfd z2t@*Bv}%Ef5sOx)13{}+rf8I)0Xi5oO2hzBf)p$opbi}@5};zis&TB?k%$2TQ#D`B zVAblkGvDv!JnwbJy-wFF*{98E&%I~5qHdps!8XP<=}N{uRwX zH2m%veuK;8eWboM-^C&Om;4>>&!GDuI(xfA`8fKf%A36)eU!R8L)I7l@{sx>x^-BBb*THj zYWf}KybJeWA5K1)`w4YFr|5!87c%ssle!Uf@e%8zM*YY`Tz|{37jo-UsQb;K+k_2t zJBGf2t_%C{1fIgc7rTAO-~`nBAKhe~xKXb+sGc$)bylgj4v&obe)V(ISyuJiM*Yju zSMXDXb;F;fv-+{-dScX{eyBS)S=fD;Tlb;5eSs3XJ=lVWQ0pz-XJZL{te z^<`hJ>l*qP`)}S1&PiUxX#&dAL>j zIQu8yoZ-jP4cm{EpECBd>Q?Wi`Z|3zU>nMNQ@_u~XWV;k6}G?Bt-G-EWo~^0PvO{? zpZ$JJU2wfT^_p-WUk5OSpDfhmyD z&qH*3=qvcF!A;mS{8z}k+5A)TQg_M3#uFc0`k6P* zR}lTp<`+00Rk#Cpq4vA{aCiTUumY=4>sNg0SAFU&AIYzDJ~MC$YJca=-@e!#>o0Lg&nveM{6? zWuLrI&85n^ZpjH-P@ zQRgQL_5Rg!=I^rKB=xJX4o_k5(awk7zkAO773#0U4Y&>UerxO}zDwvTDsSJ&FP}4C z>h`FA3}sH*ubk@^=d!^4lKbA`x#$|tM~%Fj&7Y)h7^dL7vEM28dFnCle$T=%)cuVS zA67r^Q*YHhpiU2-K<)3m`AO=whTKo|YeVWQ=&G;=x1jFls_COKcTQH}I;=qLKl@mx z&%qTqt?Cp;lwV@MsUi0h{T_MJr{%AU?g;i^!06|y>8HQe-Jcma3)64~u0ef&GsJUB zmpAmHle#5z)e-Btwp^>uEYfx6!ox{1d-T@c;0p%0=?8Z?{SMHz zVHXaYFMY(=XBp;<{-%k~z%U#(KZ!mC=b`MY`zvw11{-h>UKRb0;YWNPaQzUTUXWhu zj3wN;Ou`h@^BJ{%l6|LO1D?RGZ*o2lq4u|rt_{04ncpJs03JeXzhU)Z>d2f=Stq{1 z^`+}i5f8%%j2e2ai=ngX&$E9PF2fb5{oJg6LDkOL>9d=TGkE*uQt@Po6K?ufx8%P1RjD>igB#sj~%lVAH5SYQ5!S-|#bP{kAa| z%a33E5%qi0-;>;XBntKWOZJU%Jq6Q-etpi>+lP@SyLAle`kU10K)?CN>=UMb5~hv) zlIT~V-~3a2#>sD~I=a8PZ+899!v&auTAwAp1ef88p>L;L{SNHHBdF_NHGLkRCAbZD zVEC!7zX;U*Tz3AJ;d`IB_IuUzIef~w7&PyF?n4V6z>aZ${OXUWa|}=5sZoF8Tip2w z!bvy<_581zzVS5YzX^|E4`%2iYxHy3`CY^JDRDjjtER8vQ_jVpd7sLCNW1$s27^%d z>sLQTof$X_!$$o)@h04ZZP&Y5^xTtp!PScuLUDNOS}P_ z-|F_Se4AqpZo`Fn7hi!&j~z*x__xZtlrWM>+jg|rTSYj=5g8i z0enfn;?uf+TE9xZrC;T}T7eCCXuNN4R$rjrIxG#SKdj!;4ckxA@Kq)*^Vl=|UUt6t zlzzphb^o+}pS~>pEaxY!&QXoEe!l(crLMe}r0%v+f9BiW=Yd%mgK?<+ED+DaC7AvW zS7!@0;h_9MdZ}MxpE9gKT|Y;BSiPl_esq0HpECL#wZ2KeJ(&kS#^3}D!VsK+voHyD zzqhLXf#F~K4dXKcqc8^JFadQx3&b;U5#|iNrCUc|h7}`!mv{>v!Vc`ivF~)xkM?`s z{5|T+{%y7Y@qqmgxGuhrSc`A%chvf2=2U^51vj@I)P6+QKp#XmY3QTGV=xXAFb(J7 z0$hQ5|BJ4-&OT*Wg>_^9QS0S?==tvBXVCp=a$k1g9^8j**nwRbF#5gddb8{|Y(Fzk zcjvJMtIu@n8r0{*uRcQE%^~ZLS|9c4NAxlB;xG;Md@Nla{h;|;`SU*av-A=l){p3O zL;7DtH!A%)^~>T1)}g*1E#imp7@ipVgAwb;pW&XbAe@BLQ2W=q5W3k*(#yVK_K(82 z;peL96ZlNRIXG|lxBAQ*`UdeWxDA_zUe4#Rdac`|?y*td(swUOf6CXD@r-*8W?>lW z^B*N1gK?NJ^f}^9c<|kBpElI>tKa3WN1x@@EoI%h0gs^0Z>ju2`X%;RhAVIt>iSjU zMf_I`Uwy;hHu-HRee?$CchR?e=J(NCeq~?Fug&_AH(_){TO-U za2o3KVd+xn2la2|hkWj5=_Nj_AJNB$^dCVtD*XcWvv3LKpuQgy-{amJ^Dz0nZk>i& zFS1kS?()cxG<`61PBhV?RBfmZ*wd;SLfZNdiJg)JB`zTVvK`CF>r zL)IPGg+17Z);#WO_3E694Y&<=jPueWeh5R0?(@wo48thY@0%`pN3aL`Fi76CkuUpC za9!*D`iVTp`H#V482>&O&%g@Q{Y()bRxkCkR3X*drT4gC`FWf$QLJVcowKeAeL>JU0A`zO3}^0s1`Gi*Wsd^j6(r{S^#fCE{Cf-|&0c`QlUh6`$7q z(E1jAS$e5kRk|Z%9)9%|>PY<#YpcHK_NEc#ezWjromQzsJ5UcnCX& zpC0i(Jb}|c;?D6bjKOKnwaihU53Am(v47}?*#}0T>_2Efoj*vwPW^4T4_ojMwqXzU z;V}#{58eN*s$av0_OJb(pgV;De2>9#IAQc7_d%b7IQj%!H1b2lt^DMO^TpQ^`?O#i zPI8{*-01r$`8kzu=~vLL!)>?=b$!w2N2Fh+uGHTd;3vU6=3o{sLhXOl`lL@kY4i&) z2MbX9_p6^*^;ZVe-{g89?*5p2-?gCjGrh|D5Qbp{Mqv_Obbg4sGehoY>0{)_VFGHu zgYwU-w|rRhyK4Gb<~HaYw2k@R?)h2zYQjC(GWxw$`WpM!;iloIL3~*MS50sEw$9t_ zt`G2D&cY>_Gv3#?N}pi=Bup88(!_`Lf7SGs?=_>}+g)FvuM*sW@;O0&{X60MYd?MJOf#PdjKVlfz%-nP3vdNq zR{b&d*Z#HN47w~_giCN4=AiCJ&Z|Ce8|Vj}mu2pM0nRZ046MQ$)cec6H=AE%-#vJ$ ze8|4?9P9lhzj4m|GWk_l6Vmsf{ckqk%Cq{>{Z|a%b>cG5DdYZKcE0$Oe#NJpL*1{| zPt%vB&-0$I!EM+v-v2kNU#DIfRtD4`R&VKs?Wbh;suGuZv<$zOoi9G6U-4<(KdnEY zFH67Ab8-yjy|-pOFMjn>SDr(uTQ=&C;ddNPz#!Dm!!+>_oPo23e)7fc^G^uQzy#Fw z{puH~vjmr64z9p5)caj_{vhAl?;d>|!Xwx-`Wv<0@^NDL8MVG`%*FEKSKpz27xtl5 z|ElRH3+{QGf{U;M^?3^^-4^TS0DX+>$vgSiMk;e2G`|_<6*lIl@6V|9;zRD|Apcsw zO&`{Ik>{q0PU`Qn*8RqR+MVAu*nvk->oYHL`V#b;U#D&x9?L#IgfG4_}GEfmpWe?Q0tG;jTN1498SO>48e=eKVkn}`aK{%$$1RHS>t@p6VJjjlyj}m;{n$X;Sub?TdlWzjJ@pa_r<97 zZDTH$AHVtz^}DbSt@>9@AL72uz$9EX?pIjp%B(8`^f9jA(R-grIVWpsK2>9$5^r#Q z5AF}pZ`{#)2hXbaa`#>euRE4t1?r>;^aes%Uagnsig8gXXsR3U?p$ z{BHOB9&=o$zcQ@ADy%`>|5eEk<1YeZhTk~x6}SrXhThWM?7Z%4^@g3(rZNBfdVY(! zVao91S8vr_H0o>p0y;}y;QBhO!Wz``9JRja(~tNr zE8n|@f4}+?b)myG&Sr^59OxaCv7Y3QX+ zlk3vwA?qGo{Q0xL9~(A*;hgz>!~ZOGBQOf%#(sI?1-K5&7o@l9R*m`x#1G-I=*nl$ z+tQy(o;q;j)R};jaLTB^N4y1>e!=-zfvS99m3R?W;pPB+Ug>KWq+g@Xu=PbJ{>6vo zf7JQ{{>4w7wdF^2dhQ3tJVjqpb@whvzfK*g-(bBBo6y=%@}wWpS^bP!U&gQa*=KF} zIpq2g9REf4{7gap{D{7z^b;4PZ&P>J`l1v6;=}SkYJFGDGdN(L;`@|5@f|hhDf;6P z>3h_b`qTKBfnjL*Tju&IEW$F>=jn*}F&uvt=MP3;8V;KuRQd4{<@c2T3HFiwqpYp{ zMK`5%R==axPvS%TBv@O1PSkx1p^rd)zeFG4y69&vNPmi-Ve5-d&Yk$M{Eu2c#vH`Y zENjb8m+QxHqT-&PX{hHf`kvAUFGznx-C^sCPW+1x%m1kLeKpU?0rM2!V@j7Y<|+D9 z_K`kg7om54D(|WCwx>2LP=ufFH`YA)-BHo54aO^c_ zKW~=))Tke(P87yr!l*C0n9?N;{S@&{*o1qAzEAuFj=k3PIRW+jCyB>k7ak4J&vHEi zqi|6E6uQgGxAv9(^?dH=-TATR6X$*=VI6KlJx@7r^IWef{h;%+f_@F=VNum-u-5y_ z^RdtMLHiY6=lUV|&R`3l1*jKL~w!hNXyj;dae{chHe zP_}@+4*UF zx0HWt{=@2v+{ZfHgQv#*9ku>|eGg$9b`3w1Z*b>v3Wnee)brUSeh9np^pf;V_T7bh za38kd0o45jevSU&3M|9R(vPwKIGlh%I0?1CsW-ZQLU0y_q1Icv>?P?V>>Gt~m@xcI z5MP8FaL3SZGPfErC1fO9Zq_?g&n=OGBE;55|dVUPGB?7^8gxjMI6 ze=0uNe+*6-elo=Ka2?h!Nx#g#Ik*bf3_mBti*I)GuE9;H=YOm8`62yGpt~yiBm9Ja zoq29LZbCiJ47xI`!aBUwdeevD|ElS?nA;xQhX=3=14ci$d;TPS&B8E@!Z=)l`h4B) z`APbkgDE&~^y^nI^Rx2wJX??W%xj^_BOPm>{ETbsg@?Fx7DgWG*22YEx6VPSQ=?Aq zQCx>(U**<882)PN!Elr{j6K?|6EO1_x6Z;fn1`juy6ZKVh>;Jgum;D!)?E+649vph zJIe(#!l4-C9_El3Ul{!JJ!n;8x15n=tY;w-zq5 z&cR;VUGKxCdAH8N>F;ps5S(409^84lTQ}j_Gu%243$O&sum%&)bb4WmbsBENCfv!e zAB=w&`7rw|w-)YY-MR(Gp6%8_IJM~3AvpUSw~oNM=el(oF1*04vvB!EZk>aLA9w2# ztp9{tH((*pb-4VK~2da*d*Lc}rEj(r& zc&*dr6?a%S;T~+kiPyQjAUuQ}cm(?}T*D7Mfq`Ff@o5->i!cY*VF~WT7R>yrtCNLQ zScBo$vp-yhIaq)tcmO-_7zXODP7%ZmJ4S4ttx9-5!HhQ@KPS&vh+ioqK+;Qs= zjJ(UOg{>y}F#8_27M9=Z)-_mopIevU?C-jD1Wvu*twV6(18$v#OCNOW94x~cod13F zaOw}K2OEl+KSB?;TW;Ni^*?s&2Aum7w@$<954m*+CSe+8|IA$%p8UC62R`iBg?(83 z3l}fJ)sMJ!9%er3)>#<+m|G{{BFw>=kGty;c=QRk?!(q!yS1?Jw{Bg6wNJUVu=)?I z;qGU+?}J)!=`Odmb~LO<1^}yIz9%akmy`KijQ^dw08a3l{EAKHPecTQ}jt zH2LuK!EPOR2z;oQ{fD`=F#T}17A}3ITj$`+BiuRy_aEujEx7h5x6Z@Pqup9~@))-c zJl1h5=GcUp$GLS@_;sw|!q>BgxhJ@_aQ%sHU4pqMaUB+(%yrm?9oYD0cU>5Mid#ou zUorAjuEWWvxpfF;zs0SE$+TOi;rO?^br6nyCu`VSaO*y7Khv!{u%G2RT>W0R&cp5^ z*J0)R+`0y*e!#6mF#cS(PQb}!u0#317oL5-i-%v}7=h&0^+2z#&(121;hg$>ri>6f_cAsGD`w@yI$_dOdgb#eLk z&sr~Y>+ZT^AIiU9)&E%+m;c_p#eW|@#(z&6g!13_=J@YOQ~dXzX(<1FQiA^;B>gH^ zS15l!p02p~CV$V?fIC$eZ$kNduhwf^{D{9_=|lN_eV^aoPs{IR;SOxViPyV2L73t9 zBU!le26sIV<>$%GH@bL*pG(%@!JAyX16yx)YoYwSsr7O9{bunKjyHUNy6N)T@Cf$d z2^@cm(}iIQrr{FI!BwdDlYKg>ZqU%Th@Z;!-*7(0VD_zUy$tn!l7C44ApP-x{dE01 zdhh+v^O5^B&iz`31z3b7sPogr=VALd-G0f2;~Y#uoxej~6Yjwd3{o!)BT^sE!8FwM z#h>(5p>EpnBl8HNn;oD(kvg33BwR4gdw}?~(#g5k{+Fr00%bo-zlN>=x8W|-^+&DG zz0IA2GOWNVtid|mfSXYJT_=7~^<))_J|?dO`f%tRMLj`eQH#H{kZW-1S|k_e)$ceGor0u<}mlKlR&=oAe=l>3+_e-(bJFA@>vgF?j?1 zQFjtf!7#j`pDU*CsQXgIUk%n_L*m>onTzi4n0j-}Zvn2u+HIP@GNk_iI^F;6k{>br zFA~@H+pk`p`+3e&1{R^N?^nM_og7?&YexP1nqI$8<@ql&pJAVWd0z*A$GyixP~Shj z-vRFj{XQAC-pr2MFAC#u73%%3n*Ny23G($&zP=ygU*3=M^?lHMC9h9@nD^@(T!Jf5 z&!jeI??QR~Hr^dtA#@~`!)^kL~| zc&^vs)Vulo26expk1Bn_(9fcaD1GFT^x{MOix11c)<^Me>7{Ohenpou`t_@iNnMzv zu2tW9AIW*BaX$3>XxQ_x$NTQ0>UHTWsQOA9^Gkfto!1Pk!fkj6yHKC!IpS%k^KZ3Y zd`Lfo{A+!CK)*{|&qHfYeXi^Nmx-?!`L|jxKBOPH&z66!KcWvyU*+6w!ELx>oX1h? zEgyZukEQPz`n9Hep4Qs^KT6>Q`7> z`U9?aU=Q}8_7i!JoBt}@hb^e}G2(HUglRYrbMT_;X+LfD>B1g7fv0fly{^w$7>4Jq zr}K-{t-vbWH1_kWFZ---`Pec1_|>e~_p9H0zpK-Ld+-qI`b)%D;3_Qs z-r0VtdoEssb+`$2{n!Vbeii0n0c!oCPkre3UHw@Yg>k6sCy6h?$$ghU1ugvo`Yc== zGJg);W#wD@O8>gwJ9>8>tobZ+KUd%ZY(qUyId287x0HU+`KzPfgblc@>U3D^{pI;M z<@%ug$~*^ExC0N3=VR1*@v*`F^MBy(PX_9K*OcG%0R0Tt!!QD4P}eULufjdpy(E2- zem95oGyaEeeleJVS*ZJ+A|4%)ewVs?umum`A&mWz^SuBwQ2QNqy%76~pF#WI(R(K( z_p{4=?Zac}RR;o=ZhFY`Aa(ufgG1Io!S~pR^as>EgdNz0M{usi*DbgV^*l#iFT%d! zXVCt4^xg@{{XFKr2AJoVaX&3x82u8o&V$tTs}BuXe;nQ9i1ho^o%myS{-3vz-3s6x zMBK_huU`7me!AjkKz}m7qapQS>P27-CZO(Tjray!`;eP=5o*2Yw$bmvU3dh0Q0H$F zxAM=cmwvRLEd31XPv*Bcq`rY}^3Ryt|8Oir-A@|b0X&39um?}z8g+{IvU=?y`^%uy z^SWK~*YRJ1WmtjweC!h6gZt3xf7tw%v7fGMox|dxJJ))@+dY4hzUE;TE*br967Rti z(HYNYn0O4XKzXk9JdZ^G=WgE74?8BH*5}Zzz*Sg)>#z*(prmrMS!3DSot^V&V z`4Rez!Z^$g=s&@AYkvBCUp0Ll|NHO&c3=-q8PEH@C4ZYfci=AU!xMN4t$FNm-I}L9 z4_8g!*mUpd$!*6Fl>h!fxW(T`HDQFmBbT4c2qhknzlVVG_dOwgUoO9|@AG@}BEQEg z!3w{Bslg3?&(MIo{5-n_<>$eDel9FO?-gIevcu0OCiuQI2<7|V65rqL^SP`A<@1=( z`g)oDh@0~wT!yPK4+~JApW8h@=d<4>^fIR+>xwa-tEQLxsD0NB|5r`FkIzF`{!4d$ zgB{0JSb+Mxo;Sax_OJTfzkbE^);#8odF~M3A9B8V`n{-nJ?4M2^|sHMe?Z@DIQCI@ z?#7`$Z+`V1>K@5_sVn>F`hNAhf9?Dp!Y+*bjf?C0e)TO?|71XYzxpwJj>8E!Y4~3u zz6$fOVCbhl=H?KB%kT*1|H@rohk9P;&7W5LulU@5?TYCm_?d$7f?}Ycosk}Gvd9(f+^tA<>unqNm zEd2rc!<)?CznA0>J1^yNB;D?KI>ch5c|%+FiaSJEPWJx%xC`Xu8$Asx4`uhEW>TM12e|^b%pDzaBYA- zz~_|}xC+;xeqIKBAAeud>v@d2|69G^sQd9-U-z%qSFPT8{oHQ(e*OB@>-(+OSFPT8 z{oHQ(e*J3wO3!_+$-@$?z$)xRoqtE~=C{dwb_dL>%ym8An#%98*7LsXeDNv$icjl& zX#LTE`RMal7@&{*KW_eUn1Ty11J|IQ=eg`E^{@2@^kJR10N1ym)bFs?{VwWui3O8ZH@Hc9`W7T_MdDSMICehfU=i*?z2ABB zE7YyRI@~b!+rVc7ZozG+{aLyu`p`ePewW}y=f|iUhe?il(U`T)S%qau2aM75b zrCUay!`HUq@4Wd%>aN2wtQh;rIm|16JBGfEt^iV11=|I2v$LtfPeiEjQ{gUWcq2K&d ze8$OdsXDqp`MX&8`>h~LwE`UpXcg~!ErbN7vVBo zhtj98Nj(1fE|P#rC^}*0bKT&UU>+8r=!AatOF>sZ2UlPXN?l=}`0D4myfs*dq7#Zf z$My9~)}P>iSU;!egZQ3?vrzgJCW$XV>9=C&#fP4!Hoa>*>mo{Nd796`Dcy$wI=sP$bG3A_h%Q~A?(6Flye|VO}cZl z05dQPMJM#Dx9Tn$_1B1>iVymf_mub$j#^*v>1Q2%6>h*SD87X);$4`f-(}WNRG-}-Xj^to#q^SfF7B=t7n z)`0p!rEeH|(Mf&LS@ox>BmM5Mw)!2leun!#3&SvKoQJEfj|}ji;JTbsc`r^r*u5v^ z91BOSPy6)aS3mEwzUVXLW#I~xdF`;4ISIqeF$!Za1sC8Vlsw_u7rXmVfJL|oMR%PK zar!x!f(vjqS0q1(k4ZQ)q<_&_{Y#rd(Z{GChr{Mux~%wS&N6q|S9soh z*(bnxn1fm4e2D%?`n+WQ5mum)w$!X4r*DD#>(<~2=x7EW_NL&o#t zS0AHJ0w&>-QU8Sa`a|7wT!+ywack*QIBNYE`-`8=0e(b3fi5U|DEV8gcVHVzU&2Y^ zvr6AG^rDM$U36CcG`bad0;i36&vShVp2DD^7oF4>omF4vtnYiqsDHEi3clrBB?iMPW#!8+VC>LC0Wed02;sP;|mk>l^I5 z1-D_-@Y5kaKI{5ef<-94g`?IVI)MSQNq3ar8! ztV8KTc;5UHb!FcT)|;>ax1sDSyxsGs9`4Rf2+qJ+7>0Q$eGALP_hAdR;X&NhKZKGe zyejz{L;7u?v-*|3gnso_-7fpKn4`>9_7R>pKk$|Aeoew@7=p6Tb>7GH5&GSQ%a3*Q zD!}V=;eU);pYZ9&uRiIszUWirrQssX!8NGoRUy6!WxlJ%d=JoN!ruE(y(E3xrytRG z$vc9laGbs-p`KTScvAIWGWst*&dsR=%Wxa&`tsiC^Zq%8GHC?}x((mD`1v{_@PoTbklgxEi&3D6?ZyMbpl>4xM zN%{q!eng)oZxOD-0xUs2uTA1jDE&8${>OOECSVXojpt9ETbZw%cbRYRYu$6OWaOXX zYvPekHwmYp?q}5cS@zw5(nr^r*QoVzpMGwYK8dds%)lkM0`>hX5wAm;@1Zf@eRT7W za_2+t!|5gI4}AI&eVe=vJca@Knt*yy}*McjFjJ|<&st^JHzzwOh{to?Dr(oOhXT zmwH(v{}^9mU*(>U2^fUBpHb^W?7Ib}kEAiLQR|~V{oE>j9A8N|53_I?>ibtDUWGE> zm@(g7bg8d)=R@v8=92XLKK+RPfV@N4gC}r|{`9;;#G|VJw9)@6@jNWR4MQ)_t;|>M zN88XZ;$sD_!UEL(FH67X)6Yfe%j`S*HSWB&ALDoo^?XLH-|*?@R_Pn~+J<}Z0Cu3B z*D3L!n(vV@-x#_kl>0DYe109ZKH<}k=;z2w!7N;ct5DCYOnd`M{{f@_iKsiTH7IkM zxg`CxPd|S3A)oa{KTBR1CSVFKKz%<}h!>&EcgmP=16}OV?!L%iq!0V_Bl;+LF_?l2a1rWx<%yS}^q)2QpLo1` z?@Yoe7>Bz44)I;M2YZG-!S8?PU<&4-t}lPLu#12Bd^P=b&ZpKVh$rD3Ou+@1fft=$ zpzaAgh2vj;w%_^{(|5nY`3!!eV-_w#Jukod3U&72%D;E}6rirZPy7HL!Y=H=V|dl_ z6G_)!63)Q|n1xGF`yV!c@ixu(+wXbx!`_FSG0#!uXN>*Y#E;-9-25hYuJk_4oZarD!07Dl1&H%)vIO20KjujkntFwcc2@*aeXunD!F@h3U`1e}4h@K)GE`qKKw_(d?e)&G0UpQy~w<^D6 z-2Y+sm;4HKs;~j&JjIRkvp{@V&1=`t%X6mB=YgSb6Ys(!IPv7OpNDV(&aBn zpJv~An1NZtPndWC?!mU9-)C+IunjxLJT2X%QGe9>3_i1P2`(G{$5ZY+Ou;Z*g!(*; zS|4ZM1Wdw|;ipQx3HM?5lJuMG+ko3}$M6$>s+<2DT!3p(&%Z)E_%xTd1XrNe*RPm< z2A^RVf%As{+WlRh>tE=OSp9qc3~gx@^hFLT;t~@c_=?GDe-fUI^V}M zV3Y5Egl)cG>A*5y?`lxqhaKKqlbo9nl=GNpE$6ND3HJ|QHlaR$$+YXU3U~g4TeqOr zPoO(g`cp$Mx&+sgFlFeEsXNB?aTqo9r|1JpKQ&_ggi&974%@F^y;XPK@FVwS>08}> zU4|=A-`^1N2#msvp`RrlR{G?K^)aKq_#C!hzj~|gs^KTgeJR5VtQq&K=u>aitsC{l z=O%s|aNF=-BR;I&((M}cC%?^|%Me_K2Qd5XoLi{RtIn^ee65%Iq8n6yg?hyy{YW1( z=sPey@A}Yw)m%1^oXQ-Qni}2XkZ&1G8Z<#uExCdKC{RZ(}r8_kAqLaEu z=q&#irSBPjWUg`MJHxq)8Rze!^s`2N`Dd$#rM`c|=85ih%lGTouU_UN^qYTPeewI; zd!q(-;R)3BN3CzM?*Tl79m7xH`hG$g^DD*mrYIpw@S&<5xdBWc?%R zPY%{&Unlgl*V`y5Du;Rak@jhQ3U^qV$as>+42+@i}b2e)U$}Bg4-G=V}$M z!Gdw#BE%Cg36~9hjCfq>=SQrcGwO@aVf*!~x9XM*KMmria6jvw_a4;eKTJFd<8bbR z^m*#6!wtA;)DL}+^ScalumErHf5r4k{G?&V@V7!-_jB3#GUq1#Lf`A|M+9oWqA#H@ z!z!%7I=tQT{rWwxzR#RaWM0p9^PhmazF++eb;59r`#Nsi-w3)WjKKudek^_bg7g{c zEWu^C3d?XGYJca=U!<RzQy;MZP zv1RxfwLWXi#qx7e`YQX@;HJ^PrL+85`i9T?mcB)u133Nz?m1q8`h6olSGit>6+=Jq zTvsm!lQ08y{ZZ>f>^lQzVHieW6l#B2;;Zlg9$&J4k^Pt8GR(mhsQX#{kM92DVG*uF zt+#Z|OVXFvw+ySWX82hqz6-~fUH{Wi_d9`Z5>CSq)Ot%de@Xf(_q_%;;HGgN=9t3* zT!wXHKBLyJv2Pw0;JV?bE%E>4?&}1cf%<-pTHnJ@AD+Nd@u>`Dp67h8J)h?iu0tgc zh(1f+65N72@DR4)_<(xD>hn)?K9A-1f#2cQDSp2qzlRd0iOcU(8hqXf^YteJ5BYl1 zfz!+@1n0S*Ss0-&;l9ydPvSY}a{)G>p6@jA88{15hJK%T2gY9D_9;PK{}kOA*T-Sl z&^L+i!WKL*^!tXcO}q>HS2RETgKmBi7>5a{=NU6}bHvjyb4Byl@KuHtB{WX81YA?+HAGmVS*oTd)N?M*Z7eU!bottU&2spNEwn zcK3Y^7T`K8!z#R!@0~#SN8J3PFb*5gs}2M%OJ6hmB#F<#6ud0G?4Q9$c7UIGu4{df zxSs#|kGlI+g$)>7J^TGPO*{+}ux98tiSNJ`jQrTy_2a}-Fbg*f{SNVc*nzVzJiC5| z_%h7HeM5gteC$8FdQ)%_>Ul1_$mudL3zwkQ_lWo5F+8~-{lbqsKOJ}sCw}7W`HWhh z_320SOXMxXJY0trsOP&yd=E^toID?iC|@M6cpOB|y=<5-9LMYj&W!Z8om%WhqPxmU4q~st`lHsj@u~eZjQRN0cd2s(d$4cR_p1+aZq|kB zyy*Fhe$J;pI;1|0ZXPbc4Ag%7>L)qh^Kbz!%DGn?gszxAik~=4z!a2zvaD4*fy>U9 z_tO&Zr)8LfD^T8F+JB7ew`+b1{|j(&$bMGQ>3LlBdWS#lzMf3+zM6)!*8A&<=}+(z z!0#9whe4?O3lZ1%>#El)(Qg@6U{mIx8oHx*=ez22KBLxK_bc#H=XV@Vz$vJ1Z{T*< z7hdW5-GYlh=hg=>`15WZhPwYXpZYxd0xZH3)b%Akte;WqckrqGOdIp@t4~vB9xlL) zQQxnAn(vp^;Q^l;+nn#ElDpq4@Ccs5Vb9ABe(QW*-iB4auL@V(KKg$5q)+q{a0+UD zl=vK+hgm~E#rJJ1aFV{_P}jHgVf2wZ`PW8f%`arkd)WESkUt9}Fbpj?qCs5fBh>v6Zh>sP+k9sQZ!lu=Pi+U&g2Q(=`11)gM#m1fEJ=Kr_49n6BR>a`pZgpc&*yzjU-UVjb@U}zfpxeE8*mE_JO4ZN-TT5ipEc$w z^WOG3->a72^yy#DU0KaxgY|iz{|!E8?!tX2-w(}K92Bn*`)FFS*atx7YO`kXNf?8={~q)cRweenfvtUVuJy zKdVMR1)iIASb|%|^Aw`~ER4b!)bky+et~`E@9yNj^^AT;t`{!3*|0Van*@OFV`j=fi3?o&y*8Ayv(a({m^>RJJ^(ee7 zeeTt+uNAloOHlhCwO;luvwsD)3_qjRZ?bO#?!aBcid>^lx8;f&#D)cQT1i~4Ka zIogK1P@kU``U7|fb3XNL@`kN%>ATc9h12**!a0~W{EZWrJkiY?dR=!Boz?$E>6Z*Y ztHkSY(ES^=KJU{{;U@L#G#mkS8MLP)L{cAf5pXh{ZZ@1$AVEy|SE$p1vDdr(l5h|9px!S}UIWHezSi%k{iJ@&s4sq`ZfAg> zi_&)uKV4%^S@fwlxcMzW-M{2d_|%`U@1XiY>dGACK8io>XA=DsoQ5HIUVWZAa-V1F zZa%9}*Ds(i!gW}N6=^Z%#1EA2$k2;U>Ykt*GtSdR z=}!$mo4lXeaL{`~?r+WTTcOU;1=VZ*jyq4ga1ZW7eLgJRflqzwg7jVLjKACUF$<$m z`xpHQd4u$mO;>jcPQw|f>yKJrV&59vg$IV8o7Ha*SwHXP(D{8r%x+=AMFi+C6I;i;j|@47h@U*N{7%A<;a~cc`ADDEe6&76T}!X;!xH}V zeW+4r^8@a_>_Xk&sO#k}*xw5Eicsb>Z`_X@@q(JiwlNQx+q9Zn`-1d!d<1U`jZ2ejEaX1I(q3$1E&q5NupdDWlvvt{h3>+Yhn{9TlO z&+sF2Z*#o^yRZlQQ1^e{{6YKb{Ve^F;qP|W7dGAVQG^Y+1>3L#$KT@g6Hw1jp34sB zK2Kf<{q%3T{3z79VKaPGf4eFj?kr6Kj&pX|3w{u+L3_^rcDc={X8PXqsh{K*{p z%wvnZU8Dbt(r+8}59qTEJFpA&eB;a`3Flx6YW+5IYQkN(2ep2U=StpdGjDhEt-x(~ z0Cj%Cr#^{(4yNEd)b%Akte;Wq^Z3+$b`Af2^(WLhm3mw5evCmqAHVu2br#_^JcKL1 z<@VcveK>7A|8eq?a1Q#dKWWrYse0nCim#gTtLL*zzVs*koRFvWy6!l>EPofJpD_BD zxzBJt3}Y9h-{F0_3-{nY)br`{9yx)h@?J6YQQ~o!fJsBYN<0q>uxRMp@}A{$ntbkD zQ^wU1|A@nnF7Dk}uWzk2CYzK-j!OY$DBsQ2KQ@&22~R|aOG z-}#ce3>^^UQhuG>dv`MW6nvEfJNKEeDaVaT{2e)Zct zzfHIc_u&C-Lp|Ti&hO$&zE78Pu+2OZ%t<~6$mf&;V}3pA9mA8GtiNy6KUMX_-xB&| zO304e!o%jaagvam{2DY6q zz28OWZ?WGFY{Fgfp$znh59?R@n4q5^Ou>1$0M&MZi^?CP{x}prQ>>?r{gcFp^(%d3 z$jib-xCED>?zc+32J7%-MEXtYZozH1W9)a`$A5F@a~vk&985vo-$mu0;!pOUV80-o zH1>}ZAJ(tDH!SM@ES<#f=-mWl9-4mVbKd-0z2ABL-pTi#pZnVV^V{!zO@H3!-kF!5-ZEgR{S%>l*rvOVUrVZy3g4((scdz5?@b z-OvaA(9K~Cj>8EUgojX{KTE%NN%|Q3rr-ixH2ma=mthTV8v0Y>Q-9>b?Y}o-{W0~&hxAiJ*M=RKIdJ{t;X2g)G|=zB zU3g!wml|?@d(5i^4~+Q@TW{Z}cSu~{Ke^w-)*rRLg3rYv=hs2kg-7rN-q7y_>3c@~ z%AdODrV01pKGc3Th;PCzDEV4{Ds?{O_8Es0Q0tq-ci|p99I<}is2_Q!^BsjT7>7x? z0Chhl;$;}wp&r!wI`JLYgu8}*U)4>bOY-k5HQ_$g`-#8Qkowf0IsbbweCXCOsOv9X zF}?T>;CBp;!wDFKx}O93IfQL^v-OtPrv%F|@ju*LGcXIapH=jEScLcWdXXXLS7Ba$ z^;Pofa1-kLW9fF#H{mYagDp7d{>#3jsyAr=20mr~i`H9n2^-JDsP!HC?ZH!M`MK)) zG3Gd||DaF(^}u(3_l6t^DqmS z4gJ!G-5koW0>|2C&u5kEd02$^w)|uI(&wY3`mM5Vz%6*I^EcRcSihEjiThrJC0I7j z!>IK+_FaK_IIO?(=EwfRJqHUg1G8`uE$b-U{m+{byCh0DhMEfTN74Y+0KkBN`*J{X4+ z#{1!R*IRwojec);{Um+O!YE7_{bq>g;2JC%`sl~p*M)i5fioXJ`|E{Y{WA3$a2p;% z{q@MNzKqWbtiihBKiPGCt-w62K<&q`K0}=>T!c$-8RnqguS$Fi?!fj1>uc1j!wt9z z8&LaeJ>Si5JLlMhE3b9yJZ!#!>oD*Rw-%1Q)2)M0eqP;rmy1_^$FT;}?{;h9JnJl6 zf;kv$QXk5{Pa9!9`5t#Y1ZQCcCf@6=3+Gs;VO}xvKBpJX@49ssF2Nj>f6uhRTK>J! zKI@6!bNN9i|Gr=FgDyS^LvRL0U=$``3Z~&UY{EU*f`_mJk6<6lzn>+H{=V~-fJvB! z^Dqk+VGgdrJUoJZcmf0by~ZRA!6;0?n&JlQ2Hb+y_gOa^Z&J6--(PfKpT8pz%HIz} z_x0hVAH z*5D35k8Hwy*n%;Bo|S+xe(sZiNtlN7Fbn19RW;U|umPv|`AG=Qe8jzf20gbCbjiPT z`ZSd9r~4mu@p(Q!WZ`Vr#Un8P3Aff?9|x@O3VcRjPdxrB?OlP-4D`>8-xWA|;J*^` zKko{R1wzk0EB;x52YvUAh3*Rco51RG&WhhJu=IUr#m57Y*Pa#s>_F@H&WiurK>y76 z-GSD}&(co>&KluefzJt)&KT`of%^wiNfH?Z*qXT^hoxo4df|GdELEB?(H zbv{3kI5Yl$z}%Vf$w2d$&Z_gkK5r2pg|6(H^x*`7QQ!p0zU;m%J@RVzTy93Qnc+bhx?umb9;Qz)a zNp$)f&!LOoc&?s#PoBN+X9wEq+)ACII)}vvoL%P)*L>Z0Zr@CN^ON3J#aoFtRD7HG zmWscd__m6_pZJc7{{iv$srUi$532ZwiT|;Re~kE{ivJbyu8Q}s#is&+w|UR)KcVj{ z{r|ZZzw!C{tZT>Ma{_yR@15HO@y8!~;}0PId=-DtwfF-9dG-80lz2(SXNhm9_@k)* zT2=os#J5%a>#oJ80ST$hRs8#@fB%2* z&h2^BZ>jn}Oq~T)XN`DP#a~SQc~$>q#6#-7m#)Ph5a_6VUq$^TRo{IXnhNAp{0-E9 zwc2-+`h8XZ?dUs7|4#IQpY`6a_n`l>fAr4Hef@qwAgJ_zgnn7+KSceI(*Fhew<&!W zeMIU12K|ZBe+qp<>Hiu17R+dru5Ig z7QgZH#`j-~e?j0#eSLo(^{4;Y+wTt(f3S+L5&vQpfAO{W=LI6_oWJZ^{Kl`>ue=t& z@#}TvTKvY(39q{rzwvX$uU(6WuD!kg_5b&lYw>&fRi9h7uEoDF@Z^6jzUP1c_OV5J@#9yf5e@c8^#Xn5EqT(OD7Qg57>LafGkLzwf zNj&=)Z@fpmRQJaJo_I&a|Alzy4PO0c-1X_L?hfQsd|cvh^y)vCcy_}Z|98X#Z}!F? zOg!Ok(DlA%MBni0zmj<5ZQl4-6VIzT#E7@v?$tkmc;mOc@h1}Ryu%xRs?^!`#^)ve zPH+5~#QW|bUGMAJ#6vq?{SOe2yvrNUN&Tib{-eZ8kM+i1L_GT*Z@fUf<__?6KQEU$ z@AK+^j(FsEz42cn9(unwUL&4$55o2OZzP`kpjZDJ#A_=4TTsDcdEObS! z>-X+J!hJ!x?(=@c1MWp}J$`@UeHDKo@zP&->rWHUf5aPq81bxo;aso(aN>!NdG%jK zJg4F@;*pPg^-mz)|AaUGMB+8oZ;E*9uf6(jBVPJjZ~Pfj=TqMJ_elI7yzwQe?_PA* z`+Yv~++Ejh(DnF_5D$KqH~u2xO%*Q?FWt|pf4S88TCbm163@FA?Dc&s#Iv96t@AqK zt-HPPUn5?+zc>CC;>`zn<6BaH+8h6E;(>>FkM+jyN4)92pj`KJf8y!KdGF&S@$BQgb-qaAU+0Z~iNwF&8~+O8IrjzY z`o0n3CHDpEdi=4Xf0DP(*Ngti-uO2W@2Gf+c;lPB`fnp1d5Smw4B|~Shb-~F(tp3y zabH-k`+pws(9^v2f0%goTfFf#;_0+E{$k?6Z}-MuCh_m|#$QRizu=8mht216EC?BHrMAlcJ14% zdp`I6m{)%{@%{_F@y{n7S@Xufka*C2K)PN(Bz08$%ZUeG?5*=i;tdslwCKOlJBP;; z552@&=NpM9e#RSrvebX6H=ZWmdYL!=oy7a=-uSa5{AhQ_%BHPiZ@;*-uPv2{Po0}Rd4*w z#9OcN#@)Ap_k5jttv9}nzW+LJ{N2Puzv7L*U-nh;KOmlW-{4=L=bsP{zTR8s&xvR2 z-uOqQ&Ktb(BjQc>0sDIWzaw7T@aq4Oc;`*t`2Qx}db2k^cE3-Tyz%!VcN4EY$$Ni4 zk9cR!8~+00&6GF(VB(RddE*Zwo>TF!Al^@V^^X$0`@zWdIXs$p=sUdn#}kh%c;nwd zy!mu*{7J;~&+x{dO1z}v-$uNq;!l_OBfWK=MLh9LZ+ww>TE(ABys6?jiD$fZenjej zmp8sfJo_wf{HKVwvfg-+c<|ZY_$!Eq7QOK@@yK($@mCYiJ<1z@9r5&Yz412?&%VGL z|8=SJB5(Yy#7jT!jlY9<<0riFcZojljlWOo|D-qm0pdaT1HkL&?GK5kf6A*rARci) z5WBAbbE#AC>N~{yD*j30t(SQ9J>rd@_QpRYb&B5j3GvQLz48Ae^A!<`Q^hmHTPpr+;z9QV&+F%BiFilF zpGUl};w!`>HLuSX5)b@}H=ZXRQt_WAo>TF4;)zFl>%5Y9N$Fojyrtr=A)ftJZ=Kf@ zuc`Q(i2wiHy$zgPRe3*tc@;585QKoKE;L$HTy|#PEowqCA)D82b`hl5o7vgf-AQ(5 zhn?AEgP>8dA|j@WiWN0hRBEwCO@+3oQBhDqqtc2(ZB(>qQKC{CE9&q2yxqC?+&jB7 zvy1Zo?*}rw-+AtH&pr2?=R9xcIc@Kc(tlL(l7s(~;=3LEUll*-;Gb38yD7^5PR08j z{2s;^dk+n6a?LC>O=gReXs6ey@Z7tKy5q&2Q}JC6o>u%82VbrDeh0rq@rN9|sQC3x`(Lg2ag)*a^)|(qI{4o!zTCk-rTCzO ze_ipb9sGxi-{|1KR{UnCor~b|pz(IEL*JtKgAU%I_+bZMqxiB?^m#8;yyD;`#qV(N zs}w)_vM8S$6kp}wwagp@flBsAr|5Wkw z9K2ic83$jd`0WnvEB=s!mla=9j^6k6im!L@cPW0AgMU=04u0fQ=`j|2yB+*g#cy%&=PB;ym7S;f z?GAmv;tx3Zu;Pn%MB6`O{2lyS#m{s4=e>&0IP{-Te4m5gsrX$Ee!t>}9Q+Z*7tKW5 zdDMy0Z_6C~G{x6A`12Lt;@~e){CWo;P<+3Gk1BrH!C#?xztcb0Dc-g-+Wx;&eAvN1 zsrVL$&zBUx#las?e7}P~qWEJDek4>48gFg+XnUTn_@E!f|4i{M4*d%izt+JwD1M8B zZ&7@|gO?S5*uno=@kJxi_PkT^9tXcg@is>v`?TVN4*k~^A9L^r6~Dp3|5x$b9sKx{ zq(2Wh_@5|#ia5ZDh=1A?U+>^66<_1D|3bxgIrL+S?{)B3D86(o+Hcn>KJ4J{Q~c;c zlzyM$9S(k{@p16)D1NPj|5WjP4(>gTx?{2TfP6hFto*C{^e z;D4p~6%Kxx;x{??Rf^y3;O|iUQ3wC9;w{^v?fjJD>mB@n;x{??4-~)8!GERrBFBz+ zGV(&HKbJfBQpGC{ey-xzI{myt@tYm`LB(%(@KMF@aQN&5PIjt2ycnE zMDyrcsM+|rLvc@WHkW{(j)YsHU+mx;6hEMOo^8y<^Y$pd$H5;~{5Xft50TfNl$ZMf z=C|0}|H|lld?x3?FY#tR$qrS$tLH6a`~>gdZ#fVd;NnI*!8_pK&tv-2yhBc&lB89f z1z2BY~wWGhse?GO=xW(%atccQETzl8~QT(a=_)qb6uZ-drH*8xL#cxvj zy{n@5j}_maiQ*P-Iw%bep3CAdd-|gE7LPc%E{dB!zhy%dH-G*v2j9Z)5zpo1!<&D* z-+3d0ga138i`Ew# zpCvYzkiB%pEEB$ z2zui0;x{XPoRdHBufRPozVGJKO25XTzZW<^m#!C*_nX6C z_{8@moeKIRyf`lOCwjM^79Br=$M+3&f=^O^et`RPv3IRw2fYOJ9`<3K>Es({7>}=m z>llBQ_wB!7gORz?KYzjaGrW(n{T;yGMU0=}t-6aHWx*FOXS~H*{$Orr}J2M>KCire~i@S9QG*006? z7R7`0>))fe<@p@=b`-buYx(_AJjeZpe624>aa$L>uS9WM7h3L);%v!~ zxUCC&z81wz{=4JKfpd!K`kasMp#mPjH~@P17W zuX1pc!&f-C$>DttZgTiGXC4Le)_LAnXnU@3aFe%pJNTPGKim90M-Mqd$qR z*K^I^!7(| zE&ma{ug&ZJhoiX7>%~8f;x?~$JGkk${f|WHO}{PuJc^rsyG0U`gB~*ZaOi)c^d=wr z|2K*U^5Jk4zl5g=@-}}R#ZB+s{gWte^VDogLb@e{_M<*mDq9T(O; z-XX@H;hla?0P!!sV*Cv6Grx=qpvM?*@k$?yw*N@p8XbSXA`egW?t6N49EzT^)O+sQ z==-()*|jk`eoUUU6{EPVzx^Xo+}7W{qfy+}-!@5%4<6dq--CrHy{*43<5Aq^^_Gb! zZu57^YopI=^Y?5AxApft2eM^ z?2JRRUk*F?aTpJ5cgThXZN|Dy6g_n2t^+@tjOIrR4`e#pV^ zS3a+I_`|ph2!H?lBmnV3ibK0|r z@sqv#9QucJ^Z{Uczq83TIEx^A=>_H6u;WR|3>jW4t|5;Elz!s_cDHhx5v5fz1sg5 zJMl$me=*0s2w5oD4yXR+Zjw1{^d(de}?zv zXYs@dzC6Hqi?`RYufN53Tp#!@<0pDs9DU%2j4$;LPDJ$qvqvufeRQ2QJ;6%iS%U&S zVSkj~_6u8yBcr$d!dB|Y@c-jxJjJt;M}{B4YR^+VD}7|R?feZlM&HTP_9@mHM3$iJZmWO%85(;I}z=i{>-m?ckQDebB)zPy3WNMB8cpll@LREgo^VgIk{A zeGYE^*ewojd4LZ(xa9#J_qu3%EDx~%ucP=9?VpN+TOQyI4*qehyEJi6p!9}tJsMaXa9uaH#qp$fRi8Wz^g=#ZBg^-NR(J2JSfSn?$m9De^}+7 z#&18QxRv&ndT^fiUB%npDfG6T{#3Zs+5dK<;PY#px@pyg9FEF2<|K6=T`c>uc)(ia(^Ff}5*7M$pA%CBx3bII(&Kck6rn2JkacN6yoFZuVZ5wg|n|nHi&w#LwTic#?X` ze^vjvy$1deaN=+Nz#hG1)tSTxc83%W^6t{{^G3xFY?g5)_ASOIaB9EpYr9tYy!RS1DcwPV~0_4#S&&exbPO74}@){#59f>;B&s?VnF8ZhCKr@_E?kbzPIYd*0e* z$^G+k;M5+gQ*^2FIsVxmvO}u==Us}Q1)Sg4CYjI=D*h(m+;7uz$CBcoRC=qEFsA)^ z`g4Sj)fcjPItHBIi~8&Ay?h2Z@!xZq@E=zG-(+0>2z@*R{3PVzSRSTa<#~_RpkMiC z!vE0GLV1;5;49vu@fQmt%>bu%n%{DX-uo@UsejD=wfXoTz)yml+4AvYnX*Ocf62K1 z5&AgoY-!J4?a%f4-5Y@uf2$X9So`z84cGYZ79A&Vey-449gMxoXZiC4w|YCbDE>~x zt=`TSX|8wX^M&5>8y748yA*o6uYRtHnCrb^xb-+qFr6HF~Re1E=w3ag$w& z?^8Zzmz}5hcNMp~F3a@2bfl8oe>HGw|CXgPuWwZP)6>cHn;FMAmja>Q48{Tdd=fbE zY194G$0?sP+Xc6L9>b@B)AJsjl;^!q*m!SH`n_65WvTLcKLj1OQ|rH7toW1Q&n4XI z1e!ju6L`}5dV3B0$I8e2A=aOzF6FOzQzgCcw-vYgPD`I853sabp39ShW8Qv!t~Uce z6LP@n_bMCj2TH$3pUG(X2lmK^LY*9kk1;|w)N;H;M9Jr7k5y{`O$x#%;zlN{JdY5iLy-Z`##03 z{?7x7Uw{|H>xIU}b}9Z^;7QMWA8_Wc`Np?E#h{;`DQ3^xAXuekY#(G33iG;o?1`!5pCs}%oFrMJ2(Mt}NCguZmP z^xKwW)gfY3YoyqAn`nv32kzeS%vZMblfps<_pWI7QpD>r2V}*RB;l76-BS^$y@k z?fDwxnAf^4ELQ&irF^XJuC=EZh7+~l_Jdeix}(+$ZuKp1)PA@gc+!18X7taOak5Y8 zmv10?=>I!pyjgp$VO$#*`nVA|kB4KAVRV^(cL#84r`0Vnxs>0S+@6mDCwi+Na;@@d z-6XjA!=+W8cQtTo=dLFUvP*`M_gSOYIv%T(kKZrtv^xJ~#s3{R-Ph`W-lF)qebUjm%vc}XbmQ+(3!FUWh@rTEX4 z&!IO9ey`%68KCDvo`%jBo4?N(Oz!99z*%l<{(#YsDQ~ zfOCI-P6qOWdf#8ypkH>0&>zxzP)7f1;M6}>-`@0%uK-Va-ZTF)8BYU034AWnJhW4^ zJ!^qeJFULZQpLYigU&e-Zdup?27> zZ)P0hM+)S6)(^j6{*XW4lW}#QesPYk?f;ZK=v~Tax#AWV({AuC0#5C*{GuME|2XiZ z=X&-Q;cs;XP4D`w;#QY$Mw;dQ3^?((b4=`cpOY2b&R;OOF#(+3SIY^~!n?IS?*>lq z*Xr)td~Y2}?zcY1(QmpBrR7Lr^l`R;9N(evc{r|0%tlr=ZR8_T`h?^FP3;fA(sgPj_{_uO?GLMdC4%R<^J}USjty`<&!#ffaf#?tXi?q=EibKHd8MP_= z@mj{?cKSPjQ~%g`7OVB5?=g<~;;d7LYw$m{AnmcZxjcpErGO{3XTs>Ol=h#Za^p7O zNp{CCl-}ygtx@`wTa)?cYT!2jr+%~jRx`@y9>p#Hr$hT;aGTIuy-k~U?*>lqvGfXg z(ix@yB;)!==;QmqX+GMyHZ~s48BcEiAaH7@)oos`?R+KEW4!H*-uE7*w>pq!pPoFC z+@D>*sr~(Th`_M*ae(nq!}ZtQHSo^?r*>L>=Eb5`dao%a-*+Eyy07a8zDx18%jLOl z)cc-3Df}%T{$}lmvr5VRHdO<^u?GGr;M{(#*LR%W_q@xJ`Ckc~=&e5gy-L4mO7H`c zfajV1|1QP1yh!@_u+sk=IL$jdpUCFjpF`0l{#Li}Jf(jCIMG|4_MqY&73t62zVzFr z+CS@o6Q35%*OG5N??X(l7l%G>S9;64F#0p5W!&!3{9#+CrhyZGt80C)-uE%3w>(%| zcP`p4?erWw$@AX>=YF_d z2u;7;vr}-ZhyS4V#ht*D|8Bvj&~_=y07JVE>=D_Gal+-{q917&-NynAV-z|!Ji)1`3)#thnIP+I~bGau!$GfI%Vg|S^JAhf56dO-puq% zJUf?7yT|(haB9ER9X(I^U-de{Est@p;@<>L{jjBcG$Z!BOaEH%-M^E8bFJQB6L8{h z`BCR6pMOx?>Y&Nh?LBrY-hYEM(4tCFAW~a9B$F~a#;B+cJ6!r8@2tn3jHCy?=8TS zp7(yGw>)7P6`uFPYpI<$PxG)KtCi1Hz?1aGdx0nMe~59ckCzIc`;<@Ho1~qV@7J&R z`xLixzLqL}{B_cwEuQePIN;g9X}z#>3GIEo5;*mz)s46NUh-za?K}n3Gk>JG?GrRP z^P1hs&vhMe;&11a-KFjPg5p*$`Z0Z9KT+JyGkQ?zFaI0i)24M`E>`+SfG73mF>eui ztLJmC@|gfm@5}asz`esicLAsQ?#iDB6mN0#grnb@eBTpl;4Q$ZAMCt<8}+_#s6qd3 z;FK?M@mr2%$|XvFtMajPtZq?!3KNIth1TbJRPiq>en=CYOkcg~ZSuTr!!l0xYkz*j z@QVb$O8Fc%Tn^asmddp8*1lc%crO?F9;Npg*FQoZuLDl~Z|79neEC`p`v0qeKlL5* zymoF#hsv4H1E+pl{x{NZyY$}oE4}5BN^5bf&kf1%@eRPKKW#sSJ?|dHZGXM#d(VAm zGM^U%=lA|q=`aj${<*OR{kN6g&i_&|>Ye?!($9zT((*Rta~^QwZ*>FqDgJkg+x{1u z?{@;H{PqGWq#Q#jTF|Dy6^Zy~+JB1Dw`D+b_9G>E8mJ z?rY~$+^+cgJ%TUSJeDnre*`$mw_Q3<7i&L!+33F_?grZoKaBjg4{jO)!pA6M4E z-(Ca%C2)H0w*T~0<#odQ<#}zNNQdGt0-iK(i%M_jUhUC#9yC5$hv#AC^UzJ&&sq=U zUd6AvBbon6A4tYG)xbXpoYs9i$Jyk-W59X*=!CHMb?pbGJ&T?7?iS!gZ|CDYrtKX1 zP;z_r0VjGp$8CxB!|^u@|B~wY4=JB#GOmAwK2pGWynX6OM&(>d&)cQAos02+Uh_T0 z?R-+xD~|trnMb=Eeey-XXP3r{{=LA7zny1f&wKhOw14#ci&aX0tKxQ^-MC(G z&OW8r0dDj0I>qfAURy8z19;MV`8n{D^j_hQ=lqlKw|!go-tSl3_LrTf7d`2d#2@qS z7U>^rPp9ICG_Hi{z&~3V*FQoZuLn;3WBY~sb-w&p4f+?~D)fu>T+8*!>pI2lJievM zr}H+M*OQM*N1m(nW5DUY`_+E8_kNS&b{>=UgZIxezieN;>2)syp489p2TuHLpO?Mg zPb+Tc;Ox@&yy#!FA2vvTKB)MI6}NK|W#72x?fzGxxAT1QTKOk+dvbeL0;l%aeyhVu z|GZD>eP1H|bFboW15R>dxg($d0XV()LmCI!qx5$$u789+9#Q_bPuBYR)K4e3^LfCj zopz3)*;5ZHZs**YoNxV%&|95SYyYi^+c~!TRNkJpU)sOxJ@UK{s62cXaJsM6{j>Gr ze#NcstNBGA`K<8qUMhSJdh+ws&j}wp2lG)Khfn={^7CE({y z(jPiY7})U@_XDT((dwDl{5|SR$^CF9aN@t*$!~d84f?-PdOLTor0@Onid&sz8=uer zvhY8!U)s6bo=b77w}58zPvuw1?L6@-+CPq;_8j2UemkGh#=|EKKjtXrYxx^z-YxxO z^;oQbW`GkP+mC#lw&w$iTfJqQFJA(lBo7~D{wH`J|CNlN)yn6^_h>(B9ATN_p8}r5 z=YZ0;d_ekbmC_f#noNH+aB9Ep!?pI`s<@q7dY|&S>TAh-t^-cvfAD{z?Z2-E{ZAN& zJW>Dl&B{N0K>PE%!pHjU^NQQ~hVrfFz3A)7?Rh0|ey;1~JwB-8?PcE(+|CcRb@?&i zB)9uDFLy@Uv*epXZ~LszQG6Hhr2fBN>8%dKn9@HL1Do2jMbA?(+bJnx*mi1#VI zom+RGw*SY9+x}u($2a|(@V9gQK*m3NfhV=|4yA7ym;O0VKD?{`UHI5O=pMcAv%V#` z)%~{nUaz>Fk9MBkw-W<~p4aN7_ba|m@!eV<)#lyTfm8nDS zuM_^}uX_)0dhb>jYl*i1pOt>`MMD38cE<(`)THsuAK^GwZ7f5G>KkDY5gc!b>dcHk_3J|q2n zP}_OZ59Ga!JL|$<0_T3#b62gO4=HYS5zkXTAAL}scaI}yehr+TOV4@SrTsATLv80z zr9D?D{>&c?R){8dzw(-Y8Z}mEkQ~ILfR-a*!;`ahi8lS&Z`duH8_FF&i z`-!$^nXFJtmCtkjJDE>c4ZIIH%}1-hcbf7Uu0j7D;MAW7|4r_DsnYj7EchNh=NHQ; z|2*@j$?dtK27W(q;&11KTEAWLGZ|NF)URdp=`T2HIPtM_pRdsI z{Fvf)KKNtW{?GnG-q&qvM=w_VVc^8a&Iezl?SJ(zliUAyz=__@@m#Kap82TYc5a2q zx7RCf^?&5;d)^-4EZ>~?-2+N*^_J~e+zm3J&Jo&YDIex8WjK?on1DyKV>UN&0BtyWt{d&HG&G%~+-}_p5U*p>TN)5gJ z^^Bt*)Q{A!{NE3p#%G)3&;O~?Z_#+lu+n!OoBVz^0w+FJ|I^0#hk#T2?Hr;@l~3+T z$$W~yiQdj-UZwPlVBk>ySiRh3igy5~_pevQ)ie^co1)^;9yg0yG%71BnSgS5Dr`u#Vf#6RF>pc>QXRSpU2cIJak~ z(3?GYBoq%GZ<;^6OWSj`;=6P_n;iR@;#Sw%X=-paT=WcBmJr%8MI zw@ODI_ayo5FBISVPlB7=zDIGdTiU-*pZC&}li%;HjANcYCiD=q{PPfSe(&o9-!HJY z6dgji)nh-P_z!?n{>*-j6WR0rM(G!)q@Ct}*!y(lbD7|aRG|MFc+xmL@ziAeg}|vj zR+s)_ZU0TcY5pEo`)j4P^S>3hI^OMypLN<1UW@)7{zw5&YR`J$N%G$ZPWQb_^+}tL ze_w;oUCal1g_C#meWs7gnLZe>N$t!5r+%>d`5oF1zXeX?*6N?zd%5s*p6)_9)(_alrGG|B7b_A3MKeOzHm#ILlS1 z-qB;gsr^=8-P+%dfkgCneu3eC!MNTm^f9FLp60Ecqu+g0aW@bA+co%{`X|ZneG_nc z?|<&Z5#A1*$LD{F+`Cb_)jR5$(tbOiV!if5J8+^uaJ>+gbXvYk@s^hgew^}|d||Sl z_GP8FI;e7Y&r3f`@B0y9tYXOX84q=s^$+l*asCb9^t@Kj|20Z~aZ57&O~C27N*Bm| zO^fE71@!Zzd zbH@uq=Z@xb=Vr50xv{Q}7mOE*(=#s^El!`?OJB=>@h@{zl|t*Jw`|7CWyi<;9r^4w zf26oToQuSHxHZN9q`LVd-NPU4^3fq+X9t5_^3mPKe|2~9M{h5Eq}!M>-NDzTI|S@x z%5*2+A>El~%FcHAU}ovgPWg+Or8|X7r*P>ME?vT7l3u9#`1>*!zoz~%H8uAmQG zP9IF2qDIhPXas%WdFTU;pbsw@VVPD? zn52bCT9~ATNm?3|7A8X2E=<~mNxLv<*YAW$yD(`NChfwcU6=?(hcH1!DtdqpVbUQ? zI+R41bO;lgM?@)17Ozc+ni9zl0afA^J;r(Hxp-WpWuMX&Jp~nnL(O zMsHe1Z(2rgT1IbLMsHe%ZCZw{jIp!~+q4YZG|eFJl3|;cVVjm=o0iv+CaFs#(i|DR zGEmdnF6C?>KU!KwZ(2rgT1IbLMsJ!VI9SRcP7A#Z;Fu?PSYX+CW7%>&?fRLl%`3`q(#yo zX^%8VS|g2-ws4!JCDIUShcrW4A&rnWNE2jI$(-WW$W)RkBr~X!+b8o!rjN`XhGp)^ z)RCDZ6NeU|nO2!SGI?kP0>Zr~Glv0MeP&u^_Q>Rsxg%3YW)7`8pb>gzAd`oGm8l~$ zM<$NU8<{pTYh=>MoRKLbGlqMc)|{DEnJzM0WU|Oyk*OjxMJ9^O6D&0stX%2mXL9*c z#jj+C#`75IaVVXDwI^VmaV(VpCENltD|TDVuQ--;i>?H^?gXqS0ZZtCgr~(UjWq>R zFpecO53@KjW zIUA#csEuO@j{(u^(#1P~)RPz$^pQ9gZyjkWF}iralhzU^OK2RFl{j6zKS_a!(LtMu zV+oIuAPh;riC>%07HB>(x_G~n-V-NF=)DB8ga#*En9$sKYvT<|5Yo_&+@?ZRib3&~ zLWzn|#ajyX%B704f|?a0N}!70FhL4K9gFdbcMTLZmnzOZK>#PnUl>avPuxpy`F!;`c3DrSnvDg=^?+*A0EoJ=5n5Y$pxD)NwtsWD}?yP z>_onNerIlGCY9QrNwpI;QW($srEFzPai1=F=_RQ)`f_}7a@%xi^SX@#m2ThX>r&~V zY`Kv0%ay4@akMWtP)Vh7W7#RcGLbPvKvfX!sZA5dMWZgnyZmtiIt^H9zBHH@@h^ zrw@#8cObzKk3sPvk0s3+T;(0v(ecSq9bhlLWPPeLH$FK%49w3>PE1S|3;pYIg@HD| zKeu_^K&5>mTk30O2yN`zTAnPz`Lz}wnSn~jc)ncj8|d+AjN#8xwlLMV4u21<@M*-Q z%6KVHl-AJrc%rn0dIoOwa%FmCq&4Ra=cn?cg>og2Sv%q5-4*j?3^334hbMi!+M(>Y zKU|rdD*M@Kc;P1}O5^!Tei$}1%<4oUh>>E!&rVHccl!BaWooB4G6iAd4^K}_?8GIZ zzkEC2RK zW{P?f-;ooIK7@okW%x_PQcC1fN(56%BvVR6Q%Yo0io_BwAa4|XXxB*JkVA?PlD6Cb$9; zJOOZexfjCs6@%iE9nLOZ#Z7>&Po>J0Yz519ae90_vpv&GucE#vzps z7J-d^D%D03xu554s*UHbPaHD^8u==gB1<%{)R)|s0umZu^6Mzd2x+0lHR*L93!3*(thk6TxC+qhTEIMBn>>Hj z%Qmjq(6} z4V+IZ5rL^RR{Q)+RYA|JA4)-4>hd>e&-hdM5*8^?ufg2*HxL7V0uwYdjz<|J-7R<+ ze7~Z&lS%S;p0Ht%ber`-)}MdGW=5dus=^uQQh|6-%l1 z4bU?&bvNg;P?b`h5CoeiCo6qLyeAA9p3#FZ9jK(+{ecox-f4U>?3XH27(b=)Yz_}+ zGB8Dg^8Crk@q88!zJnOIYOtA}!=*EBy!QZgnpnO?lPLUB6; zE*eSi8iUOr&Q`LU$eOioWm&W`oxyw|^l@qwja*EWIU7~iK;RW~fQ{z*#zCqBUBQ-n zp0sazY3Ps2&Qcy7G%_jA9rSpIzj5`7=$vw=VVNWU>>> zbvAIhy{jgt5%*%V3w;ghUK-9X&5lp!bw1ZI1(?&Op{=y~)HMTEr7^=M@)NnzPMx8C z8rqmWu?di^fdz=)+ROP$^zrKzDUMYM;}YVul4|n@(C@hl6sNv{RS+!@J6pN^_+t(M z0}3>D@TE3fW4+cnoWE?EMPTp(d*wY07PGE@~zUqLV~G?DUVsuL626S{OzXk3b|e1z@v_c z^jJDG?2+_D=GwN%P~5mlm5jbsxCjEEH&|n&k9?>c=r&l=* z*D(lTl4&C;kZRiq!vNxG8k00rbHbDH*8wsj11S$OFM(i}fol zYV+_5(a^GK+wC}mx_utg&Y*6`qdz_)+N6;QqpcB@s7@i2L7U;o>h^W=#RL%iTkaE+ z%PVbbgbuptVgYgm%0xM{8E!G^_t30+V(Ou^;+ON3A}W?rsKHpU8W$7LHKFlsfEv6l z?@vKx&u7>Z9_@*haB9KxJ%q#wyX86v`-r%TuUp|^qv|mYo7vT4P&fl8{#21c?k-WH z^Fv(IeMo%nlsC(wtHEiUn5ImZYP|!|TR)&p}`qz>G7DZ>kEuWnjnjT3CgJdF7Fx>29Ih@W6WxAjiWa%DpU2AZlel=6nw))q+ zI`!v9XQNqub13zApYxgXs-@Fd%a%&xJ2MoL>Mp<}8=b;pMc$Z7wpi&K5;Jt;x(mm* zXW;aG8NfB2myb@1aE;Si%$A6_^Lx>ybqA8RUx@u z=VD0Jt@A$Vkijw}`l7?191Gir=s8%pq&r~-aPLy*=cWoJcvbxI!bG8xVI?V0$$LmK zB%LRsA(^^ZQvnJuA_zO>vc)2vHAjjmY*EO15TrUqAlk?)r+Ugei(^gKWAuaM4yl{;9V-U>rd}RKvB_kl6Di!j%{Ek8yLyKfJnIL{;pwd~H zM%WQV+>rwteKtE;$LS6%slao}COSFf%+<%ds-9K)-Yiji*AR7juON`z)JyL2GxQj+ zLNeR?2YtE)%T?T?-S@}x*%Fjn@*~XY`o*$kFFJ=8%_$TcVHb4zkQ-&FV0|QHDFV(< zh5KOuz-!R!+Z}sJJ7u?YbQ-CIF{x7Tr0qt$6tfOK)OESY`lQ;BTFS}VOeX|f({X>i z@xa=F(L#n>5bVbj)5L;bq0Lrs>$U+nhINXFqcxN0ypZeX_Fte8?YNVTny^5v+gU?e z3CGu^tr6z}yJMQ~qxx)MN4aXmc`xc43neT!xeNv(qK7n?QfYONv;0h_r%UkA()1-q z_!OL$SQHDn%s58_X&o{#WUuiLYb4K4{%qpOJ+OWb`NO8xEb<56+en({J0ar}3q|;y zlqzFnR{0at6$E-HJ4q*O$Z^`}^zVYri?t~;5uf}J($EFsx0qX%HU+Cb+hi^m_(%yk zXq6GSA)*SVNEJk{jI*l@l#^2k8A*gXq#M<(^vxKX{#e#QJs)Yt$B3@;aK=qmvoN3(OOCB3l>XWA#Jq|0&_M;s?PJ|^`(OpXme#l zQmeo>4@;wiot#jx9`nUvTI~{z|5SQF^4?hJLE%>=Ywkf`wKcSvvj+fUwj+89VPj13 z$sOW*MQjsZR=m5osnNz?`D|iD7j1FF*6&0ZXdqU_5gYiR2f~YFLy=-zY+!Y`-lzI! zC<*$IS?bt|#9C}oU4|u#MIuwCO^ACvRnCs&{gIJzL{~EXJ$@hD{eA1TVG&n1#=)HL zL86p3(s0#OD@>L-B0xPEd2h8Xr&JF@xg5;d8R)sCl5@ElgX=W14M#s&lbf+vAh6wq z@FHF_`TWQ86Nss2w&HfxNJ8?|BS%&9?})Mvf)L40dqsXeH<5LH27`lP@zfJGHL(K0 z1WajLd00Hx)|=sSxm_K!xDf3xOV3-CbgJ zi(8&T3!Hrp_lu8IDf|c18?UbmVWwd?rn0%5ndg+wg|O`?%^=C;N(o4i;TQvj85QE}n5DN^XWXK3 z7dy3n_96E8`yguiiSeF#6Z~3Ek2f1vg8+hv(KHAXUa3eI(w$~?(A1Kps>($N#uGAs zkw&2;pm72WQadqo6A~DaY?<|ku;HPI|Y749KtJ?E6L@n|Ny>tKh2Ycm$mg&4!=n}rQMCFb=eNVm)H z=K)ukVV$h;-Iu5spR0`PXf`h(?DJXIgj5FMC3%5xy#-mmq+}qPaXvm^uN9FP&1o}1 zJhx#(-_mC??CMaK7(JnMUrb5FS1D<3gWQn<$N zm&cQIgE?{^Fwf`qA2sGQRZm8`ef#A2HrlG0FZvUg4f*g&a?Eq<=5?B7#$r!>Xk$=+ z$C`Ti4T*l8FR)H^nK!2fy%6FaQ|R%{N;4mH<5_9zH(lTl z_HD=v46fMFKOhrqp~oe^@nNwP0~<8uucAz7c763xhUU0BH>$=pMoEd2H%xX(@_#C` ziX}nSxJq?s916}MWFwF@TQ%^ST2NsTBEAd3gzU^zO7fzSNIIP-TaotHXzD;9i#jCp zBZx|e4KolWZuhA_i2^YnN-=ajMBt0m2EU0G;diO?%=we@HH}KP3Lc1HgS4AGUwn4qOEeg z1A$U;%ahoNFxLcYGO0o`DjFCFjbvP^-suEO8XCZ+K&h@)kA>Fs=$UOt79?$DGOA^k zD4{Vvqs)hlJ`JR0y~$%FU&vqG8*FwV(a!rvL%y|C8VkwPPM<8^GWNMvWq(X`QvwO4 z15)0dX5pm^!<=k5?8Hw%#bnh+i--@ZouqoCNQxQTRAYtqagxlfU$n!Y2>S`*Aj}5U zEPSL?(snJ{931b|ss`TZ+tuk>(Mm zLDTCNEZkN#Ou66;uU?#KYKjj>_ndjvOwW+>Qkq$P?e!Vq97o1hfzcuj(T?cW9kyWdV_ldDb-K?;BW_F{diS^d3rU|y+A%nqbDe3}6bF~|}wG6pf>IzhjASpM& zJ8g0!9(&3TP#3qe!y#fb_l{-Det9g5BwNw|lL9pw(rHE*QE)&uPLX1WJvNYmxiQ=F zWR`YaOGoH+*QG+ul@7!1{5q7k@cyucx^XqY+}=M)$@fzdW9~+X`FvEAfwty%tinEC zOs$QBewTcUWQ*+-a<+}v=~X)+KMOflvXy2PvVuWU)e8f2*o&q;O&60ApKNF(Ym@Dy z88z)!o_%ndP=+U}1+ApH8tGXghacJJ13|kFDMqwrI>9rII zTpbF^_P4J(e>?y@Zs%R7WX4Oq*Ql_w57=Z&SX`1>O|ECLt^K$TV~o8%#_S{xJoP_R=NhK-87~ zfN|n%Os>lX*pP-^*CNXTJ9r`WIIJMugU~B#ebCNC32pIcgbD@?QdBS$QJ~$yD6}<- zVl>4{k{ULn)sNNXNrl#G-QEyQ*Mga{n>MNTxylAJ|hEUrjyyw)uPS!UlcdlmAKuF?Q zEN>ioZ)moK>if*)`JhTd4Onn^ICf)EaSQ(Cf?6VW^Elr6Y9iad5f)Bg|G)+QKp+0L zbTTp#0wuzAR`$YhE|zIGR9}DNHnN4t)o4dL4cZblvgj3s)hehgl7}FhB_q~j812#AaRG_nR2|E)+ABT#9L%3r(~ndzWJ}6@{*lQu-GQQx|R>}L8=W+ zBETQQmW^R{W0QiJYHnY1M4HySwG(BgeB0Am-C$4eD%6!z(B}|!bUV|GjdnE`kk5o1 zR<#$XBx`0PQq+0@BM#7CnbJkT)QPw)$-2aFek40Rj?$Ep2hI*69ZAWP`SH&$GMgaO z!|-(Lwo{77Vsv9%$J4-*cAUn9SN<}ZKDu44>b#LXsN%dSM3r}x%j5|VZcn4K+}zUC zoPkO4E^<|w2{NcB2cy%um1}7tVM8kBghNEg0Jh9i4iRxM#>8*6Y8rk3_hNtWM5A$wa!9dLk6YN?pj?sbDOkxC@O!yx?HR24*h`in2l% zfrFAVG0rww{8ZF3@2w_(bGd;I)(QBnR3G{YsKr40pd9kykurvULb@0Elb|L*ip*q( z3fohd+qyNKQhv~XBa`UZ(CgRg3HPK+3MG zHcg|4`#4k3y~A_6vm3k}Yu(uIQqIG18Fx9&eZR(itWCIZ8;K{&L^I_!G{qaV7Tf9% zSCS~BmrJQ75{KcUw{<3uaQs1(^ZHUJ!ppIk-D#{9(Cx+Wj?{JLRdG$WJjO@1^@R#w zM0c(8ov{ZA{Z*Biq4gANX%BDvK=o%T{8;HgSZNHuaYw)>KN$R>=$W$P|CV&xxcdlu3l5SYfcC*EqnJ!J|^s9*o!#W&}brVIxM zRTQBiB~qtH3iMN5T;5Ds$jd&ckPjoQq|B0l&5^7IWq325C<;$EEyM8^YkC`CO@=*s zwVVlk>tHp_6835YGt}W=+tFbhMeG<_CWH>iU&aa>b7nScp?pC3g@0(aZ(Vot% zpXf?=;NSM%Zu%D;J(2G0>h9=i?@D#zj}##t>E4dsuI_X%Aw-w%YVYbz_jGkYj88CK zM;p#E#1ZVB#4^>x|KK#5_V#pVJJ+%yCw<^^se12X0hUyH20LpT2zb|J&^IjX>#^n` z?%G9lpwfP|%7n%?rcg(OHuSa^^E+&hJ(=)29wKH)rZ=dw(udgg+RdDR7_CS~3;#k! zK`C8QRVUI!k@nF~sv?JIoaF3A4ON@Y=!t4XH|&Swi6QD+yBdvR5SS^Tns4AX4ch^v z%tzNDWCKLkAxaOR-FdaokN|}TM>%cLca6w8!(ZWd3>Rf=Z$N`<1`M(lq^-*;Y&ysv zD{v9oDCsN`WY^Dgc!*(?6pfA70G_8Bsw2@+Lot3HFFy_4P<7wtb^L(}0`@geW`rQ9 zhG!$D4bHED#YbvFKjl|L*^nCI&MR!Lf&t!psvDV-JIg4$UB3W-T$VpA-ZWd}wTEOj zC3AE5m~G$SIG;LWob91xo!Vt`?QL`Na%7uw=tZFxBX8yA+BUOoS=L>RHvg*&DMA;4 zP}B!$SkckhkgVvCE)h6>c`VA$Pb4*Pg^ptA85ovKG%=p|ScGW{er|7ae$Ew~V%1f_xKF|i# z>GwAW+Y#saY;_jyob6N@+jmDI+uVHf?PnfHj!9M{nPGOL3>SHqPh5sQbns{7Dk8E1 zT{pTdnmuyPUOwb7s%BWtJvSGqI<_w22 zNqHe2wun*fzwwyr6HKFK#zwR;D7S~>E4u0Uih_H3#T?ZjRR4;24(g6cM~oiqI;YWO zvRZ?X$<_5}1j3_6NkqjR(NeN9A}v(w3@v!>n=7WM`x(d~-^RrhSMaX1B7!rHN?Ofb zjr55$Ye6FiHUOG=|0EEr6L0|8B$#}BoGG4=J|*O^&PP^~G+kwOGdGJ3HVT1Bo^d#t z=82gI$43BG6M3NwinS`Pu{3*0{mJP{X}Z~if2n_ko7TkLfhyX0+P8!_t%xsH~_n zPmy%a^P>HMk@zDnokvbi*a5?XtH3Kej)A6QZm2#9ju6=#&r-!R4JT%l1SZK7a0pS< zf{G@SS(e3N6~l7iZ?GXZv_qBqq7D;3bV*&J)>d2@BkA;NWUBEN=*StoNd2Rf?jHUI z8QpzUs8ljmWutxjW-e*GiBH%mvtq3Ryqos-6mn$*w>icT)?7ka3=IS*=TjvOaYar) z7@gn|oREQJtHZn`D9YAQ?^8Wf3F@;%gZ>$4ZBSeqOe79l=}j7E(iX`kVX4vs`^l%C zSfF<^yMBnyr(tZXcy*|zQdz2FD|K?koTpN&IOd~-?OixW5ZlS8P}E-wy3XqA3UyOG zP6&Qau%u=$LB%pCa-JBP7d~<`CI$7_%}{IV_ma`6l1N{t!>%iZ?fPz_=~FswtKpfd zr%`lpsD@?u#;_-ty1Z7!;8faj_-T_FvY96OS8wm%o}r8*DkL(yM2$FR_>_+>K0Flv0VI8O@)% zh8LmkvHT3NvEXt4x-rX~oHL@)jJwmKPpY6)C8wJu7A9cL$MQC2@0VJoo#&GdcYI3rIqyH*n`feb3{b8vQf@02PXPYH&@Id*e znSxun2IH>_=cvI2j2$MLN1GHOg>n`oZ76jgM@4B^A}HGKTex4#Sh>LMssb!h6@ zQ-{Bp%{PlV6O<t=s&T=3qY7-%1^GZp=XWiD_g!-^61?y8@rYuHTu_gwO+WG1#gu${1qr#bp-DB5 zSZqVvDG)s(`j|f&4lg*v#NUMjCoWKbSK!mGvxHvNEUIy^b!ZPnlcpVF9WWZG=sZj% zR==YQMhd&kD_qQ6O->|+ z&IeN#9W_^S8_3u>5omg$x7P3=5Tj>-OUBRX&P*j{^s_ZpFo92&02 zlBN6%Ibtgzyqt8TBE^>14XpEP1eoE-CNn5B`yxISUN_)V!CC4kr^tu2iK7lOuqw10 zaZpH}3nvGW?jScemuCSl9@U-2!nMLebB~>FI?KHen?~yzH|DvT$8H~8buu238(>$A zPgnez3FJV#33m0bKcW3S*<$rnJUdazZYT>-b^V!#da?lfQKZqZOrWFSKfFsMcm^lQ zVVq7(OculE$?=I^+p~OH8r9yOnB1NaIiCB4R~@%?zH&V(+GI`mq$D<}w`a@AN6G3H zLEfSn;Pr^K#)f5rhqur{L8VN8E^2d%O#ySZdSo1#!m%J&;O9;j&+I)34qIapU~5(= zEK+B({K9P7S~bU}EzZ-&@X&Tro=3S7N~FQ}rchKP-BpK!uFbQIuaHz*IFG1BxS$O- zk~QAYmJ|~Z3$g*KZm|Wm8{PzXMnb+m45UVU3Bf8-_f6Av$V%FsqxsbH&4kCJ^^oU> z%Z(3bQ3eIKzX%!b*H_`W(mj!E<9OgXl^FoX%+aINYu1`Knz~r*9qo zw7DP7AgbLxP?Bv%)+z+M`e1qTl#<2R6fBc$vv{)PwA-od4)u{hVX#%+b&}A!(L1(n z6b`+jKSBm%T?f@r^uIVshn@4OK#o;8P#LdKkht+Kv0j!`DCC5r=@NiYMa)Ld38MdVSEAnwf|by5mP4seMW`4{h>54LR3RJOsG zyt*Y7FAXntjU+o!d913si)z0}DB!c>!W*CwE9T8I_0_;=RD(euMJlhO`3c1&u)b{Y zi+Kd9#gR$z)JSSftK@N;9@IvPv&fOEVpG?C$wpQFV11hHGzlL5TIem@}9`)cr^}w>&6H zWVKvPwWw}m-OhzMb(m-*25Jx;CW&&Zg(e-`n2Hs@c@ zVrS#~pid+@xQ)|-v2|>ma)Wb}9$e6JNFfXFiMYnXh7~n56vjo36_V# zCH*$R$W1yj~2t39zM0C?;^Dl>< z5o0kP+jSD`8}e0I$3c6D8Z}Qq9e|W@u9+S?G9fgY8Xoi7tyRb1EG|h?uR^w3eNJx~ zIyee%YEpNFgqr*W?dtem1dWJyQ?^ZRaw_j)79{6!xj)(U}Vut@`s(>1U6i@vyWqpo$@<(xoU2)sDW8=&9uP= zoH`3LYz7X&p}Lw%snFZDb(<;N1kcb@Bi1vTpQ#2j>T%62KnzdIJw)A^PEyMP9&yRD zsGbSX-B3(7+|jk>W+7Z{Bb8o*qdIoL89P|W6?hj4)q1fEU`p^uD}(bav4zf`9Fcmj zP;VnXHF~7^CG6{RVBVT~3XnJIrLkMgT7Vo&MSROBX2s(dwhEfXi&f*t!E?gzRGtH& zZcTric;RSCYPPz;^UT?)b923@6MTxX-v@^aEJ4^Gbyf<1xT}%KfvvDsDS&stQ-SOG zjZAUuX&ILhBxIMJ5KBb%VT0bLW&|kDTvAN_xOR0kacWip71E*>Fh;By3RW%BJ*dO*eviug;WNxQC8EiQ{cHPfU}zQK^hPpy*L+@0EJoKK9l;B`hjuzs(_ z?CH$b8I&R6&y*2cb0vG|tvvxPMR+9W0c)QCBsxoz0VL;@Vab)PY}>gyJcM8n4TAlF ziZk@nK+q=?aZe+KYm#07)un1`Ya~w48}$2E7y4mrOdv^xeEqnArr2Q*%lTFkx*;8| zk?5|daH1wO83V*9Po)QTWJhs&4@Y`Kj**3|W?nTnH8g-%*@qwk8IssAkDq@2L}y|# z%J^Dp8=gN0kv{L~3MsRLx*wpYxCg|MO%Omzi zYr2h#hP08;*l=nPdK2`bs<J zMb(8Bbw$*&LsavM%SOz@+sI!&&D~lba*d zgb(zTx>xM_OT||AAyr3IGlrLW&l1CO_6c z?9_CmFpNHr5W zEO+ja)cBqzJQ(E<23x=*3%@+I$!Jw!!h296y54wKB6w?E6E z3)yV-s4y(uVBE|udpT)oZVTU}TT=^>#b0POL4zO?BAGBXDuK>RAp+0MvO^XMQK;jZ zm1z2QFf~?db{EclD-NU3Js-^!xkV$!m00SUU`cMLLUB8e9uhx`zXChOhO?FICRL@Y zPE<=Y+S<$u$-vFmw+`K-ifZhQaC(qd*+GRd5)6RmI4}bgGK3cDu4Jc2ySlAzZ%s&I=FGRPb$W2?w8D%w`~muU#KBzK_=!awL} znAakJp`nWa+T3(W^vLuG40m40Fv&v0oMnj=nC1vwWd`ZCnAej#JuI*&BJcESb$fl1 zsh;YPJx7HRu&8lrb_RZy*g^QqRmqGibYhWU{WM#vpQ!Qa#jXv zcVa^)wk$b$84$Jb>5rpETW)f6Dq9*Wpng2n3ZR{legRcLQK8Hcs_lL#8>$m^+)8CM zw2uxeB!4zXig9`moc7(6c7-qq4zWU?P;1kR7BqY;O;RUQHTYnqg2qaEjB4wF z!W2mzB<(wtI+)$DjpN^NiXf&Huc+l`pHSUTHMK}FlsFHU)!Gc9N(Y}|(D07Aq{_cA zPf@Bkvps_msD*$-?u&U0ss+eNs5&wH(U}<^DFE2niL8yvPJerwGXrU{s>e`mDye%8 z8IF4|u-mQ^ZaZjOwH$ZVD3?0Asu7UJ1aUAQOwqL``GeZn^H+H5*`yp=5EgVP4c0)j zW>WD38)jT2qvNQ@>6MUkQ#O4y*joru)JW)fK^BK}gATpgdSw4SPR@KoM$o;xQShH^iv`kOg3>cD|u`WoV&hg~7>5`Pt zpsZXw;4J0CGTlsR(i^hnZOD9pmnP7hg;5M-bW#+ukoHAiFIbrf%xv0W7m6_t@G&n)yi2Mdfs;az ze<&lswi5PFju&z}Gm@+-I$)oVdegWb+7Z-G&Cf$Y@IKNFk*kxis}D>6Ah}&g_;kvY zWFJ$uSb?S~d`8BzqoR|ACuH&>LZ$EKS#7y0ky4EvV5bIUToxhrLiq+{fzD;>*H^?s z;#-YuQsJHpJz2dm{cg5VM+#H*8L80?a+1G?GG)!#ZV7gFBi$3KL{LwpyIRIQd1N)| zWr=Aop*VECCB7*BK&G(fy^Ix#71H%Do6h@?Di~J~TB;ny_Sj%@X$DH51B8~cnpydC znEYxIH7E*c5c00&(9uE^QpUtUQ8hf()MR;bszSTPN^@4oK?K|44LNnpWX35`x~7>* ziO#)x&@%Ebb2C{fNTH?fAy zg!(3FctcbJ6E*CAlEcLN2BA{ISv3kDTYhSA!^-i=Vtz0?G@eIWQeD`Q?w3pOL5MzS z$7@hK5g3V_UKE)Ga&l31!baLl)1WGH!zDhF(+8`=JGA0e8H9p&4di0-QA6-lBE`@T zErW9ANjg<3ZweZ#`7TJq9S->eQU|-O$u4ksjw7*o^46R_Yx%> z;o2LnbkVvTd~gwO3nsTd?#$gEUKJXOgj%*YReYjX!FPd^b;>70tw{~b^Div!pdiF% zY^C92)K{+b+gmBkxjqG;(Ez6mqUz9SZdz6)U({VqFEoa~M#Db8B!M z1m!Q#`42pN=nLNCSJkEXJGw$%Hy;;F85uF9oQiL{W2=pbQ}!V{~97P34+NA9zo5 zpM&7!dtk6e(t- zW^|f1ab|OuO&6x%o?UtI#VgM5^HZ(u?o4d*A#IaTBC%3&WWR34I^#nWmE;oH6tS+@y%1gEeM@=7IXQb2MJRlg@~` z;H6GxeWTfFI`I>ZW3q5nGa~|C)JO$l{2kL|0A+OdycWrx%Z2s$*D52O!m*Z}I7@>; z20A6V8jmPznGoD%u4v*P=2_G2qc|iETO_o?5yI0j!u(WMrJs~U*!A$+jTee2T1(&uc45U@Yqw)iVN7Tyw*_buYc3;lo7o;@v%;Y5fXf&a9_SE8 z9PvnFtuQoAZpOZeOl};Gfpq%>vKR8jA~IlLL{pMazBo#QcVhiSdpfgzqAT5jf7^Sz z>0el+6Y0*b?v9@Ju2d)fKzWSy6CLT^j^3{BbT1)9m+ors>P`1_bwE;1FkMGmI^Esg z*4;@gQ$74oD&5iEp6hwYTYn!JOU z2~D&}IjOhQBN?cLRR5G-U{uR)*eE6wOxUP0lWg85)S$;@ z{wPkx!L}lt@aCg2tSb+}Fo_*!TCTvk=H^;EO>ag|kk<2kOVh}?+g_NeOlMJ@IijLh zS8?&bX&j42OvqYqdQ*5`jJq!5d1bNGIMLBp5Hi37K(oG~`8ub4DFJvQQ?O#_$4H#*lvqO@*ylY~OL# zHnNHb2Wi-;em&ckjmWjK#)RfR%#f9c>^8J*$ufBZ)g)|y^GZqDJKL)0`f(I4)d+vz zS`Jjy;lzT|fubj-=A}BuCX2%jsgi;4sav|$S22NRB&~NbAs0z!Ce0Nm9MU=4KGm^@ zXG30iy%MaE92kiW2bow{PgCg)$YO`Hp3BInw}_4i3jEn2wY!NJaOV`I&t#H3brOn; zDrgBqa8@FV-QWP0tGU_;NY_2t;Em(1bCMHcPUELQ|b5E4lTHZMUXA3@&;=!L|_8T@+ z`2S@(!@!eE@JWChoZ>8~y z*Gg3xz1B*82LGa+1$;M2Tfx27{FpxiV-L6*yxu*PzTo_YA$sj2Kv z;bFfMAG#@6as#syg&eM*#I5j8E8k!4HB>Hpt#r&MPACIuerS3WB6Nf<*n8DR4y{C}jfyXy$~#XgrQZXZY6FZ$Vv&tLui z_mg)0A-&!{A3a$Jk5c;M^wU0i@XJ&1zg_>()8!lc>{%~=(|w7DUB5(NZ@J=jean!1 zVW0o^m=fxTHZK6z;J4q0+JA;G6!v+^u|jI?xBJ-Vh4}h+q3dVza=m>X(mT2BSJ)fI zFZ7-98yk`9?enf~p|tzE&tKH*&lfVU?LBh6eeQW~_4-rst9$(nFuFn?(>rjdTyLMJ z$mPMm)YkA1jl=NuhxB^;JV*m9^s`uhx6fDN@9^~pexUc)&%H<3lgov6ow2;ixqjCV zrG@tC(!1@yMz6R2->ui%=j~_No#fNy_ZH{+^~W8eV$Rur+fd~0Y4T0TQ8q|os5LDuM<8t&y0)R-#+ic7xajB z{c^p2xn6H{wXVMxU(g%3>(}V@YxMdV5)Ppsm*4mB9ktl5-~Uc&|NeJM`&;zI+H>3W z_8xzNYs2?H_%6Br;Jf7drbh1f8+W){6cN9=Rf>0x&G0Q$@Tl?!^ngAZ@^J_czXUe1N76bU+dsROF#CxNUs;P z`tOTBE;oL|+ND)6be(}qYFvNkV`nnSY0HgLKJC7SKBva@-#t$z?w0?wnVo!ny2ka( zmp+>>C^+g8D#Yp+n*xBb=y*@&OKPtzsX6R*0Pmg?M*BN+W zjqC4uj?W}5mq!PXdp-Rf?IGcOXituR+5dO)H}&RwFv#rrO)fkcxQ#ublz;cG9Ohph bIV*a{=wF_9QjP21JCf(?bIt|MpWgoiBbC&P diff --git a/opendbc/can/packer_pyx.cpp b/opendbc/can/packer_pyx.cpp deleted file mode 100644 index cb86232..0000000 --- a/opendbc/can/packer_pyx.cpp +++ /dev/null @@ -1,9741 +0,0 @@ -/* Generated by Cython 3.0.8 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [ - "opendbc/can/common.h", - "opendbc/can/common_dbc.h" - ], - "include_dirs": [ - "opendbc/can" - ], - "language": "c++", - "name": "opendbc.can.packer_pyx", - "sources": [ - "/data/openpilot/opendbc/can/packer_pyx.pyx" - ] - }, - "module_name": "opendbc.can.packer_pyx" -} -END: Cython Metadata */ - -#ifndef PY_SSIZE_T_CLEAN -#define PY_SSIZE_T_CLEAN -#endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#endif - -#include "Python.h" -#ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x030008F0 -#define CYTHON_FUTURE_DIVISION 1 -#include -#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX -#if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(CYTHON_LIMITED_API) - #ifdef Py_LIMITED_API - #undef __PYX_LIMITED_VERSION_HEX - #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API - #endif - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_USE_CPP_STD_MOVE - #if defined(__cplusplus) && (\ - __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) - #define CYTHON_USE_CPP_STD_MOVE 1 - #else - #define CYTHON_USE_CPP_STD_MOVE 0 - #endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif -#ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) -#else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) -#endif -#if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) -#else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) -#endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) - -#ifndef __cplusplus - #error "Cython files generated with the C++ option must be compiled with a C++ compiler." -#endif -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #else - #define CYTHON_INLINE inline - #endif -#endif -template -void __Pyx_call_destructor(T& x) { - x.~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } - T *operator->() { return ptr; } - T *operator&() { return ptr; } - operator T&() { return *ptr; } - template bool operator ==(const U& other) const { return *ptr == other; } - template bool operator !=(const U& other) const { return *ptr != other; } - template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } - template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } - private: - T *ptr; -}; - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyCodeObject *result; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - result = - #if PY_VERSION_HEX >= 0x030C0000 - PyUnstable_Code_NewWithPosOnlyArgs - #else - PyCode_NewWithPosOnlyArgs - #endif - (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); - Py_DECREF(empty_bytes); - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif -#endif -#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) -#else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) -#else - #define __Pyx_Py_Is(x, y) ((x) == (y)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) -#else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) -#else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) -#else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) -#endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) -#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) -#else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) -#endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 -#endif -#ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#endif -#if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords -#else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords -#endif -#if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) -#else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) -#endif -#if PY_MAJOR_VERSION >= 0x030900B1 -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) -#else -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) -#endif -#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) -#elif !CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) -#endif -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) -static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { - return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; -} -#endif -static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { -#if CYTHON_COMPILING_IN_LIMITED_API - return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; -#else - return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -#endif -} -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); -#else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod -#endif -#ifndef METH_METHOD - #define METH_METHOD 0x200 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() -#elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ - void *result; - result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); - return result; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { - PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); - if (res == NULL) PyErr_Clear(); - return res; -} -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { -#if CYTHON_COMPILING_IN_PYPY - return PyDict_GetItem(dict, name); -#else - PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; - assert(hash != -1); - ep = (mp->ma_lookup)(mp, name, hash); - if (ep == NULL) { - return NULL; - } - return ep->me_value; -#endif -} -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#endif -#if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE((PyObject*)obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} -#else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) - #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) - #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ - (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) -#else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) -#endif -#if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) -#else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) -#endif -#if CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) -#else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) -#endif -#if PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) -#else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#define __Pyx_truncl truncl -#endif - -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } -#define __PYX_ERR(f_index, lineno, Ln_error) \ - { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } - -#ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C -#elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif -#else - #define __PYX_EXTERN_C extern "C++" -#endif - -#define __PYX_HAVE__opendbc__can__packer_pyx -#define __PYX_HAVE_API__opendbc__can__packer_pyx -/* Early includes */ -#include -#include "ios" -#include "new" -#include "stdexcept" -#include "typeinfo" -#include -#include - - #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600) - // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully - #include - - namespace cython_std { - template typename std::remove_reference::type&& move(T& t) noexcept { return std::move(t); } - template typename std::remove_reference::type&& move(T&& t) noexcept { return std::move(t); } - } - - #endif - -#include -#include -#include -#include "common_dbc.h" -#include "common.h" -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 1 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "ascii" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif -#endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "opendbc/can/packer_pyx.pyx", - "", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - -/* #### Code section: numeric_typedefs ### */ -/* #### Code section: complex_type_declarations ### */ -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker; - -/* "common.pxd":11 - * - * - * ctypedef unsigned int (*calc_checksum_type)(uint32_t, const Signal&, const vector[uint8_t] &) # <<<<<<<<<<<<<< - * - * cdef extern from "common_dbc.h": - */ -typedef unsigned int (*__pyx_t_7opendbc_3can_6common_calc_checksum_type)(uint32_t, struct Signal const &, std::vector const &); - -/* "opendbc/can/packer_pyx.pyx":13 - * - * - * cdef class CANPacker: # <<<<<<<<<<<<<< - * cdef: - * cpp_CANPacker *packer - */ -struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker { - PyObject_HEAD - struct __pyx_vtabstruct_7opendbc_3can_10packer_pyx_CANPacker *__pyx_vtab; - CANPacker *packer; - struct DBC const *dbc; - std::map name_to_address; -}; - - - -struct __pyx_vtabstruct_7opendbc_3can_10packer_pyx_CANPacker { - std::vector (*pack)(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *, PyObject *, PyObject *); - PyObject *(*make_can_msg)(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch); -}; -static struct __pyx_vtabstruct_7opendbc_3can_10packer_pyx_CANPacker *__pyx_vtabptr_7opendbc_3can_10packer_pyx_CANPacker; -/* #### Code section: utility_code_proto ### */ - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ - } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) -#else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) -#endif -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); -#endif - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* fastcall.proto */ -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) -#define __Pyx_KwValues_VARARGS(args, nargs) NULL -#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) -#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) -#if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#endif - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* MoveIfSupported.proto */ -#if CYTHON_USE_CPP_STD_MOVE - #include - #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) -#else - #define __PYX_STD_MOVE_IF_SUPPORTED(x) x -#endif - -/* PyObjectFormatSimple.proto */ -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#elif PY_MAJOR_VERSION < 3 - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ - PyObject_Format(s, f)) -#elif CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ - likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ - PyObject_Format(s, f)) -#else - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#endif - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif - -/* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* UnpackTupleError.proto */ -static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); - -/* UnpackTuple2.proto */ -#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ - (likely(is_tuple || PyTuple_Check(tuple)) ?\ - (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ - __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ - (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ - __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); -static int __Pyx_unpack_tuple2_generic( - PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); - -/* dict_iter.proto */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_is_dict); -static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* ValidateBasesTuple.proto */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); -#endif - -/* PyType_Ready.proto */ -CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* SetVTable.proto */ -static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); - -/* GetVTable.proto */ -static void* __Pyx_GetVtable(PyTypeObject *type); - -/* MergeVTables.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type); -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); -#endif - -/* CythonFunctionShared.proto */ -#define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) -#define __Pyx_CyFunction_Defaults(type, f)\ - ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) -#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ - ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) -typedef struct { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject_HEAD - PyObject *func; -#elif PY_VERSION_HEX < 0x030900B1 - PyCFunctionObject func; -#else - PyCMethodObject func; -#endif -#if CYTHON_BACKPORT_VECTORCALL - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_weakreflist; -#endif - PyObject *func_dict; - PyObject *func_name; - PyObject *func_qualname; - PyObject *func_doc; - PyObject *func_globals; - PyObject *func_code; - PyObject *func_closure; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_classobj; -#endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; - PyObject *func_is_coroutine; -} __pyx_CyFunctionObject; -#undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#undef __Pyx_IsSameCFunction -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, - PyObject *tuple); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, - PyObject *dict); -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, - PyObject *dict); -static int __pyx_CyFunction_init(PyObject *module); -#if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) -#else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) -#endif -#endif - -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -/* None.proto */ -#include - -/* CppExceptionConversion.proto */ -#ifndef __Pyx_CppExn2PyErr -#include -#include -#include -#include -static void __Pyx_CppExn2PyErr() { - try { - if (PyErr_Occurred()) - ; // let the latest Python exn pass through and ignore the current one - else - throw; - } catch (const std::bad_alloc& exn) { - PyErr_SetString(PyExc_MemoryError, exn.what()); - } catch (const std::bad_cast& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::bad_typeid& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::domain_error& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::invalid_argument& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::ios_base::failure& exn) { - PyErr_SetString(PyExc_IOError, exn.what()); - } catch (const std::out_of_range& exn) { - PyErr_SetString(PyExc_IndexError, exn.what()); - } catch (const std::overflow_error& exn) { - PyErr_SetString(PyExc_OverflowError, exn.what()); - } catch (const std::range_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::underflow_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::exception& exn) { - PyErr_SetString(PyExc_RuntimeError, exn.what()); - } - catch (...) - { - PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); - } -} -#endif - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* CIntFromPy.proto */ -static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ -static std::vector __pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_pack(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_values); /* proto*/ -static PyObject *__pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_make_can_msg(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_name_or_addr, PyObject *__pyx_v_bus, PyObject *__pyx_v_values, int __pyx_skip_dispatch); /* proto*/ - -/* Module declarations from "libc.stdint" */ - -/* Module declarations from "libcpp.vector" */ - -/* Module declarations from "libcpp.utility" */ - -/* Module declarations from "libcpp.map" */ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libcpp.string" */ - -/* Module declarations from "libcpp" */ - -/* Module declarations from "libcpp.pair" */ - -/* Module declarations from "opendbc.can.common" */ - -/* Module declarations from "opendbc.can.packer_pyx" */ -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ -/* #### Code section: typeinfo ### */ -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "opendbc.can.packer_pyx" -extern int __pyx_module_is_main_opendbc__can__packer_pyx; -int __pyx_module_is_main_opendbc__can__packer_pyx = 0; - -/* Implementation of "opendbc.can.packer_pyx" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_RuntimeError; -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_TypeError; -/* #### Code section: string_decls ### */ -static const char __pyx_k__7[] = "?"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_bus[] = "bus"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; -static const char __pyx_k_self[] = "self"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_utf8[] = "utf8"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_enable[] = "enable"; -static const char __pyx_k_encode[] = "encode"; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_dbc_name[] = "dbc_name"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_CANPacker[] = "CANPacker"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_iteritems[] = "iteritems"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; -static const char __pyx_k_Can_t_lookup[] = "Can't lookup "; -static const char __pyx_k_RuntimeError[] = "RuntimeError"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_make_can_msg[] = "make_can_msg"; -static const char __pyx_k_name_or_addr[] = "name_or_addr"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_CANPacker_make_can_msg[] = "CANPacker.make_can_msg"; -static const char __pyx_k_opendbc_can_packer_pyx[] = "opendbc.can.packer_pyx"; -static const char __pyx_k_CANPacker___reduce_cython[] = "CANPacker.__reduce_cython__"; -static const char __pyx_k_opendbc_can_packer_pyx_pyx[] = "opendbc/can/packer_pyx.pyx"; -static const char __pyx_k_CANPacker___setstate_cython[] = "CANPacker.__setstate_cython__"; -static const char __pyx_k_self_dbc_self_packer_cannot_be_c[] = "self.dbc,self.packer cannot be converted to a Python object for pickling"; -/* #### Code section: decls ### */ -static int __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker___init__(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_dbc_name); /* proto */ -static void __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_2__dealloc__(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_4make_can_msg(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_name_or_addr, PyObject *__pyx_v_bus, PyObject *__pyx_v_values); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_tp_new_7opendbc_3can_10packer_pyx_CANPacker(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type_7opendbc_3can_10packer_pyx_CANPacker; - #endif - PyTypeObject *__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker; - PyObject *__pyx_n_s_CANPacker; - PyObject *__pyx_n_s_CANPacker___reduce_cython; - PyObject *__pyx_n_s_CANPacker___setstate_cython; - PyObject *__pyx_n_s_CANPacker_make_can_msg; - PyObject *__pyx_kp_u_Can_t_lookup; - PyObject *__pyx_n_s_RuntimeError; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_n_s__7; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_bus; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_dbc_name; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_n_s_encode; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_iteritems; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_make_can_msg; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_name_or_addr; - PyObject *__pyx_n_s_opendbc_can_packer_pyx; - PyObject *__pyx_kp_s_opendbc_can_packer_pyx_pyx; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_pyx_vtable; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_self; - PyObject *__pyx_kp_s_self_dbc_self_packer_cannot_be_c; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_u_utf8; - PyObject *__pyx_n_s_values; - PyObject *__pyx_int_0; - PyObject *__pyx_tuple_; - PyObject *__pyx_tuple__3; - PyObject *__pyx_tuple__5; - PyObject *__pyx_codeobj__2; - PyObject *__pyx_codeobj__4; - PyObject *__pyx_codeobj__6; -} __pyx_mstate; - -#if CYTHON_USE_MODULE_STATE -#ifdef __cplusplus -namespace { - extern struct PyModuleDef __pyx_moduledef; -} /* anonymous namespace */ -#else -static struct PyModuleDef __pyx_moduledef; -#endif - -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker); - Py_CLEAR(clear_module_state->__pyx_type_7opendbc_3can_10packer_pyx_CANPacker); - Py_CLEAR(clear_module_state->__pyx_n_s_CANPacker); - Py_CLEAR(clear_module_state->__pyx_n_s_CANPacker___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANPacker___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANPacker_make_can_msg); - Py_CLEAR(clear_module_state->__pyx_kp_u_Can_t_lookup); - Py_CLEAR(clear_module_state->__pyx_n_s_RuntimeError); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_n_s__7); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_bus); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_dbc_name); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_n_s_encode); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_iteritems); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_make_can_msg); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_name_or_addr); - Py_CLEAR(clear_module_state->__pyx_n_s_opendbc_can_packer_pyx); - Py_CLEAR(clear_module_state->__pyx_kp_s_opendbc_can_packer_pyx_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_vtable); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_self); - Py_CLEAR(clear_module_state->__pyx_kp_s_self_dbc_self_packer_cannot_be_c); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_u_utf8); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_tuple_); - Py_CLEAR(clear_module_state->__pyx_tuple__3); - Py_CLEAR(clear_module_state->__pyx_tuple__5); - Py_CLEAR(clear_module_state->__pyx_codeobj__2); - Py_CLEAR(clear_module_state->__pyx_codeobj__4); - Py_CLEAR(clear_module_state->__pyx_codeobj__6); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker); - Py_VISIT(traverse_module_state->__pyx_type_7opendbc_3can_10packer_pyx_CANPacker); - Py_VISIT(traverse_module_state->__pyx_n_s_CANPacker); - Py_VISIT(traverse_module_state->__pyx_n_s_CANPacker___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANPacker___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANPacker_make_can_msg); - Py_VISIT(traverse_module_state->__pyx_kp_u_Can_t_lookup); - Py_VISIT(traverse_module_state->__pyx_n_s_RuntimeError); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_n_s__7); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_bus); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_dbc_name); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_n_s_encode); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_iteritems); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_make_can_msg); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_name_or_addr); - Py_VISIT(traverse_module_state->__pyx_n_s_opendbc_can_packer_pyx); - Py_VISIT(traverse_module_state->__pyx_kp_s_opendbc_can_packer_pyx_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_vtable); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_self); - Py_VISIT(traverse_module_state->__pyx_kp_s_self_dbc_self_packer_cannot_be_c); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_u_utf8); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_tuple_); - Py_VISIT(traverse_module_state->__pyx_tuple__3); - Py_VISIT(traverse_module_state->__pyx_tuple__5); - Py_VISIT(traverse_module_state->__pyx_codeobj__2); - Py_VISIT(traverse_module_state->__pyx_codeobj__4); - Py_VISIT(traverse_module_state->__pyx_codeobj__6); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type_7opendbc_3can_10packer_pyx_CANPacker __pyx_mstate_global->__pyx_type_7opendbc_3can_10packer_pyx_CANPacker -#endif -#define __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker __pyx_mstate_global->__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker -#define __pyx_n_s_CANPacker __pyx_mstate_global->__pyx_n_s_CANPacker -#define __pyx_n_s_CANPacker___reduce_cython __pyx_mstate_global->__pyx_n_s_CANPacker___reduce_cython -#define __pyx_n_s_CANPacker___setstate_cython __pyx_mstate_global->__pyx_n_s_CANPacker___setstate_cython -#define __pyx_n_s_CANPacker_make_can_msg __pyx_mstate_global->__pyx_n_s_CANPacker_make_can_msg -#define __pyx_kp_u_Can_t_lookup __pyx_mstate_global->__pyx_kp_u_Can_t_lookup -#define __pyx_n_s_RuntimeError __pyx_mstate_global->__pyx_n_s_RuntimeError -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_n_s__7 __pyx_mstate_global->__pyx_n_s__7 -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_bus __pyx_mstate_global->__pyx_n_s_bus -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_dbc_name __pyx_mstate_global->__pyx_n_s_dbc_name -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_n_s_encode __pyx_mstate_global->__pyx_n_s_encode -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_iteritems __pyx_mstate_global->__pyx_n_s_iteritems -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_make_can_msg __pyx_mstate_global->__pyx_n_s_make_can_msg -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_name_or_addr __pyx_mstate_global->__pyx_n_s_name_or_addr -#define __pyx_n_s_opendbc_can_packer_pyx __pyx_mstate_global->__pyx_n_s_opendbc_can_packer_pyx -#define __pyx_kp_s_opendbc_can_packer_pyx_pyx __pyx_mstate_global->__pyx_kp_s_opendbc_can_packer_pyx_pyx -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_pyx_vtable __pyx_mstate_global->__pyx_n_s_pyx_vtable -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self -#define __pyx_kp_s_self_dbc_self_packer_cannot_be_c __pyx_mstate_global->__pyx_kp_s_self_dbc_self_packer_cannot_be_c -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_n_u_utf8 __pyx_mstate_global->__pyx_n_u_utf8 -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_tuple_ __pyx_mstate_global->__pyx_tuple_ -#define __pyx_tuple__3 __pyx_mstate_global->__pyx_tuple__3 -#define __pyx_tuple__5 __pyx_mstate_global->__pyx_tuple__5 -#define __pyx_codeobj__2 __pyx_mstate_global->__pyx_codeobj__2 -#define __pyx_codeobj__4 __pyx_mstate_global->__pyx_codeobj__4 -#define __pyx_codeobj__6 __pyx_mstate_global->__pyx_codeobj__6 -/* #### Code section: module_code ### */ - -/* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { - Py_ssize_t __pyx_v_length; - char const *__pyx_v_data; - std::string __pyx_r; - char const *__pyx_t_1; - std::string __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "string.from_py":14 - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) - */ - __pyx_v_length = 0; - - /* "string.from_py":15 - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< - * return string(data, length) - * - */ - __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) - __pyx_v_data = __pyx_t_1; - - /* "string.from_py":16 - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) # <<<<<<<<<<<<<< - * - * - */ - try { - __pyx_t_2 = std::string(__pyx_v_data, __pyx_v_length); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(1, 16, __pyx_L1_error) - } - __pyx_r = __pyx_t_2; - goto __pyx_L0; - - /* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - return __pyx_r; -} - -/* "opendbc/can/packer_pyx.pyx":19 - * map[string, int] name_to_address - * - * def __init__(self, dbc_name): # <<<<<<<<<<<<<< - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - */ - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_dbc_name = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dbc_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dbc_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 19, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 19, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - } - __pyx_v_dbc_name = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 19, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker___init__(((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self), __pyx_v_dbc_name); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker___init__(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_dbc_name) { - std::vector ::size_type __pyx_v_i; - struct Msg __pyx_v_msg; - int __pyx_r; - __Pyx_RefNannyDeclarations - std::string __pyx_t_1; - struct DBC const *__pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - std::vector ::size_type __pyx_t_6; - std::vector ::size_type __pyx_t_7; - std::vector ::size_type __pyx_t_8; - uint32_t __pyx_t_9; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); - - /* "opendbc/can/packer_pyx.pyx":20 - * - * def __init__(self, dbc_name): - * self.dbc = dbc_lookup(dbc_name) # <<<<<<<<<<<<<< - * if not self.dbc: - * raise RuntimeError(f"Can't lookup {dbc_name}") - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 20, __pyx_L1_error) - try { - __pyx_t_2 = dbc_lookup(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1)); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 20, __pyx_L1_error) - } - __pyx_v_self->dbc = __pyx_t_2; - - /* "opendbc/can/packer_pyx.pyx":21 - * def __init__(self, dbc_name): - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't lookup {dbc_name}") - * - */ - __pyx_t_3 = (!(__pyx_v_self->dbc != 0)); - if (unlikely(__pyx_t_3)) { - - /* "opendbc/can/packer_pyx.pyx":22 - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - * raise RuntimeError(f"Can't lookup {dbc_name}") # <<<<<<<<<<<<<< - * - * self.packer = new cpp_CANPacker(dbc_name) - */ - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_dbc_name, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Can_t_lookup, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 22, __pyx_L1_error) - - /* "opendbc/can/packer_pyx.pyx":21 - * def __init__(self, dbc_name): - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't lookup {dbc_name}") - * - */ - } - - /* "opendbc/can/packer_pyx.pyx":24 - * raise RuntimeError(f"Can't lookup {dbc_name}") - * - * self.packer = new cpp_CANPacker(dbc_name) # <<<<<<<<<<<<<< - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 24, __pyx_L1_error) - __pyx_v_self->packer = new CANPacker(__pyx_t_1); - - /* "opendbc/can/packer_pyx.pyx":25 - * - * self.packer = new cpp_CANPacker(dbc_name) - * for i in range(self.dbc[0].msgs.size()): # <<<<<<<<<<<<<< - * msg = self.dbc[0].msgs[i] - * self.name_to_address[string(msg.name)] = msg.address - */ - __pyx_t_6 = (__pyx_v_self->dbc[0]).msgs.size(); - __pyx_t_7 = __pyx_t_6; - for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_i = __pyx_t_8; - - /* "opendbc/can/packer_pyx.pyx":26 - * self.packer = new cpp_CANPacker(dbc_name) - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] # <<<<<<<<<<<<<< - * self.name_to_address[string(msg.name)] = msg.address - * - */ - __pyx_v_msg = ((__pyx_v_self->dbc[0]).msgs[__pyx_v_i]); - - /* "opendbc/can/packer_pyx.pyx":27 - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] - * self.name_to_address[string(msg.name)] = msg.address # <<<<<<<<<<<<<< - * - * def __dealloc__(self): - */ - __pyx_t_9 = __pyx_v_msg.address; - try { - __pyx_t_1 = std::string(__pyx_v_msg.name); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 27, __pyx_L1_error) - } - (__pyx_v_self->name_to_address[__pyx_t_1]) = __pyx_t_9; - } - - /* "opendbc/can/packer_pyx.pyx":19 - * map[string, int] name_to_address - * - * def __init__(self, dbc_name): # <<<<<<<<<<<<<< - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/packer_pyx.pyx":29 - * self.name_to_address[string(msg.name)] = msg.address - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self.packer: - * del self.packer - */ - -/* Python wrapper */ -static void __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_3__dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_2__dealloc__(((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_2__dealloc__(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self) { - int __pyx_t_1; - - /* "opendbc/can/packer_pyx.pyx":30 - * - * def __dealloc__(self): - * if self.packer: # <<<<<<<<<<<<<< - * del self.packer - * - */ - __pyx_t_1 = (__pyx_v_self->packer != 0); - if (__pyx_t_1) { - - /* "opendbc/can/packer_pyx.pyx":31 - * def __dealloc__(self): - * if self.packer: - * del self.packer # <<<<<<<<<<<<<< - * - * cdef vector[uint8_t] pack(self, addr, values): - */ - delete __pyx_v_self->packer; - - /* "opendbc/can/packer_pyx.pyx":30 - * - * def __dealloc__(self): - * if self.packer: # <<<<<<<<<<<<<< - * del self.packer - * - */ - } - - /* "opendbc/can/packer_pyx.pyx":29 - * self.name_to_address[string(msg.name)] = msg.address - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self.packer: - * del self.packer - */ - - /* function exit code */ -} - -/* "opendbc/can/packer_pyx.pyx":33 - * del self.packer - * - * cdef vector[uint8_t] pack(self, addr, values): # <<<<<<<<<<<<<< - * cdef vector[SignalPackValue] values_thing - * values_thing.reserve(len(values)) - */ - -static std::vector __pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_pack(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_addr, PyObject *__pyx_v_values) { - std::vector __pyx_v_values_thing; - struct SignalPackValue __pyx_v_spv; - PyObject *__pyx_v_name = NULL; - PyObject *__pyx_v_value = NULL; - std::vector __pyx_r; - __Pyx_RefNannyDeclarations - Py_ssize_t __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; - int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; - std::string __pyx_t_9; - double __pyx_t_10; - uint32_t __pyx_t_11; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("pack", 1); - - /* "opendbc/can/packer_pyx.pyx":35 - * cdef vector[uint8_t] pack(self, addr, values): - * cdef vector[SignalPackValue] values_thing - * values_thing.reserve(len(values)) # <<<<<<<<<<<<<< - * cdef SignalPackValue spv - * - */ - __pyx_t_1 = PyObject_Length(__pyx_v_values); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(0, 35, __pyx_L1_error) - try { - __pyx_v_values_thing.reserve(__pyx_t_1); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 35, __pyx_L1_error) - } - - /* "opendbc/can/packer_pyx.pyx":38 - * cdef SignalPackValue spv - * - * for name, value in values.iteritems(): # <<<<<<<<<<<<<< - * spv.name = name.encode("utf8") - * spv.value = value - */ - __pyx_t_1 = 0; - if (unlikely(__pyx_v_values == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "iteritems"); - __PYX_ERR(0, 38, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_values, 0, __pyx_n_s_iteritems, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_2); - __pyx_t_2 = __pyx_t_5; - __pyx_t_5 = 0; - while (1) { - __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_3, &__pyx_t_1, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); - if (unlikely(__pyx_t_7 == 0)) break; - if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GOTREF(__pyx_t_6); - __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_6); - __pyx_t_6 = 0; - - /* "opendbc/can/packer_pyx.pyx":39 - * - * for name, value in values.iteritems(): - * spv.name = name.encode("utf8") # <<<<<<<<<<<<<< - * spv.value = value - * values_thing.push_back(spv) - */ - __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_8 = NULL; - __pyx_t_7 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_5))) { - __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); - if (likely(__pyx_t_8)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); - __Pyx_INCREF(__pyx_t_8); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_5, function); - __pyx_t_7 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_n_u_utf8}; - __pyx_t_6 = __Pyx_PyObject_FastCall(__pyx_t_5, __pyx_callargs+1-__pyx_t_7, 1+__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __pyx_t_9 = __pyx_convert_string_from_py_std__in_string(__pyx_t_6); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_v_spv.name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_9); - - /* "opendbc/can/packer_pyx.pyx":40 - * for name, value in values.iteritems(): - * spv.name = name.encode("utf8") - * spv.value = value # <<<<<<<<<<<<<< - * values_thing.push_back(spv) - * - */ - __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L1_error) - __pyx_v_spv.value = __pyx_t_10; - - /* "opendbc/can/packer_pyx.pyx":41 - * spv.name = name.encode("utf8") - * spv.value = value - * values_thing.push_back(spv) # <<<<<<<<<<<<<< - * - * return self.packer.pack(addr, values_thing) - */ - try { - __pyx_v_values_thing.push_back(__pyx_v_spv); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 41, __pyx_L1_error) - } - } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "opendbc/can/packer_pyx.pyx":43 - * values_thing.push_back(spv) - * - * return self.packer.pack(addr, values_thing) # <<<<<<<<<<<<<< - * - * cpdef make_can_msg(self, name_or_addr, bus, values): - */ - __pyx_t_11 = __Pyx_PyInt_As_uint32_t(__pyx_v_addr); if (unlikely((__pyx_t_11 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 43, __pyx_L1_error) - __pyx_r = __pyx_v_self->packer->pack(__pyx_t_11, __pyx_v_values_thing); - goto __pyx_L0; - - /* "opendbc/can/packer_pyx.pyx":33 - * del self.packer - * - * cdef vector[uint8_t] pack(self, addr, values): # <<<<<<<<<<<<<< - * cdef vector[SignalPackValue] values_thing - * values_thing.reserve(len(values)) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); - __Pyx_XDECREF(__pyx_t_8); - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.pack", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_name); - __Pyx_XDECREF(__pyx_v_value); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/packer_pyx.pyx":45 - * return self.packer.pack(addr, values_thing) - * - * cpdef make_can_msg(self, name_or_addr, bus, values): # <<<<<<<<<<<<<< - * cdef int addr - * if isinstance(name_or_addr, int): - */ - -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyObject *__pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_make_can_msg(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_name_or_addr, PyObject *__pyx_v_bus, PyObject *__pyx_v_values, int __pyx_skip_dispatch) { - int __pyx_v_addr; - std::vector __pyx_v_val; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *__pyx_t_4 = NULL; - int __pyx_t_5; - int __pyx_t_6; - std::string __pyx_t_7; - std::vector __pyx_t_8; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("make_can_msg", 1); - /* Check if called by wrapper */ - if (unlikely(__pyx_skip_dispatch)) ; - /* Check if overridden in Python */ - else if (unlikely((Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0) || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)))) { - #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS - static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; - if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { - PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); - #endif - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_make_can_msg); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (!__Pyx_IsSameCFunction(__pyx_t_1, (void*) __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg)) { - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_t_1); - __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_3))) { - __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); - if (likely(__pyx_t_4)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); - __Pyx_INCREF(__pyx_t_4); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_3, function); - __pyx_t_5 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_v_name_or_addr, __pyx_v_bus, __pyx_v_values}; - __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 3+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - } - __pyx_r = __pyx_t_2; - __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - goto __pyx_L0; - } - #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS - __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); - __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); - if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { - __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; - } - #endif - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS - } - #endif - } - - /* "opendbc/can/packer_pyx.pyx":47 - * cpdef make_can_msg(self, name_or_addr, bus, values): - * cdef int addr - * if isinstance(name_or_addr, int): # <<<<<<<<<<<<<< - * addr = name_or_addr - * else: - */ - __pyx_t_6 = PyInt_Check(__pyx_v_name_or_addr); - if (__pyx_t_6) { - - /* "opendbc/can/packer_pyx.pyx":48 - * cdef int addr - * if isinstance(name_or_addr, int): - * addr = name_or_addr # <<<<<<<<<<<<<< - * else: - * addr = self.name_to_address[name_or_addr.encode("utf8")] - */ - __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_name_or_addr); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 48, __pyx_L1_error) - __pyx_v_addr = __pyx_t_5; - - /* "opendbc/can/packer_pyx.pyx":47 - * cpdef make_can_msg(self, name_or_addr, bus, values): - * cdef int addr - * if isinstance(name_or_addr, int): # <<<<<<<<<<<<<< - * addr = name_or_addr - * else: - */ - goto __pyx_L3; - } - - /* "opendbc/can/packer_pyx.pyx":50 - * addr = name_or_addr - * else: - * addr = self.name_to_address[name_or_addr.encode("utf8")] # <<<<<<<<<<<<<< - * - * cdef vector[uint8_t] val = self.pack(addr, values) - */ - /*else*/ { - __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name_or_addr, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = NULL; - __pyx_t_5 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_2))) { - __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); - if (likely(__pyx_t_3)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); - __Pyx_INCREF(__pyx_t_3); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_2, function); - __pyx_t_5 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_n_u_utf8}; - __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); - __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - } - __pyx_t_7 = __pyx_convert_string_from_py_std__in_string(__pyx_t_1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 50, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_addr = (__pyx_v_self->name_to_address[__pyx_t_7]); - } - __pyx_L3:; - - /* "opendbc/can/packer_pyx.pyx":52 - * addr = self.name_to_address[name_or_addr.encode("utf8")] - * - * cdef vector[uint8_t] val = self.pack(addr, values) # <<<<<<<<<<<<<< - * return [addr, 0, (&val[0])[:val.size()], bus] - */ - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = ((struct __pyx_vtabstruct_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self->__pyx_vtab)->pack(__pyx_v_self, __pyx_t_1, __pyx_v_values); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_val = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_8); - - /* "opendbc/can/packer_pyx.pyx":53 - * - * cdef vector[uint8_t] val = self.pack(addr, values) - * return [addr, 0, (&val[0])[:val.size()], bus] # <<<<<<<<<<<<<< - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __Pyx_PyBytes_FromStringAndSize(((char *)(&(__pyx_v_val[0]))) + 0, __pyx_v_val.size() - 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyList_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_GIVEREF(__pyx_t_1); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(0, 53, __pyx_L1_error); - __Pyx_INCREF(__pyx_int_0); - __Pyx_GIVEREF(__pyx_int_0); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_int_0)) __PYX_ERR(0, 53, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_2); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_t_2)) __PYX_ERR(0, 53, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_bus); - __Pyx_GIVEREF(__pyx_v_bus); - if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_v_bus)) __PYX_ERR(0, 53, __pyx_L1_error); - __pyx_t_1 = 0; - __pyx_t_2 = 0; - __pyx_r = __pyx_t_3; - __pyx_t_3 = 0; - goto __pyx_L0; - - /* "opendbc/can/packer_pyx.pyx":45 - * return self.packer.pack(addr, values_thing) - * - * cpdef make_can_msg(self, name_or_addr, bus, values): # <<<<<<<<<<<<<< - * cdef int addr - * if isinstance(name_or_addr, int): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.make_can_msg", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg = {"make_can_msg", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v_name_or_addr = 0; - PyObject *__pyx_v_bus = 0; - PyObject *__pyx_v_values = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("make_can_msg (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name_or_addr,&__pyx_n_s_bus,&__pyx_n_s_values,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name_or_addr)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bus)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("make_can_msg", 1, 3, 3, 1); __PYX_ERR(0, 45, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_values)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 45, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("make_can_msg", 1, 3, 3, 2); __PYX_ERR(0, 45, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "make_can_msg") < 0)) __PYX_ERR(0, 45, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 3)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); - } - __pyx_v_name_or_addr = values[0]; - __pyx_v_bus = values[1]; - __pyx_v_values = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("make_can_msg", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 45, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.make_can_msg", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_4make_can_msg(((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self), __pyx_v_name_or_addr, __pyx_v_bus, __pyx_v_values); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_4make_can_msg(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, PyObject *__pyx_v_name_or_addr, PyObject *__pyx_v_bus, PyObject *__pyx_v_values) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("make_can_msg", 1); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_make_can_msg(__pyx_v_self, __pyx_v_name_or_addr, __pyx_v_bus, __pyx_v_values, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.make_can_msg", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_6__reduce_cython__(((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_dbc_self_packer_cannot_be_c, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_8__setstate_cython__(((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10packer_pyx_9CANPacker_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":4 - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_dbc_self_packer_cannot_be_c, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.packer_pyx.CANPacker.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} -static struct __pyx_vtabstruct_7opendbc_3can_10packer_pyx_CANPacker __pyx_vtable_7opendbc_3can_10packer_pyx_CANPacker; - -static PyObject *__pyx_tp_new_7opendbc_3can_10packer_pyx_CANPacker(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)o); - p->__pyx_vtab = __pyx_vtabptr_7opendbc_3can_10packer_pyx_CANPacker; - new((void*)&(p->name_to_address)) std::map (); - return o; -} - -static void __pyx_tp_dealloc_7opendbc_3can_10packer_pyx_CANPacker(PyObject *o) { - struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *p = (struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7opendbc_3can_10packer_pyx_CANPacker) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_3__dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - __Pyx_call_destructor(p->name_to_address); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static PyMethodDef __pyx_methods_7opendbc_3can_10packer_pyx_CANPacker[] = { - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type_7opendbc_3can_10packer_pyx_CANPacker_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7opendbc_3can_10packer_pyx_CANPacker}, - {Py_tp_methods, (void *)__pyx_methods_7opendbc_3can_10packer_pyx_CANPacker}, - {Py_tp_init, (void *)__pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_1__init__}, - {Py_tp_new, (void *)__pyx_tp_new_7opendbc_3can_10packer_pyx_CANPacker}, - {0, 0}, -}; -static PyType_Spec __pyx_type_7opendbc_3can_10packer_pyx_CANPacker_spec = { - "opendbc.can.packer_pyx.CANPacker", - sizeof(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, - __pyx_type_7opendbc_3can_10packer_pyx_CANPacker_slots, -}; -#else - -static PyTypeObject __pyx_type_7opendbc_3can_10packer_pyx_CANPacker = { - PyVarObject_HEAD_INIT(0, 0) - "opendbc.can.packer_pyx.""CANPacker", /*tp_name*/ - sizeof(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_7opendbc_3can_10packer_pyx_CANPacker, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ - 0, /*tp_doc*/ - 0, /*tp_traverse*/ - 0, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_7opendbc_3can_10packer_pyx_CANPacker, /*tp_methods*/ - 0, /*tp_members*/ - 0, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - __pyx_pw_7opendbc_3can_10packer_pyx_9CANPacker_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_7opendbc_3can_10packer_pyx_CANPacker, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_n_s_CANPacker, __pyx_k_CANPacker, sizeof(__pyx_k_CANPacker), 0, 0, 1, 1}, - {&__pyx_n_s_CANPacker___reduce_cython, __pyx_k_CANPacker___reduce_cython, sizeof(__pyx_k_CANPacker___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANPacker___setstate_cython, __pyx_k_CANPacker___setstate_cython, sizeof(__pyx_k_CANPacker___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANPacker_make_can_msg, __pyx_k_CANPacker_make_can_msg, sizeof(__pyx_k_CANPacker_make_can_msg), 0, 0, 1, 1}, - {&__pyx_kp_u_Can_t_lookup, __pyx_k_Can_t_lookup, sizeof(__pyx_k_Can_t_lookup), 0, 1, 0, 0}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s__7, __pyx_k__7, sizeof(__pyx_k__7), 0, 0, 1, 1}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_bus, __pyx_k_bus, sizeof(__pyx_k_bus), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_dbc_name, __pyx_k_dbc_name, sizeof(__pyx_k_dbc_name), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__pyx_n_s_iteritems, __pyx_k_iteritems, sizeof(__pyx_k_iteritems), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_make_can_msg, __pyx_k_make_can_msg, sizeof(__pyx_k_make_can_msg), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_name_or_addr, __pyx_k_name_or_addr, sizeof(__pyx_k_name_or_addr), 0, 0, 1, 1}, - {&__pyx_n_s_opendbc_can_packer_pyx, __pyx_k_opendbc_can_packer_pyx, sizeof(__pyx_k_opendbc_can_packer_pyx), 0, 0, 1, 1}, - {&__pyx_kp_s_opendbc_can_packer_pyx_pyx, __pyx_k_opendbc_can_packer_pyx_pyx, sizeof(__pyx_k_opendbc_can_packer_pyx_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, - {&__pyx_kp_s_self_dbc_self_packer_cannot_be_c, __pyx_k_self_dbc_self_packer_cannot_be_c, sizeof(__pyx_k_self_dbc_self_packer_cannot_be_c), 0, 0, 1, 0}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_u_utf8, __pyx_k_utf8, sizeof(__pyx_k_utf8), 0, 1, 0, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 22, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 25, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "opendbc/can/packer_pyx.pyx":45 - * return self.packer.pack(addr, values_thing) - * - * cpdef make_can_msg(self, name_or_addr, bus, values): # <<<<<<<<<<<<<< - * cdef int addr - * if isinstance(name_or_addr, int): - */ - __pyx_tuple_ = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_name_or_addr, __pyx_n_s_bus, __pyx_n_s_values); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - __pyx_codeobj__2 = (PyObject*)__Pyx_PyCode_New(4, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple_, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_opendbc_can_packer_pyx_pyx, __pyx_n_s_make_can_msg, 45, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__2)) __PYX_ERR(0, 45, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__3); - __Pyx_GIVEREF(__pyx_tuple__3); - __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__3, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - */ - __pyx_tuple__5 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__5); - __Pyx_GIVEREF(__pyx_tuple__5); - __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__5, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - return 0; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - __pyx_vtabptr_7opendbc_3can_10packer_pyx_CANPacker = &__pyx_vtable_7opendbc_3can_10packer_pyx_CANPacker; - __pyx_vtable_7opendbc_3can_10packer_pyx_CANPacker.pack = (std::vector (*)(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *, PyObject *, PyObject *))__pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_pack; - __pyx_vtable_7opendbc_3can_10packer_pyx_CANPacker.make_can_msg = (PyObject *(*)(struct __pyx_obj_7opendbc_3can_10packer_pyx_CANPacker *, PyObject *, PyObject *, PyObject *, int __pyx_skip_dispatch))__pyx_f_7opendbc_3can_10packer_pyx_9CANPacker_make_can_msg; - #if CYTHON_USE_TYPE_SPECS - __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7opendbc_3can_10packer_pyx_CANPacker_spec, NULL); if (unlikely(!__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker)) __PYX_ERR(0, 13, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7opendbc_3can_10packer_pyx_CANPacker_spec, __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #else - __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker = &__pyx_type_7opendbc_3can_10packer_pyx_CANPacker; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker->tp_dictoffset && __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (__Pyx_SetVtable(__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker, __pyx_vtabptr_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_MergeVtables(__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_CANPacker, (PyObject *) __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker) < 0) __PYX_ERR(0, 13, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_packer_pyx(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_packer_pyx}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "packer_pyx", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - #if CYTHON_USE_MODULE_STATE - __pyx_m_traverse, /* m_traverse */ - __pyx_m_clear, /* m_clear */ - NULL /* m_free */ - #else - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ - #endif - }; - #ifdef __cplusplus -} /* anonymous namespace */ -#endif -#endif - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initpacker_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initpacker_pyx(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_packer_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_packer_pyx(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - CYTHON_UNUSED_VAR(def); - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_packer_pyx(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'packer_pyx' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("packer_pyx", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "packer_pyx" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_packer_pyx(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_opendbc__can__packer_pyx) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "opendbc.can.packer_pyx")) { - if (unlikely((PyDict_SetItemString(modules, "opendbc.can.packer_pyx", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "opendbc/can/packer_pyx.pyx":45 - * return self.packer.pack(addr, values_thing) - * - * cpdef make_can_msg(self, name_or_addr, bus, values): # <<<<<<<<<<<<<< - * cdef int addr - * if isinstance(name_or_addr, int): - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_5make_can_msg, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANPacker_make_can_msg, NULL, __pyx_n_s_opendbc_can_packer_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__2)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker, __pyx_n_s_make_can_msg, __pyx_t_2) < 0) __PYX_ERR(0, 45, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - PyType_Modified(__pyx_ptype_7opendbc_3can_10packer_pyx_CANPacker); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANPacker___reduce_cython, NULL, __pyx_n_s_opendbc_can_packer_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__4)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc,self.packer cannot be converted to a Python object for pickling" - */ - __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10packer_pyx_9CANPacker_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANPacker___setstate_cython, NULL, __pyx_n_s_opendbc_can_packer_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__6)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "opendbc/can/packer_pyx.pyx":1 - * # distutils: language = c++ # <<<<<<<<<<<<<< - * # cython: c_string_encoding=ascii, language_level=3 - * - */ - __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init opendbc.can.packer_pyx", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init opendbc.can.packer_pyx"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### Code section: cleanup_globals ### */ -/* #### Code section: cleanup_module ### */ -/* #### Code section: main_method ### */ -/* #### Code section: utility_code_pragmas ### */ -#ifdef _MSC_VER -#pragma warning( push ) -/* Warning 4127: conditional expression is constant - * Cython uses constant conditional expressions to allow in inline functions to be optimized at - * compile-time, so this warning is not useful - */ -#pragma warning( disable : 4127 ) -#endif - - - -/* #### Code section: utility_code_def ### */ - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030C00A6 - PyObject *current_exception = tstate->current_exception; - if (unlikely(!current_exception)) return 0; - exc_type = (PyObject*) Py_TYPE(current_exception); - if (exc_type == err) return 1; -#else - exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; -#endif - #if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(exc_type); - #endif - if (unlikely(PyTuple_Check(err))) { - result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - } else { - result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); - } - #if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(exc_type); - #endif - return result; -} -#endif - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject *tmp_value; - assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); - if (value) { - #if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) - #endif - PyException_SetTraceback(value, tb); - } - tmp_value = tstate->current_exception; - tstate->current_exception = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#endif -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject* exc_value; - exc_value = tstate->current_exception; - tstate->current_exception = 0; - *value = exc_value; - *type = NULL; - *tb = NULL; - if (exc_value) { - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - #if CYTHON_COMPILING_IN_CPYTHON - *tb = ((PyBaseExceptionObject*) exc_value)->traceback; - Py_XINCREF(*tb); - #else - *tb = PyException_GetTraceback(exc_value); - #endif - } -#else - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#endif -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); - } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); - } - return result; -#endif -} - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* TupleAndListFromArray */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { - PyObject *v; - Py_ssize_t i; - for (i = 0; i < length; i++) { - v = dest[i] = src[i]; - Py_INCREF(v); - } -} -static CYTHON_INLINE PyObject * -__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - Py_INCREF(__pyx_empty_tuple); - return __pyx_empty_tuple; - } - res = PyTuple_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); - return res; -} -static CYTHON_INLINE PyObject * -__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - return PyList_New(0); - } - res = PyList_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); - return res; -} -#endif - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); - } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); - } -#endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -#endif -} - -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; - } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); -#endif -} - -/* fastcall */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) -{ - Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); - if (unlikely(eq != 0)) { - if (unlikely(eq < 0)) return NULL; - return kwvalues[i]; - } - } - return NULL; -} -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 -CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* RaiseArgTupleInvalid */ -static void __Pyx_RaiseArgtupleInvalid( - const char* func_name, - int exact, - Py_ssize_t num_min, - Py_ssize_t num_max, - Py_ssize_t num_found) -{ - Py_ssize_t num_expected; - const char *more_or_less; - if (num_found < num_min) { - num_expected = num_min; - more_or_less = "at least"; - } else { - num_expected = num_max; - more_or_less = "at most"; - } - if (exact) { - more_or_less = "exactly"; - } - PyErr_Format(PyExc_TypeError, - "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", - func_name, more_or_less, num_expected, - (num_expected == 1) ? "" : "s", num_found); -} - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectFastCall */ -#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { - PyObject *argstuple; - PyObject *result = 0; - size_t i; - argstuple = PyTuple_New((Py_ssize_t)nargs); - if (unlikely(!argstuple)) return NULL; - for (i = 0; i < nargs; i++) { - Py_INCREF(args[i]); - if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; - } - result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: - Py_DECREF(argstuple); - return result; -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { - Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); -#if CYTHON_COMPILING_IN_CPYTHON - if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) - return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) - return __Pyx_PyObject_CallMethO(func, args[0]); - } -#endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL - if (PyCFunction_Check(func)) { - if (kwargs) { - return _PyCFunction_FastCallDict(func, args, nargs, kwargs); - } else { - return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); - } - } - #if PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #endif - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); - } - #endif - #endif - if (kwargs == NULL) { - #if CYTHON_VECTORCALL - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)nargs, NULL); - } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL - if (__Pyx_CyFunction_CheckExact(func)) { - __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); - if (f) return f(func, args, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); - } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API - return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else - return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif -} - -/* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { - #if PY_VERSION_HEX >= 0x030C00A6 - PyException_SetTraceback(value, tb); - #elif CYTHON_FAST_THREAD_STATE - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* IterFinish */ -static CYTHON_INLINE int __Pyx_IterFinish(void) { - PyObject* exc_type; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - exc_type = __Pyx_PyErr_CurrentExceptionType(); - if (unlikely(exc_type)) { - if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) - return -1; - __Pyx_PyErr_Clear(); - return 0; - } - return 0; -} - -/* PyObjectCallNoArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { - PyObject *arg[2] = {NULL, NULL}; - return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* PyObjectGetMethod */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { - PyObject *attr; -#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP - __Pyx_TypeName type_name; - PyTypeObject *tp = Py_TYPE(obj); - PyObject *descr; - descrgetfunc f = NULL; - PyObject **dictptr, *dict; - int meth_found = 0; - assert (*method == NULL); - if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; - } - if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; - } - descr = _PyType_Lookup(tp, name); - if (likely(descr != NULL)) { - Py_INCREF(descr); -#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR - if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) -#elif PY_MAJOR_VERSION >= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) - #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif -#endif - { - meth_found = 1; - } else { - f = Py_TYPE(descr)->tp_descr_get; - if (f != NULL && PyDescr_IsData(descr)) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - } - } - dictptr = _PyObject_GetDictPtr(obj); - if (dictptr != NULL && (dict = *dictptr) != NULL) { - Py_INCREF(dict); - attr = __Pyx_PyDict_GetItemStr(dict, name); - if (attr != NULL) { - Py_INCREF(attr); - Py_DECREF(dict); - Py_XDECREF(descr); - goto try_unpack; - } - Py_DECREF(dict); - } - if (meth_found) { - *method = descr; - return 1; - } - if (f != NULL) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - if (likely(descr != NULL)) { - *method = descr; - return 0; - } - type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return 0; -#else - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; -#endif -try_unpack: -#if CYTHON_UNPACK_METHODS - if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { - PyObject *function = PyMethod_GET_FUNCTION(attr); - Py_INCREF(function); - Py_DECREF(attr); - *method = function; - return 1; - } -#endif - *method = attr; - return 0; -} - -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; -} - -/* RaiseNeedMoreValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* UnpackItemEndCheck */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } - return __Pyx_IterFinish(); -} - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* UnpackTupleError */ -static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { - if (t == Py_None) { - __Pyx_RaiseNoneNotIterableError(); - } else if (PyTuple_GET_SIZE(t) < index) { - __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); - } else { - __Pyx_RaiseTooManyValuesError(index); - } -} - -/* UnpackTuple2 */ -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { - PyObject *value1 = NULL, *value2 = NULL; -#if CYTHON_COMPILING_IN_PYPY - value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; - value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; -#else - value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); - value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); -#endif - if (decref_tuple) { - Py_DECREF(tuple); - } - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -#if CYTHON_COMPILING_IN_PYPY -bad: - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -#endif -} -static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, - int has_known_size, int decref_tuple) { - Py_ssize_t index; - PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; - iternextfunc iternext; - iter = PyObject_GetIter(tuple); - if (unlikely(!iter)) goto bad; - if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } - iternext = __Pyx_PyObject_GetIterNextFunc(iter); - value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } - value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } - if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; - Py_DECREF(iter); - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -unpacking_failed: - if (!has_known_size && __Pyx_IterFinish() == 0) - __Pyx_RaiseNeedMoreValuesError(index); -bad: - Py_XDECREF(iter); - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -} - -/* dict_iter */ -#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 -#include -#endif -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_source_is_dict) { - is_dict = is_dict || likely(PyDict_CheckExact(iterable)); - *p_source_is_dict = is_dict; - if (is_dict) { -#if !CYTHON_COMPILING_IN_PYPY - *p_orig_length = PyDict_Size(iterable); - Py_INCREF(iterable); - return iterable; -#elif PY_MAJOR_VERSION >= 3 - static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; - PyObject **pp = NULL; - if (method_name) { - const char *name = PyUnicode_AsUTF8(method_name); - if (strcmp(name, "iteritems") == 0) pp = &py_items; - else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; - else if (strcmp(name, "itervalues") == 0) pp = &py_values; - if (pp) { - if (!*pp) { - *pp = PyUnicode_FromString(name + 4); - if (!*pp) - return NULL; - } - method_name = *pp; - } - } -#endif - } - *p_orig_length = 0; - if (method_name) { - PyObject* iter; - iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); - if (!iterable) - return NULL; -#if !CYTHON_COMPILING_IN_PYPY - if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) - return iterable; -#endif - iter = PyObject_GetIter(iterable); - Py_DECREF(iterable); - return iter; - } - return PyObject_GetIter(iterable); -} -static CYTHON_INLINE int __Pyx_dict_iter_next( - PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { - PyObject* next_item; -#if !CYTHON_COMPILING_IN_PYPY - if (source_is_dict) { - PyObject *key, *value; - if (unlikely(orig_length != PyDict_Size(iter_obj))) { - PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); - return -1; - } - if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { - return 0; - } - if (pitem) { - PyObject* tuple = PyTuple_New(2); - if (unlikely(!tuple)) { - return -1; - } - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(tuple, 0, key); - PyTuple_SET_ITEM(tuple, 1, value); - *pitem = tuple; - } else { - if (pkey) { - Py_INCREF(key); - *pkey = key; - } - if (pvalue) { - Py_INCREF(value); - *pvalue = value; - } - } - return 1; - } else if (PyTuple_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyTuple_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else if (PyList_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyList_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else -#endif - { - next_item = PyIter_Next(iter_obj); - if (unlikely(!next_item)) { - return __Pyx_IterFinish(); - } - } - if (pitem) { - *pitem = next_item; - } else if (pkey && pvalue) { - if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) - return -1; - } else if (pkey) { - *pkey = next_item; - } else { - *pvalue = next_item; - } - return 1; -} - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - if (strcmp(memb->name, "__weaklistoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_weaklistoffset = memb->offset; - changed = 1; - } - else if (strcmp(memb->name, "__dictoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_dictoffset = memb->offset; - changed = 1; - } -#if CYTHON_METH_FASTCALL - else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); -#if PY_VERSION_HEX >= 0x030800b4 - type->tp_vectorcall_offset = memb->offset; -#else - type->tp_print = (printfunc) memb->offset; -#endif - changed = 1; - } -#endif -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - else if (strcmp(memb->name, "__module__") == 0) { - PyObject *descr; - assert(memb->type == T_OBJECT); - assert(memb->flags == 0 || memb->flags == READONLY); - descr = PyDescr_NewMember(type, memb); - if (unlikely(!descr)) - return -1; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#endif - -/* ValidateBasesTuple */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { - Py_ssize_t i, n; -#if CYTHON_ASSUME_SAFE_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#if CYTHON_AVOID_BORROWED_REFS - PyObject *b0 = PySequence_GetItem(bases, i); - if (!b0) return -1; -#elif CYTHON_ASSUME_SAFE_MACROS - PyObject *b0 = PyTuple_GET_ITEM(bases, i); -#else - PyObject *b0 = PyTuple_GetItem(bases, i); - if (!b0) return -1; -#endif - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); - __Pyx_DECREF_TypeName(b_name); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - if (dictoffset == 0) - { - Py_ssize_t b_dictoffset = 0; -#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - b_dictoffset = b->tp_dictoffset; -#else - PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); - if (!py_b_dictoffset) goto dictoffset_return; - b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); - Py_DECREF(py_b_dictoffset); - if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; -#endif - if (b_dictoffset) { - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "extension type '%.200s' has no __dict__ slot, " - "but base type '" __Pyx_FMT_TYPENAME "' has: " - "either add 'cdef dict __dict__' to the extension type " - "or add '__slots__ = [...]' to the base type", - type_name, b_name); - __Pyx_DECREF_TypeName(b_name); - } -#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) - dictoffset_return: -#endif -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - } -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - } - return 0; -} -#endif - -/* PyType_Ready */ -static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) - (void)__Pyx_PyObject_CallMethod0; -#if CYTHON_USE_TYPE_SPECS - (void)__Pyx_validate_bases_tuple; -#endif - return PyType_Ready(t); -#else - int r; - PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); - if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) - return -1; -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - { - int gc_was_enabled; - #if PY_VERSION_HEX >= 0x030A00b1 - gc_was_enabled = PyGC_Disable(); - (void)__Pyx_PyObject_CallMethod0; - #else - PyObject *ret, *py_status; - PyObject *gc = NULL; - #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); - if (unlikely(!py_status)) { - Py_DECREF(gc); - return -1; - } - gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); - Py_DECREF(py_status); - if (gc_was_enabled > 0) { - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); - if (unlikely(!ret)) { - Py_DECREF(gc); - return -1; - } - Py_DECREF(ret); - } else if (unlikely(gc_was_enabled == -1)) { - Py_DECREF(gc); - return -1; - } - #endif - t->tp_flags |= Py_TPFLAGS_HEAPTYPE; -#if PY_VERSION_HEX >= 0x030A0000 - t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; -#endif -#else - (void)__Pyx_PyObject_CallMethod0; -#endif - r = PyType_Ready(t); -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; - #if PY_VERSION_HEX >= 0x030A00b1 - if (gc_was_enabled) - PyGC_Enable(); - #else - if (gc_was_enabled) { - PyObject *tp, *v, *tb; - PyErr_Fetch(&tp, &v, &tb); - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); - if (likely(ret || r == -1)) { - Py_XDECREF(ret); - PyErr_Restore(tp, v, tb); - } else { - Py_XDECREF(tp); - Py_XDECREF(v); - Py_XDECREF(tb); - r = -1; - } - } - Py_DECREF(gc); - #endif - } -#endif - return r; -#endif -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* SetVTable */ -static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { - PyObject *ob = PyCapsule_New(vtable, 0, 0); - if (unlikely(!ob)) - goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_n_s_pyx_vtable, ob) < 0)) -#else - if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_n_s_pyx_vtable, ob) < 0)) -#endif - goto bad; - Py_DECREF(ob); - return 0; -bad: - Py_XDECREF(ob); - return -1; -} - -/* GetVTable */ -static void* __Pyx_GetVtable(PyTypeObject *type) { - void* ptr; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_n_s_pyx_vtable); -#else - PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_n_s_pyx_vtable); -#endif - if (!ob) - goto bad; - ptr = PyCapsule_GetPointer(ob, 0); - if (!ptr && !PyErr_Occurred()) - PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); - Py_DECREF(ob); - return ptr; -bad: - Py_XDECREF(ob); - return NULL; -} - -/* MergeVTables */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_MergeVtables(PyTypeObject *type) { - int i; - void** base_vtables; - __Pyx_TypeName tp_base_name; - __Pyx_TypeName base_name; - void* unknown = (void*)-1; - PyObject* bases = type->tp_bases; - int base_depth = 0; - { - PyTypeObject* base = type->tp_base; - while (base) { - base_depth += 1; - base = base->tp_base; - } - } - base_vtables = (void**) malloc(sizeof(void*) * (size_t)(base_depth + 1)); - base_vtables[0] = unknown; - for (i = 1; i < PyTuple_GET_SIZE(bases); i++) { - void* base_vtable = __Pyx_GetVtable(((PyTypeObject*)PyTuple_GET_ITEM(bases, i))); - if (base_vtable != NULL) { - int j; - PyTypeObject* base = type->tp_base; - for (j = 0; j < base_depth; j++) { - if (base_vtables[j] == unknown) { - base_vtables[j] = __Pyx_GetVtable(base); - base_vtables[j + 1] = unknown; - } - if (base_vtables[j] == base_vtable) { - break; - } else if (base_vtables[j] == NULL) { - goto bad; - } - base = base->tp_base; - } - } - } - PyErr_Clear(); - free(base_vtables); - return 0; -bad: - tp_base_name = __Pyx_PyType_GetName(type->tp_base); - base_name = __Pyx_PyType_GetName((PyTypeObject*)PyTuple_GET_ITEM(bases, i)); - PyErr_Format(PyExc_TypeError, - "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); - __Pyx_DECREF_TypeName(tp_base_name); - __Pyx_DECREF_TypeName(base_name); - free(base_vtables); - return -1; -} -#endif - -/* SetupReduce */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* FetchSharedCythonModule */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); - if (unlikely(!cached_type)) goto bad; - if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL -static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - PyObject *res = NULL; - PyObject *kwnames; - PyObject **newargs; - PyObject **kwvalues; - Py_ssize_t i, pos; - size_t j; - PyObject *key, *value; - unsigned long keys_are_strings; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); - if (unlikely(newargs == NULL)) { - PyErr_NoMemory(); - return NULL; - } - for (j = 0; j < nargs; j++) newargs[j] = args[j]; - kwnames = PyTuple_New(nkw); - if (unlikely(kwnames == NULL)) { - PyMem_Free(newargs); - return NULL; - } - kwvalues = newargs + nargs; - pos = i = 0; - keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; - while (PyDict_Next(kw, &pos, &key, &value)) { - keys_are_strings &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - kwvalues[i] = value; - i++; - } - if (unlikely(!keys_are_strings)) { - PyErr_SetString(PyExc_TypeError, "keywords must be strings"); - goto cleanup; - } - res = vc(func, newargs, nargs, kwnames); -cleanup: - Py_DECREF(kwnames); - for (i = 0; i < nkw; i++) - Py_DECREF(kwvalues[i]); - PyMem_Free(newargs); - return res; -} -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - if (__Pyx_CyFunction_Check(func)) { - return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; - } else if (PyCFunction_Check(func)) { - return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; - } - return 0; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -} -#endif -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - __Pyx_Py_XDECREF_SET( - __Pyx_CyFunction_GetClassObj(f), - ((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#else - __Pyx_Py_XDECREF_SET( - ((PyCMethodObject *) (f))->mm_class, - (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#endif -} -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - if (unlikely(op->func_doc == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); - if (unlikely(!op->func_doc)) return NULL; -#else - if (((PyCFunctionObject*)op)->m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - if (unlikely(op->func_doc == NULL)) - return NULL; - } else { - Py_INCREF(Py_None); - return Py_None; - } -#endif - } - Py_INCREF(op->func_doc); - return op->func_doc; -} -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (value == NULL) { - value = Py_None; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#endif - if (unlikely(op->func_name == NULL)) - return NULL; - } - Py_INCREF(op->func_name); - return op->func_name; -} -static int -__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_dict == NULL)) { - op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; - } - Py_INCREF(op->func_dict); - return op->func_dict; -} -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; - } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_dict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_globals); - return op->func_globals; -} -static PyObject * -__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(op); - CYTHON_UNUSED_VAR(context); - Py_INCREF(Py_None); - return Py_None; -} -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; - CYTHON_UNUSED_VAR(context); - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { - int result = 0; - PyObject *res = op->defaults_getter((PyObject *) op); - if (unlikely(!res)) - return -1; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - op->defaults_tuple = PyTuple_GET_ITEM(res, 0); - Py_INCREF(op->defaults_tuple); - op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); - Py_INCREF(op->defaults_kwdict); - #else - op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; - else { - op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); - if (unlikely(!op->defaults_kwdict)) result = -1; - } - #endif - Py_DECREF(res); - return result; -} -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_tuple; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_kwdict; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value || value == Py_None) { - value = NULL; - } else if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); - return -1; - } - Py_XINCREF(value); - __Pyx_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - result = PyDict_New(); - if (unlikely(!result)) return NULL; - op->func_annotations = result; - } - Py_INCREF(result); - return result; -} -static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; - fromlist = PyList_New(1); - if (unlikely(!fromlist)) return NULL; - Py_INCREF(marker); -#if CYTHON_ASSUME_SAFE_MACROS - PyList_SET_ITEM(fromlist, 0, marker); -#else - if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { - Py_DECREF(marker); - Py_DECREF(fromlist); - return NULL; - } -#endif - module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject * -__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_GetAttrString(op->func, "__module__"); -} -static int -__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_SetAttrString(op->func, "__module__", value); -} -#endif -static PyGetSetDef __pyx_CyFunction_getsets[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, -#if CYTHON_COMPILING_IN_LIMITED_API - {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, -#endif - {0, 0, 0, 0, 0} -}; -static PyMemberDef __pyx_CyFunction_members[] = { -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, -#endif -#endif - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) -#else -#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) -#endif -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { -#if !CYTHON_COMPILING_IN_LIMITED_API - PyCFunctionObject *cf = (PyCFunctionObject*) op; -#endif - if (unlikely(op == NULL)) - return NULL; -#if CYTHON_COMPILING_IN_LIMITED_API - op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); - if (unlikely(!op->func)) return NULL; -#endif - op->flags = flags; - __Pyx_CyFunction_weakreflist(op) = NULL; -#if !CYTHON_COMPILING_IN_LIMITED_API - cf->m_ml = ml; - cf->m_self = (PyObject *) op; -#endif - Py_XINCREF(closure); - op->func_closure = closure; -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_XINCREF(module); - cf->m_module = module; -#endif - op->func_dict = NULL; - op->func_name = NULL; - Py_INCREF(qualname); - op->func_qualname = qualname; - op->func_doc = NULL; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - op->func_classobj = NULL; -#else - ((PyCMethodObject*)op)->mm_class = NULL; -#endif - op->func_globals = globals; - Py_INCREF(op->func_globals); - Py_XINCREF(code); - op->func_code = code; - op->defaults_pyobjects = 0; - op->defaults_size = 0; - op->defaults = NULL; - op->defaults_tuple = NULL; - op->defaults_kwdict = NULL; - op->defaults_getter = NULL; - op->func_annotations = NULL; - op->func_is_coroutine = NULL; -#if CYTHON_METH_FASTCALL - switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { - case METH_NOARGS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; - break; - case METH_O: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; - break; - case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; - break; - case METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; - break; - case METH_VARARGS | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = NULL; - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - Py_DECREF(op); - return NULL; - } -#endif - return (PyObject *) op; -} -static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) -{ - Py_CLEAR(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_CLEAR(m->func); -#else - Py_CLEAR(((PyCFunctionObject*)m)->m_module); -#endif - Py_CLEAR(m->func_dict); - Py_CLEAR(m->func_name); - Py_CLEAR(m->func_qualname); - Py_CLEAR(m->func_doc); - Py_CLEAR(m->func_globals); - Py_CLEAR(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API -#if PY_VERSION_HEX < 0x030900B1 - Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); -#else - { - PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; - ((PyCMethodObject *) (m))->mm_class = NULL; - Py_XDECREF(cls); - } -#endif -#endif - Py_CLEAR(m->defaults_tuple); - Py_CLEAR(m->defaults_kwdict); - Py_CLEAR(m->func_annotations); - Py_CLEAR(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; - } - return 0; -} -static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - if (__Pyx_CyFunction_weakreflist(m) != NULL) - PyObject_ClearWeakRefs((PyObject *) m); - __Pyx_CyFunction_clear(m); - __Pyx_PyHeapTypeObject_GC_Del(m); -} -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - PyObject_GC_UnTrack(m); - __Pyx__CyFunction_dealloc(m); -} -static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) -{ - Py_VISIT(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(m->func); -#else - Py_VISIT(((PyCFunctionObject*)m)->m_module); -#endif - Py_VISIT(m->func_dict); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); - Py_VISIT(m->func_doc); - Py_VISIT(m->func_globals); - Py_VISIT(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); -#endif - Py_VISIT(m->defaults_tuple); - Py_VISIT(m->defaults_kwdict); - Py_VISIT(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *f = ((__pyx_CyFunctionObject*)func)->func; - PyObject *py_name = NULL; - PyCFunction meth; - int flags; - meth = PyCFunction_GetFunction(f); - if (unlikely(!meth)) return NULL; - flags = PyCFunction_GetFlags(f); - if (unlikely(flags < 0)) return NULL; -#else - PyCFunctionObject* f = (PyCFunctionObject*)func; - PyCFunction meth = f->m_ml->ml_meth; - int flags = f->m_ml->ml_flags; -#endif - Py_ssize_t size; - switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { - case METH_VARARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) - return (*meth)(self, arg); - break; - case METH_VARARGS | METH_KEYWORDS: - return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); - case METH_NOARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 0)) - return (*meth)(self, NULL); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; - #endif - result = (*meth)(self, arg0); - #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(arg0); - #endif - return result; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - return NULL; -} -static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *self, *result; -#if CYTHON_COMPILING_IN_LIMITED_API - self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); - if (unlikely(!self) && PyErr_Occurred()) return NULL; -#else - self = ((PyCFunctionObject*)func)->m_self; -#endif - result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); - return result; -} -static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { - PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; -#if CYTHON_METH_FASTCALL - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); -#else - (void) &__Pyx_PyVectorcall_FastCallDict; - return PyVectorcall_Call(func, args, kw); -#endif - } -#endif - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - Py_ssize_t argc; - PyObject *new_args; - PyObject *self; -#if CYTHON_ASSUME_SAFE_MACROS - argc = PyTuple_GET_SIZE(args); -#else - argc = PyTuple_Size(args); - if (unlikely(!argc) < 0) return NULL; -#endif - new_args = PyTuple_GetSlice(args, 1, argc); - if (unlikely(!new_args)) - return NULL; - self = PyTuple_GetItem(args, 0); - if (unlikely(!self)) { - Py_DECREF(new_args); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - return NULL; - } - result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); - Py_DECREF(new_args); - } else { - result = __Pyx_CyFunction_Call(func, args, kw); - } - return result; -} -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) -{ - int ret = 0; - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - return ret; -} -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, NULL); -} -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, args[0]); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_CyFunctionType_slots[] = { - {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, - {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, - {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, - {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, - {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, - {Py_tp_methods, (void *)__pyx_CyFunction_methods}, - {Py_tp_members, (void *)__pyx_CyFunction_members}, - {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, - {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, - {0, 0}, -}; -static PyType_Spec __pyx_CyFunctionType_spec = { - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_PyMethod_New, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - if (unlikely(__pyx_CyFunctionType == NULL)) { - return -1; - } - return 0; -} -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - m->defaults_size = size; - return m->defaults; -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_tuple = tuple; - Py_INCREF(tuple); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_kwdict = dict; - Py_INCREF(dict); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->func_annotations = dict; - Py_INCREF(dict); -} - -/* CythonFunction */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - PyObject *op = __Pyx_CyFunction_Init( - PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); - if (likely(op)) { - PyObject_GC_Track(op); - } - return op; -} - -/* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { - PyObject *use_cline; - PyObject *ptype, *pvalue, *ptraceback; -#if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict; -#endif - CYTHON_MAYBE_UNUSED_VAR(tstate); - if (unlikely(!__pyx_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { - c_line = 0; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; -} -#endif - -/* CodeObjectCache */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { - int start = 0, mid = 0, end = count - 1; - if (end >= 0 && code_line > entries[end].code_line) { - return count; - } - while (start < end) { - mid = start + (end - start) / 2; - if (code_line < entries[mid].code_line) { - end = mid; - } else if (code_line > entries[mid].code_line) { - start = mid + 1; - } else { - return mid; - } - } - if (code_line <= entries[mid].code_line) { - return mid; - } else { - return mid + 1; - } -} -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; - } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; -} -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; - } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_code_cache.count = 1; - entries[0].code_line = code_line; - entries[0].code_object = code_object; - Py_INCREF(code_object); - } - return; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; - } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; - } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} -#endif - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, - PyObject *firstlineno, PyObject *name) { - PyObject *replace = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; - replace = PyObject_GetAttrString(code, "replace"); - if (likely(replace)) { - PyObject *result; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; - PyObject *replace = NULL, *getframe = NULL, *frame = NULL; - PyObject *exc_type, *exc_value, *exc_traceback; - int success = 0; - if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); - } - PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); - code_object = Py_CompileString("_getframe()", filename, Py_eval_input); - if (unlikely(!code_object)) goto bad; - py_py_line = PyLong_FromLong(py_line); - if (unlikely(!py_py_line)) goto bad; - py_funcname = PyUnicode_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - dict = PyDict_New(); - if (unlikely(!dict)) goto bad; - { - PyObject *old_code_object = code_object; - code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); - Py_DECREF(old_code_object); - } - if (unlikely(!code_object)) goto bad; - getframe = PySys_GetObject("_getframe"); - if (unlikely(!getframe)) goto bad; - if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; - frame = PyEval_EvalCode(code_object, dict, dict); - if (unlikely(!frame) || frame == Py_None) goto bad; - success = 1; - bad: - PyErr_Restore(exc_type, exc_value, exc_traceback); - Py_XDECREF(code_object); - Py_XDECREF(py_py_line); - Py_XDECREF(py_funcname); - Py_XDECREF(dict); - Py_XDECREF(replace); - if (success) { - PyTraceBack_Here( - (struct _frame*)frame); - } - Py_XDECREF(frame); -} -#else -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = NULL; - PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - funcname = PyUnicode_AsUTF8(py_funcname); - if (!funcname) goto bad; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - return NULL; -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyFrameObject *py_frame = 0; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject *ptype, *pvalue, *ptraceback; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); - } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) { - /* If the code object creation fails, then we should clear the - fetched exception references and propagate the new exception */ - Py_XDECREF(ptype); - Py_XDECREF(pvalue); - Py_XDECREF(ptraceback); - goto bad; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); - } - py_frame = PyFrame_New( - tstate, /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ - ); - if (!py_frame) goto bad; - __Pyx_PyFrame_SetLineNumber(py_frame, py_line); - PyTraceBack_Here(py_frame); -bad: - Py_XDECREF(py_code); - Py_XDECREF(py_frame); -} -#endif - -/* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* CIntFromPy */ -static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(size_t) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (size_t) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) { - return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) { - return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) { - return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (size_t) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(size_t) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { - return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(size_t) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - size_t val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (size_t) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (size_t) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (size_t) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (size_t) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (size_t) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((size_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((size_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (size_t) -1; - } - } else { - size_t val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (size_t) -1; - val = __Pyx_PyInt_As_size_t(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to size_t"); - return (size_t) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to size_t"); - return (size_t) -1; -} - -/* CIntFromPy */ -static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(uint32_t) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (uint32_t) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT)) { - return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT)) { - return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT)) { - return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (uint32_t) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(uint32_t) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { - return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(uint32_t) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(uint32_t) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - uint32_t val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (uint32_t) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (uint32_t) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (uint32_t) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (uint32_t) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (uint32_t) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(uint32_t) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((uint32_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(uint32_t) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((uint32_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((uint32_t) 1) << (sizeof(uint32_t) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (uint32_t) -1; - } - } else { - uint32_t val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (uint32_t) -1; - val = __Pyx_PyInt_As_uint32_t(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to uint32_t"); - return (uint32_t) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to uint32_t"); - return (uint32_t) -1; -} - -/* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(int) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(int) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(int) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(int) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(int) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(int), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* FormatTypeName */ -#if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__7); - } - return name; -} -#endif - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(long) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(long) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - long val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(a, b); -} -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (cls == a || cls == b) return 1; - mro = cls->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - PyObject *base = PyTuple_GET_ITEM(mro, i); - if (base == (PyObject *)a || base == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - if (exc_type1) { - return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); - } else { - return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } -} -#endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - const char* rt_version = Py_GetVersion(); - unsigned long version = 0; - unsigned long factor = 0x01000000UL; - unsigned int digit = 0; - int i = 0; - while (factor) { - while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); - ++i; - } - version += factor * digit; - if (rt_version[i] != '.') - break; - digit = 0; - factor >>= 8; - ++i; - } - return version; -#endif -} -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { - const unsigned long MAJOR_MINOR = 0xFFFF0000UL; - if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) - return 0; - if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) - return 1; - { - char message[200]; - PyOS_snprintf(message, sizeof(message), - "compile time Python version %d.%d " - "of module '%.100s' " - "%s " - "runtime version %d.%d", - (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), - __Pyx_MODULE_NAME, - (allow_newer) ? "was newer than" : "does not match", - (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) - ); - return PyErr_WarnEx(NULL, message, 1); - } -} - -/* InitStrings */ -#if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); - } else { - *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); - } - } else { - *str = PyBytes_FromStringAndSize(t.s, t.n - 1); - } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - return 0; -} - -#include -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { - size_t len = strlen(s); - if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { - PyErr_SetString(PyExc_OverflowError, "byte string is too long"); - return -1; - } - return (Py_ssize_t) len; -} -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return __Pyx_PyUnicode_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return PyByteArray_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { - Py_ssize_t ignore; - return __Pyx_PyObject_AsStringAndSize(o, &ignore); -} -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (likely(PyUnicode_IS_ASCII(o))) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } -#else - return PyUnicode_AsUTF8AndSize(o, length); -#endif -} -#endif -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - char* result; - int r = PyBytes_AsStringAndSize(o, &result, length); - if (unlikely(r < 0)) { - return NULL; - } else { - return result; - } - } -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { - int is_true = x == Py_True; - if (is_true | (x == Py_False) | (x == Py_None)) return is_true; - else return PyObject_IsTrue(x); -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { - int retval; - if (unlikely(!x)) return -1; - retval = __Pyx_PyObject_IsTrue(x); - Py_DECREF(x); - return retval; -} -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - if (PyLong_Check(result)) { - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " - "The ability to return an instance of a strict subclass of int is deprecated, " - "and may be removed in a future version of Python.", - result_type_name)) { - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; - } - __Pyx_DECREF_TypeName(result_type_name); - return result; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); - } - return res; -} -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { - Py_ssize_t ival; - PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - if (likely(PyLong_CheckExact(b))) { - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(__Pyx_PyLong_IsCompact(b))) { - return __Pyx_PyLong_CompactValue(b); - } else { - const digit* digits = __Pyx_PyLong_Digits(b); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { - if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { - return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/opendbc/can/packer_pyx.so b/opendbc/can/packer_pyx.so deleted file mode 100755 index e791807fcac23bc90c458178d98cef2dd5a66342..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 709720 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

  • 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 DSJJi7 diff --git a/opendbc/can/parser_pyx.cpp b/opendbc/can/parser_pyx.cpp deleted file mode 100644 index c29ee7f..0000000 --- a/opendbc/can/parser_pyx.cpp +++ /dev/null @@ -1,13645 +0,0 @@ -/* Generated by Cython 3.0.8 */ - -/* BEGIN: Cython Metadata -{ - "distutils": { - "depends": [ - "opendbc/can/common.h", - "opendbc/can/common_dbc.h" - ], - "include_dirs": [ - "opendbc/can" - ], - "language": "c++", - "name": "opendbc.can.parser_pyx", - "sources": [ - "/data/openpilot/opendbc/can/parser_pyx.pyx" - ] - }, - "module_name": "opendbc.can.parser_pyx" -} -END: Cython Metadata */ - -#ifndef PY_SSIZE_T_CLEAN -#define PY_SSIZE_T_CLEAN -#endif /* PY_SSIZE_T_CLEAN */ -#if defined(CYTHON_LIMITED_API) && 0 - #ifndef Py_LIMITED_API - #if CYTHON_LIMITED_API+0 > 0x03030000 - #define Py_LIMITED_API CYTHON_LIMITED_API - #else - #define Py_LIMITED_API 0x03030000 - #endif - #endif -#endif - -#include "Python.h" -#ifndef Py_PYTHON_H - #error Python headers needed to compile C extensions, please install development version of Python. -#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) - #error Cython requires Python 2.7+ or Python 3.3+. -#else -#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API -#define __PYX_EXTRA_ABI_MODULE_NAME "limited" -#else -#define __PYX_EXTRA_ABI_MODULE_NAME "" -#endif -#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME -#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI -#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." -#define CYTHON_HEX_VERSION 0x030008F0 -#define CYTHON_FUTURE_DIVISION 1 -#include -#ifndef offsetof - #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) -#endif -#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) - #ifndef __stdcall - #define __stdcall - #endif - #ifndef __cdecl - #define __cdecl - #endif - #ifndef __fastcall - #define __fastcall - #endif -#endif -#ifndef DL_IMPORT - #define DL_IMPORT(t) t -#endif -#ifndef DL_EXPORT - #define DL_EXPORT(t) t -#endif -#define __PYX_COMMA , -#ifndef HAVE_LONG_LONG - #define HAVE_LONG_LONG -#endif -#ifndef PY_LONG_LONG - #define PY_LONG_LONG LONG_LONG -#endif -#ifndef Py_HUGE_VAL - #define Py_HUGE_VAL HUGE_VAL -#endif -#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX -#if defined(GRAALVM_PYTHON) - /* For very preliminary testing purposes. Most variables are set the same as PyPy. - The existence of this section does not imply that anything works or is even tested */ - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 1 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(PYPY_VERSION) - #define CYTHON_COMPILING_IN_PYPY 1 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #undef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 1 - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) - #endif - #if PY_VERSION_HEX < 0x03090000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(CYTHON_LIMITED_API) - #ifdef Py_LIMITED_API - #undef __PYX_LIMITED_VERSION_HEX - #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API - #endif - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 1 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #undef CYTHON_CLINE_IN_TRACEBACK - #define CYTHON_CLINE_IN_TRACEBACK 0 - #undef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 0 - #undef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 1 - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #undef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #endif - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #undef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 0 - #undef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 0 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL 0 - #undef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #undef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 1 - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 - #endif -#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 0 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 1 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #undef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 0 - #ifndef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #undef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 0 - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #undef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 0 - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #undef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 0 - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 -#else - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_CPYTHON 1 - #define CYTHON_COMPILING_IN_LIMITED_API 0 - #define CYTHON_COMPILING_IN_GRAAL 0 - #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 - #endif - #ifndef CYTHON_USE_TYPE_SPECS - #define CYTHON_USE_TYPE_SPECS 0 - #endif - #ifndef CYTHON_USE_PYTYPE_LOOKUP - #define CYTHON_USE_PYTYPE_LOOKUP 1 - #endif - #if PY_MAJOR_VERSION < 3 - #undef CYTHON_USE_ASYNC_SLOTS - #define CYTHON_USE_ASYNC_SLOTS 0 - #elif !defined(CYTHON_USE_ASYNC_SLOTS) - #define CYTHON_USE_ASYNC_SLOTS 1 - #endif - #ifndef CYTHON_USE_PYLONG_INTERNALS - #define CYTHON_USE_PYLONG_INTERNALS 1 - #endif - #ifndef CYTHON_USE_PYLIST_INTERNALS - #define CYTHON_USE_PYLIST_INTERNALS 1 - #endif - #ifndef CYTHON_USE_UNICODE_INTERNALS - #define CYTHON_USE_UNICODE_INTERNALS 1 - #endif - #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 - #undef CYTHON_USE_UNICODE_WRITER - #define CYTHON_USE_UNICODE_WRITER 0 - #elif !defined(CYTHON_USE_UNICODE_WRITER) - #define CYTHON_USE_UNICODE_WRITER 1 - #endif - #ifndef CYTHON_AVOID_BORROWED_REFS - #define CYTHON_AVOID_BORROWED_REFS 0 - #endif - #ifndef CYTHON_ASSUME_SAFE_MACROS - #define CYTHON_ASSUME_SAFE_MACROS 1 - #endif - #ifndef CYTHON_UNPACK_METHODS - #define CYTHON_UNPACK_METHODS 1 - #endif - #ifndef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 1 - #endif - #ifndef CYTHON_FAST_GIL - #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) - #endif - #ifndef CYTHON_METH_FASTCALL - #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) - #endif - #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL 1 - #endif - #ifndef CYTHON_PEP487_INIT_SUBCLASS - #define CYTHON_PEP487_INIT_SUBCLASS 1 - #endif - #if PY_VERSION_HEX < 0x03050000 - #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 - #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) - #define CYTHON_PEP489_MULTI_PHASE_INIT 1 - #endif - #ifndef CYTHON_USE_MODULE_STATE - #define CYTHON_USE_MODULE_STATE 0 - #endif - #if PY_VERSION_HEX < 0x030400a1 - #undef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE 0 - #elif !defined(CYTHON_USE_TP_FINALIZE) - #define CYTHON_USE_TP_FINALIZE 1 - #endif - #if PY_VERSION_HEX < 0x030600B1 - #undef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS 0 - #elif !defined(CYTHON_USE_DICT_VERSIONS) - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) - #endif - #if PY_VERSION_HEX < 0x030700A3 - #undef CYTHON_USE_EXC_INFO_STACK - #define CYTHON_USE_EXC_INFO_STACK 0 - #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK 1 - #endif - #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 - #endif -#endif -#if !defined(CYTHON_FAST_PYCCALL) -#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) -#endif -#if !defined(CYTHON_VECTORCALL) -#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) -#endif -#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_MAJOR_VERSION < 3 - #include "longintrepr.h" - #endif - #undef SHIFT - #undef BASE - #undef MASK - #ifdef SIZEOF_VOID_P - enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; - #endif -#endif -#ifndef __has_attribute - #define __has_attribute(x) 0 -#endif -#ifndef __has_cpp_attribute - #define __has_cpp_attribute(x) 0 -#endif -#ifndef CYTHON_RESTRICT - #if defined(__GNUC__) - #define CYTHON_RESTRICT __restrict__ - #elif defined(_MSC_VER) && _MSC_VER >= 1400 - #define CYTHON_RESTRICT __restrict - #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define CYTHON_RESTRICT restrict - #else - #define CYTHON_RESTRICT - #endif -#endif -#ifndef CYTHON_UNUSED - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(maybe_unused) - #define CYTHON_UNUSED [[maybe_unused]] - #endif - #endif - #endif -#endif -#ifndef CYTHON_UNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) -# define CYTHON_UNUSED __attribute__ ((__unused__)) -# else -# define CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_UNUSED_VAR -# if defined(__cplusplus) - template void CYTHON_UNUSED_VAR( const T& ) { } -# else -# define CYTHON_UNUSED_VAR(x) (void)(x) -# endif -#endif -#ifndef CYTHON_MAYBE_UNUSED_VAR - #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) -#endif -#ifndef CYTHON_NCP_UNUSED -# if CYTHON_COMPILING_IN_CPYTHON -# define CYTHON_NCP_UNUSED -# else -# define CYTHON_NCP_UNUSED CYTHON_UNUSED -# endif -#endif -#ifndef CYTHON_USE_CPP_STD_MOVE - #if defined(__cplusplus) && (\ - __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) - #define CYTHON_USE_CPP_STD_MOVE 1 - #else - #define CYTHON_USE_CPP_STD_MOVE 0 - #endif -#endif -#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) -#ifdef _MSC_VER - #ifndef _MSC_STDINT_H_ - #if _MSC_VER < 1300 - typedef unsigned char uint8_t; - typedef unsigned short uint16_t; - typedef unsigned int uint32_t; - #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int16 uint16_t; - typedef unsigned __int32 uint32_t; - #endif - #endif - #if _MSC_VER < 1300 - #ifdef _WIN64 - typedef unsigned long long __pyx_uintptr_t; - #else - typedef unsigned int __pyx_uintptr_t; - #endif - #else - #ifdef _WIN64 - typedef unsigned __int64 __pyx_uintptr_t; - #else - typedef unsigned __int32 __pyx_uintptr_t; - #endif - #endif -#else - #include - typedef uintptr_t __pyx_uintptr_t; -#endif -#ifndef CYTHON_FALLTHROUGH - #if defined(__cplusplus) - /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 - * but leads to warnings with -pedantic, since it is a C++17 feature */ - #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) - #if __has_cpp_attribute(fallthrough) - #define CYTHON_FALLTHROUGH [[fallthrough]] - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_cpp_attribute(clang::fallthrough) - #define CYTHON_FALLTHROUGH [[clang::fallthrough]] - #elif __has_cpp_attribute(gnu::fallthrough) - #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] - #endif - #endif - #endif - #ifndef CYTHON_FALLTHROUGH - #if __has_attribute(fallthrough) - #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) - #else - #define CYTHON_FALLTHROUGH - #endif - #endif - #if defined(__clang__) && defined(__apple_build_version__) - #if __apple_build_version__ < 7000000 - #undef CYTHON_FALLTHROUGH - #define CYTHON_FALLTHROUGH - #endif - #endif -#endif -#ifdef __cplusplus - template - struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; - #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) -#else - #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) -#endif -#if CYTHON_COMPILING_IN_PYPY == 1 - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) -#else - #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) -#endif -#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) - -#ifndef __cplusplus - #error "Cython files generated with the C++ option must be compiled with a C++ compiler." -#endif -#ifndef CYTHON_INLINE - #if defined(__clang__) - #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) - #else - #define CYTHON_INLINE inline - #endif -#endif -template -void __Pyx_call_destructor(T& x) { - x.~T(); -} -template -class __Pyx_FakeReference { - public: - __Pyx_FakeReference() : ptr(NULL) { } - __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } - T *operator->() { return ptr; } - T *operator&() { return ptr; } - operator T&() { return *ptr; } - template bool operator ==(const U& other) const { return *ptr == other; } - template bool operator !=(const U& other) const { return *ptr != other; } - template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } - template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } - private: - T *ptr; -}; - -#define __PYX_BUILD_PY_SSIZE_T "n" -#define CYTHON_FORMAT_SSIZE_T "z" -#if PY_MAJOR_VERSION < 3 - #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" - #define __Pyx_DefaultClassType PyClass_Type - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_BUILTIN_MODULE_NAME "builtins" - #define __Pyx_DefaultClassType PyType_Type -#if CYTHON_COMPILING_IN_LIMITED_API - static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyObject *exception_table = NULL; - PyObject *types_module=NULL, *code_type=NULL, *result=NULL; - #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 - PyObject *version_info; - PyObject *py_minor_version = NULL; - #endif - long minor_version = 0; - PyObject *type, *value, *traceback; - PyErr_Fetch(&type, &value, &traceback); - #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 - minor_version = 11; - #else - if (!(version_info = PySys_GetObject("version_info"))) goto end; - if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; - minor_version = PyLong_AsLong(py_minor_version); - Py_DECREF(py_minor_version); - if (minor_version == -1 && PyErr_Occurred()) goto end; - #endif - if (!(types_module = PyImport_ImportModule("types"))) goto end; - if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; - if (minor_version <= 7) { - (void)p; - result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else if (minor_version <= 10) { - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, fline, lnos, fv, cell); - } else { - if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; - result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, - c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); - } - end: - Py_XDECREF(code_type); - Py_XDECREF(exception_table); - Py_XDECREF(types_module); - if (type) { - PyErr_Restore(type, value, traceback); - } - return result; - } - #ifndef CO_OPTIMIZED - #define CO_OPTIMIZED 0x0001 - #endif - #ifndef CO_NEWLOCALS - #define CO_NEWLOCALS 0x0002 - #endif - #ifndef CO_VARARGS - #define CO_VARARGS 0x0004 - #endif - #ifndef CO_VARKEYWORDS - #define CO_VARKEYWORDS 0x0008 - #endif - #ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x0200 - #endif - #ifndef CO_GENERATOR - #define CO_GENERATOR 0x0020 - #endif - #ifndef CO_COROUTINE - #define CO_COROUTINE 0x0080 - #endif -#elif PY_VERSION_HEX >= 0x030B0000 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, - PyObject *code, PyObject *c, PyObject* n, PyObject *v, - PyObject *fv, PyObject *cell, PyObject* fn, - PyObject *name, int fline, PyObject *lnos) { - PyCodeObject *result; - PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); - if (!empty_bytes) return NULL; - result = - #if PY_VERSION_HEX >= 0x030C0000 - PyUnstable_Code_NewWithPosOnlyArgs - #else - PyCode_NewWithPosOnlyArgs - #endif - (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); - Py_DECREF(empty_bytes); - return result; - } -#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#else - #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ - PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) -#endif -#endif -#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) - #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) -#else - #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) - #define __Pyx_Py_Is(x, y) Py_Is(x, y) -#else - #define __Pyx_Py_Is(x, y) ((x) == (y)) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) - #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) -#else - #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) - #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) -#else - #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) -#endif -#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) - #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) -#else - #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) -#endif -#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) -#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) -#else - #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) -#endif -#ifndef CO_COROUTINE - #define CO_COROUTINE 0x80 -#endif -#ifndef CO_ASYNC_GENERATOR - #define CO_ASYNC_GENERATOR 0x200 -#endif -#ifndef Py_TPFLAGS_CHECKTYPES - #define Py_TPFLAGS_CHECKTYPES 0 -#endif -#ifndef Py_TPFLAGS_HAVE_INDEX - #define Py_TPFLAGS_HAVE_INDEX 0 -#endif -#ifndef Py_TPFLAGS_HAVE_NEWBUFFER - #define Py_TPFLAGS_HAVE_NEWBUFFER 0 -#endif -#ifndef Py_TPFLAGS_HAVE_FINALIZE - #define Py_TPFLAGS_HAVE_FINALIZE 0 -#endif -#ifndef Py_TPFLAGS_SEQUENCE - #define Py_TPFLAGS_SEQUENCE 0 -#endif -#ifndef Py_TPFLAGS_MAPPING - #define Py_TPFLAGS_MAPPING 0 -#endif -#ifndef METH_STACKLESS - #define METH_STACKLESS 0 -#endif -#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) - #ifndef METH_FASTCALL - #define METH_FASTCALL 0x80 - #endif - typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); - typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, - Py_ssize_t nargs, PyObject *kwnames); -#else - #define __Pyx_PyCFunctionFast _PyCFunctionFast - #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords -#endif -#if CYTHON_METH_FASTCALL - #define __Pyx_METH_FASTCALL METH_FASTCALL - #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast - #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords -#else - #define __Pyx_METH_FASTCALL METH_VARARGS - #define __Pyx_PyCFunction_FastCall PyCFunction - #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords -#endif -#if CYTHON_VECTORCALL - #define __pyx_vectorcallfunc vectorcallfunc - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET - #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) -#elif CYTHON_BACKPORT_VECTORCALL - typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, - size_t nargsf, PyObject *kwnames); - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) -#else - #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 - #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) -#endif -#if PY_MAJOR_VERSION >= 0x030900B1 -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) -#else -#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) -#endif -#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) -#elif !CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) -#endif -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) -static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { - return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; -} -#endif -static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { -#if CYTHON_COMPILING_IN_LIMITED_API - return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; -#else - return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -#endif -} -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) -#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) - typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); -#else - #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) - #define __Pyx_PyCMethod PyCMethod -#endif -#ifndef METH_METHOD - #define METH_METHOD 0x200 -#endif -#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) - #define PyObject_Malloc(s) PyMem_Malloc(s) - #define PyObject_Free(p) PyMem_Free(p) - #define PyObject_Realloc(p) PyMem_Realloc(p) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) -#else - #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) - #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyThreadState_Current PyThreadState_Get() -#elif !CYTHON_FAST_THREAD_STATE - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#elif PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() -#elif PY_VERSION_HEX >= 0x03060000 - #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() -#elif PY_VERSION_HEX >= 0x03000000 - #define __Pyx_PyThreadState_Current PyThreadState_GET() -#else - #define __Pyx_PyThreadState_Current _PyThreadState_Current -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) -{ - void *result; - result = PyModule_GetState(op); - if (!result) - Py_FatalError("Couldn't find the module state"); - return result; -} -#endif -#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) -#else - #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) -#endif -#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) -#include "pythread.h" -#define Py_tss_NEEDS_INIT 0 -typedef int Py_tss_t; -static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { - *key = PyThread_create_key(); - return 0; -} -static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { - Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); - *key = Py_tss_NEEDS_INIT; - return key; -} -static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { - PyObject_Free(key); -} -static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { - return *key != Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { - PyThread_delete_key(*key); - *key = Py_tss_NEEDS_INIT; -} -static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { - return PyThread_set_key_value(*key, value); -} -static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { - return PyThread_get_key_value(*key); -} -#endif -#if PY_MAJOR_VERSION < 3 - #if CYTHON_COMPILING_IN_PYPY - #if PYPY_VERSION_NUM < 0x07030600 - #if defined(__cplusplus) && __cplusplus >= 201402L - [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] - #elif defined(__GNUC__) || defined(__clang__) - __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) - #elif defined(_MSC_VER) - __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) - #endif - static CYTHON_INLINE int PyGILState_Check(void) { - return 0; - } - #else // PYPY_VERSION_NUM < 0x07030600 - #endif // PYPY_VERSION_NUM < 0x07030600 - #else - static CYTHON_INLINE int PyGILState_Check(void) { - PyThreadState * tstate = _PyThreadState_Current; - return tstate && (tstate == PyGILState_GetThisThreadState()); - } - #endif -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) -#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) -#else -#define __Pyx_PyDict_NewPresized(n) PyDict_New() -#endif -#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION - #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) -#else - #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) - #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS -#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { - PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); - if (res == NULL) PyErr_Clear(); - return res; -} -#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) -#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#else -static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { -#if CYTHON_COMPILING_IN_PYPY - return PyDict_GetItem(dict, name); -#else - PyDictEntry *ep; - PyDictObject *mp = (PyDictObject*) dict; - long hash = ((PyStringObject *) name)->ob_shash; - assert(hash != -1); - ep = (mp->ma_lookup)(mp, name, hash); - if (ep == NULL) { - return NULL; - } - return ep->me_value; -#endif -} -#define __Pyx_PyDict_GetItemStr PyDict_GetItem -#endif -#if CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) - #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) - #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) -#else - #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) - #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) - #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) -#else - #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) -#endif -#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 -#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ - PyTypeObject *type = Py_TYPE((PyObject*)obj);\ - assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ - PyObject_GC_Del(obj);\ - Py_DECREF(type);\ -} -#else -#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) -#endif -#if CYTHON_COMPILING_IN_LIMITED_API - #define CYTHON_PEP393_ENABLED 1 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) - #define __Pyx_PyUnicode_DATA(u) ((void*)u) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) -#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) - #define CYTHON_PEP393_ENABLED 1 - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_READY(op) (0) - #else - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #endif - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) - #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) - #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) - #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) - #if PY_VERSION_HEX >= 0x030C0000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) - #else - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #endif -#else - #define CYTHON_PEP393_ENABLED 0 - #define PyUnicode_1BYTE_KIND 1 - #define PyUnicode_2BYTE_KIND 2 - #define PyUnicode_4BYTE_KIND 4 - #define __Pyx_PyUnicode_READY(op) (0) - #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) - #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) - #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) - #define __Pyx_PyUnicode_KIND(u) ((int)sizeof(Py_UNICODE)) - #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) - #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) - #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) -#else - #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) - #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ - PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) -#endif -#if CYTHON_COMPILING_IN_PYPY - #if !defined(PyUnicode_DecodeUnicodeEscape) - #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) - #endif - #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) - #undef PyUnicode_Contains - #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) - #endif - #if !defined(PyByteArray_Check) - #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) - #endif - #if !defined(PyObject_Format) - #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) - #endif -#endif -#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) -#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) -#else - #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) -#endif -#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) - #define PyObject_ASCII(o) PyObject_Repr(o) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBaseString_Type PyUnicode_Type - #define PyStringObject PyUnicodeObject - #define PyString_Type PyUnicode_Type - #define PyString_Check PyUnicode_Check - #define PyString_CheckExact PyUnicode_CheckExact -#ifndef PyObject_Unicode - #define PyObject_Unicode PyObject_Str -#endif -#endif -#if PY_MAJOR_VERSION >= 3 - #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) - #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) -#else - #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) - #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) -#endif -#if CYTHON_COMPILING_IN_CPYTHON - #define __Pyx_PySequence_ListKeepNew(obj)\ - (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) -#else - #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) -#endif -#ifndef PySet_CheckExact - #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) -#endif -#if PY_VERSION_HEX >= 0x030900A4 - #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) -#else - #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) - #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) -#endif -#if CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) - #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) -#else - #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) - #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) - #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) - #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) - #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) - #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) - #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) - #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) - #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) -#endif -#if PY_VERSION_HEX >= 0x030d00A1 - #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) -#else - static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { - PyObject *module = PyImport_AddModule(name); - Py_XINCREF(module); - return module; - } -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyIntObject PyLongObject - #define PyInt_Type PyLong_Type - #define PyInt_Check(op) PyLong_Check(op) - #define PyInt_CheckExact(op) PyLong_CheckExact(op) - #define __Pyx_Py3Int_Check(op) PyLong_Check(op) - #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) - #define PyInt_FromString PyLong_FromString - #define PyInt_FromUnicode PyLong_FromUnicode - #define PyInt_FromLong PyLong_FromLong - #define PyInt_FromSize_t PyLong_FromSize_t - #define PyInt_FromSsize_t PyLong_FromSsize_t - #define PyInt_AsLong PyLong_AsLong - #define PyInt_AS_LONG PyLong_AS_LONG - #define PyInt_AsSsize_t PyLong_AsSsize_t - #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask - #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask - #define PyNumber_Int PyNumber_Long -#else - #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) - #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) -#endif -#if PY_MAJOR_VERSION >= 3 - #define PyBoolObject PyLongObject -#endif -#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY - #ifndef PyUnicode_InternFromString - #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) - #endif -#endif -#if PY_VERSION_HEX < 0x030200A4 - typedef long Py_hash_t; - #define __Pyx_PyInt_FromHash_t PyInt_FromLong - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t -#else - #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t - #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t -#endif -#if CYTHON_USE_ASYNC_SLOTS - #if PY_VERSION_HEX >= 0x030500B1 - #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods - #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) - #else - #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) - #endif -#else - #define __Pyx_PyType_AsAsync(obj) NULL -#endif -#ifndef __Pyx_PyAsyncMethodsStruct - typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; - } __Pyx_PyAsyncMethodsStruct; -#endif - -#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) - #if !defined(_USE_MATH_DEFINES) - #define _USE_MATH_DEFINES - #endif -#endif -#include -#ifdef NAN -#define __PYX_NAN() ((float) NAN) -#else -static CYTHON_INLINE float __PYX_NAN() { - float value; - memset(&value, 0xFF, sizeof(value)); - return value; -} -#endif -#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) -#define __Pyx_truncl trunc -#else -#define __Pyx_truncl truncl -#endif - -#define __PYX_MARK_ERR_POS(f_index, lineno) \ - { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } -#define __PYX_ERR(f_index, lineno, Ln_error) \ - { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } - -#ifdef CYTHON_EXTERN_C - #undef __PYX_EXTERN_C - #define __PYX_EXTERN_C CYTHON_EXTERN_C -#elif defined(__PYX_EXTERN_C) - #ifdef _MSC_VER - #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") - #else - #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. - #endif -#else - #define __PYX_EXTERN_C extern "C++" -#endif - -#define __PYX_HAVE__opendbc__can__parser_pyx -#define __PYX_HAVE_API__opendbc__can__parser_pyx -/* Early includes */ -#include "ios" -#include "new" -#include "stdexcept" -#include "typeinfo" -#include - - #if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600) - // move should be defined for these versions of MSVC, but __cplusplus isn't set usefully - #include - - namespace cython_std { - template typename std::remove_reference::type&& move(T& t) noexcept { return std::move(t); } - template typename std::remove_reference::type&& move(T&& t) noexcept { return std::move(t); } - } - - #endif - -#include -#include -#include -#include -#include -#include "common_dbc.h" -#include "common.h" -#ifdef _OPENMP -#include -#endif /* _OPENMP */ - -#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) -#define CYTHON_WITHOUT_ASSERTIONS -#endif - -typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; - const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; - -#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 1 -#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 -#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) -#define __PYX_DEFAULT_STRING_ENCODING "ascii" -#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString -#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#define __Pyx_uchar_cast(c) ((unsigned char)c) -#define __Pyx_long_cast(x) ((long)x) -#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ - (sizeof(type) < sizeof(Py_ssize_t)) ||\ - (sizeof(type) > sizeof(Py_ssize_t) &&\ - likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX) &&\ - (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ - v == (type)PY_SSIZE_T_MIN))) ||\ - (sizeof(type) == sizeof(Py_ssize_t) &&\ - (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ - v == (type)PY_SSIZE_T_MAX))) ) -static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { - return (size_t) i < (size_t) limit; -} -#if defined (__cplusplus) && __cplusplus >= 201103L - #include - #define __Pyx_sst_abs(value) std::abs(value) -#elif SIZEOF_INT >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) abs(value) -#elif SIZEOF_LONG >= SIZEOF_SIZE_T - #define __Pyx_sst_abs(value) labs(value) -#elif defined (_MSC_VER) - #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) -#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - #define __Pyx_sst_abs(value) llabs(value) -#elif defined (__GNUC__) - #define __Pyx_sst_abs(value) __builtin_llabs(value) -#else - #define __Pyx_sst_abs(value) ((value<0) ? -value : value) -#endif -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); -#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) -#define __Pyx_PyBytes_FromString PyBytes_FromString -#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); -#if PY_MAJOR_VERSION < 3 - #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize -#else - #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString - #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize -#endif -#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) -#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) -#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) -#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) -#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) -#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) -#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) -{ - const wchar_t *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#else -static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) -{ - const Py_UNICODE *u_end = u; - while (*u_end++) ; - return (size_t)(u_end - u - 1); -} -#endif -#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) -#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) -#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode -#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode -#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) -#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); -#define __Pyx_PySequence_Tuple(obj)\ - (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); -#if CYTHON_ASSUME_SAFE_MACROS -#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) -#else -#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) -#endif -#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) -#if PY_MAJOR_VERSION >= 3 -#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) -#else -#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) -#endif -#if CYTHON_USE_PYLONG_INTERNALS - #if PY_VERSION_HEX >= 0x030C00A7 - #ifndef _PyLong_SIGN_MASK - #define _PyLong_SIGN_MASK 3 - #endif - #ifndef _PyLong_NON_SIZE_BITS - #define _PyLong_NON_SIZE_BITS 3 - #endif - #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) - #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) - #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) - #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) - #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_SignedDigitCount(x)\ - ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) - #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) - #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) - #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) - #else - #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) - #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) - #endif - typedef Py_ssize_t __Pyx_compact_pylong; - typedef size_t __Pyx_compact_upylong; - #else - #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) - #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) - #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) - #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) - #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) - #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) - #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) - #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) - #define __Pyx_PyLong_CompactValue(x)\ - ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) - typedef sdigit __Pyx_compact_pylong; - typedef digit __Pyx_compact_upylong; - #endif - #if PY_VERSION_HEX >= 0x030C00A5 - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) - #else - #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) - #endif -#endif -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII -#include -static int __Pyx_sys_getdefaultencoding_not_ascii; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - PyObject* ascii_chars_u = NULL; - PyObject* ascii_chars_b = NULL; - const char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - if (strcmp(default_encoding_c, "ascii") == 0) { - __Pyx_sys_getdefaultencoding_not_ascii = 0; - } else { - char ascii_chars[128]; - int c; - for (c = 0; c < 128; c++) { - ascii_chars[c] = (char) c; - } - __Pyx_sys_getdefaultencoding_not_ascii = 1; - ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); - if (!ascii_chars_u) goto bad; - ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); - if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { - PyErr_Format( - PyExc_ValueError, - "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", - default_encoding_c); - goto bad; - } - Py_DECREF(ascii_chars_u); - Py_DECREF(ascii_chars_b); - } - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - Py_XDECREF(ascii_chars_u); - Py_XDECREF(ascii_chars_b); - return -1; -} -#endif -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) -#else -#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) -#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#include -static char* __PYX_DEFAULT_STRING_ENCODING; -static int __Pyx_init_sys_getdefaultencoding_params(void) { - PyObject* sys; - PyObject* default_encoding = NULL; - char* default_encoding_c; - sys = PyImport_ImportModule("sys"); - if (!sys) goto bad; - default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); - Py_DECREF(sys); - if (!default_encoding) goto bad; - default_encoding_c = PyBytes_AsString(default_encoding); - if (!default_encoding_c) goto bad; - __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); - if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; - strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); - Py_DECREF(default_encoding); - return 0; -bad: - Py_XDECREF(default_encoding); - return -1; -} -#endif -#endif - - -/* Test for GCC > 2.95 */ -#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) - #define likely(x) __builtin_expect(!!(x), 1) - #define unlikely(x) __builtin_expect(!!(x), 0) -#else /* !__GNUC__ or GCC < 2.95 */ - #define likely(x) (x) - #define unlikely(x) (x) -#endif /* __GNUC__ */ -static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } - -#if !CYTHON_USE_MODULE_STATE -static PyObject *__pyx_m = NULL; -#endif -static int __pyx_lineno; -static int __pyx_clineno = 0; -static const char * __pyx_cfilenm = __FILE__; -static const char *__pyx_filename; - -/* #### Code section: filename_table ### */ - -static const char *__pyx_f[] = { - "opendbc/can/parser_pyx.pyx", - "", -}; -/* #### Code section: utility_code_proto_before_types ### */ -/* ForceInitThreads.proto */ -#ifndef __PYX_FORCE_INIT_THREADS - #define __PYX_FORCE_INIT_THREADS 0 -#endif - -/* #### Code section: numeric_typedefs ### */ -/* #### Code section: complex_type_declarations ### */ -/* #### Code section: type_declarations ### */ - -/*--- Type declarations ---*/ -struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser; -struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine; - -/* "common.pxd":11 - * - * - * ctypedef unsigned int (*calc_checksum_type)(uint32_t, const Signal&, const vector[uint8_t] &) # <<<<<<<<<<<<<< - * - * cdef extern from "common_dbc.h": - */ -typedef unsigned int (*__pyx_t_7opendbc_3can_6common_calc_checksum_type)(uint32_t, struct Signal const &, std::vector const &); - -/* "opendbc/can/parser_pyx.pyx":18 - * - * - * cdef class CANParser: # <<<<<<<<<<<<<< - * cdef: - * cpp_CANParser *can - */ -struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser { - PyObject_HEAD - CANParser *can; - struct DBC const *dbc; - std::vector can_values; - PyObject *vl; - PyObject *vl_all; - PyObject *ts_nanos; - std::string dbc_name; -}; - - -/* "opendbc/can/parser_pyx.pyx":105 - * - * - * cdef class CANDefine(): # <<<<<<<<<<<<<< - * cdef: - * const DBC *dbc - */ -struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine { - PyObject_HEAD - struct DBC const *dbc; - PyObject *dv; - std::string dbc_name; -}; - -/* #### Code section: utility_code_proto ### */ - -/* --- Runtime support code (head) --- */ -/* Refnanny.proto */ -#ifndef CYTHON_REFNANNY - #define CYTHON_REFNANNY 0 -#endif -#if CYTHON_REFNANNY - typedef struct { - void (*INCREF)(void*, PyObject*, Py_ssize_t); - void (*DECREF)(void*, PyObject*, Py_ssize_t); - void (*GOTREF)(void*, PyObject*, Py_ssize_t); - void (*GIVEREF)(void*, PyObject*, Py_ssize_t); - void* (*SetupContext)(const char*, Py_ssize_t, const char*); - void (*FinishContext)(void**); - } __Pyx_RefNannyAPIStruct; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; - static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); - #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; -#ifdef WITH_THREAD - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - if (acquire_gil) {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - PyGILState_Release(__pyx_gilstate_save);\ - } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ - } - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } -#else - #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) - #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() -#endif - #define __Pyx_RefNannyFinishContextNogil() {\ - PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __Pyx_RefNannyFinishContext();\ - PyGILState_Release(__pyx_gilstate_save);\ - } - #define __Pyx_RefNannyFinishContext()\ - __Pyx_RefNanny->FinishContext(&__pyx_refnanny) - #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) - #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) - #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) - #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) - #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) -#else - #define __Pyx_RefNannyDeclarations - #define __Pyx_RefNannySetupContext(name, acquire_gil) - #define __Pyx_RefNannyFinishContextNogil() - #define __Pyx_RefNannyFinishContext() - #define __Pyx_INCREF(r) Py_INCREF(r) - #define __Pyx_DECREF(r) Py_DECREF(r) - #define __Pyx_GOTREF(r) - #define __Pyx_GIVEREF(r) - #define __Pyx_XINCREF(r) Py_XINCREF(r) - #define __Pyx_XDECREF(r) Py_XDECREF(r) - #define __Pyx_XGOTREF(r) - #define __Pyx_XGIVEREF(r) -#endif -#define __Pyx_Py_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; Py_XDECREF(tmp);\ - } while (0) -#define __Pyx_XDECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_XDECREF(tmp);\ - } while (0) -#define __Pyx_DECREF_SET(r, v) do {\ - PyObject *tmp = (PyObject *) r;\ - r = v; __Pyx_DECREF(tmp);\ - } while (0) -#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) -#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) - -/* PyErrExceptionMatches.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); -#else -#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) -#endif - -/* PyThreadStateGet.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; -#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; -#if PY_VERSION_HEX >= 0x030C00A6 -#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) -#else -#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) -#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) -#endif -#else -#define __Pyx_PyThreadState_declare -#define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) -#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() -#endif - -/* PyErrFetchRestore.proto */ -#if CYTHON_FAST_THREAD_STATE -#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) -#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 -#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) -#else -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#endif -#else -#define __Pyx_PyErr_Clear() PyErr_Clear() -#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) -#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) -#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) -#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) -#endif - -/* PyObjectGetAttrStr.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* RaiseTooManyValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); - -/* RaiseNeedMoreValuesToUnpack.proto */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); - -/* IterFinish.proto */ -static CYTHON_INLINE int __Pyx_IterFinish(void); - -/* UnpackItemEndCheck.proto */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); - -/* TupleAndListFromArray.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); -static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); -#endif - -/* IncludeStringH.proto */ -#include - -/* BytesEquals.proto */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); - -/* UnicodeEquals.proto */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); - -/* fastcall.proto */ -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) -#elif CYTHON_ASSUME_SAFE_MACROS - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) -#else - #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) -#endif -#if CYTHON_AVOID_BORROWED_REFS - #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) - #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) -#else - #define __Pyx_Arg_NewRef_VARARGS(arg) arg - #define __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) -#define __Pyx_KwValues_VARARGS(args, nargs) NULL -#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) -#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) -#if CYTHON_METH_FASTCALL - #define __Pyx_Arg_FASTCALL(args, i) args[i] - #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) - #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) - static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); - #else - #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) - #endif - #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs - to have the same reference counting */ - #define __Pyx_Arg_XDECREF_FASTCALL(arg) -#else - #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS - #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS - #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS - #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS - #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS - #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) - #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) -#endif -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) -#else -#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) -#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) -#endif - -/* RaiseArgTupleInvalid.proto */ -static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, - Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); - -/* RaiseDoubleKeywords.proto */ -static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); - -/* ParseKeywords.proto */ -static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, - const char* function_name); - -/* MoveIfSupported.proto */ -#if CYTHON_USE_CPP_STD_MOVE - #include - #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x) -#else - #define __PYX_STD_MOVE_IF_SUPPORTED(x) x -#endif - -/* PyObjectFormatSimple.proto */ -#if CYTHON_COMPILING_IN_PYPY - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#elif PY_MAJOR_VERSION < 3 - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyString_CheckExact(s)) ? PyUnicode_FromEncodedObject(s, NULL, "strict") :\ - PyObject_Format(s, f)) -#elif CYTHON_USE_TYPE_SLOTS - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ - likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ - PyObject_Format(s, f)) -#else - #define __Pyx_PyObject_FormatSimple(s, f) (\ - likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ - PyObject_Format(s, f)) -#endif - -/* PyFunctionFastCall.proto */ -#if CYTHON_FAST_PYCALL -#if !CYTHON_VECTORCALL -#define __Pyx_PyFunction_FastCall(func, args, nargs)\ - __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); -#endif -#define __Pyx_BUILD_ASSERT_EXPR(cond)\ - (sizeof(char [1 - 2*!(cond)]) - 1) -#ifndef Py_MEMBER_SIZE -#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) -#endif -#if !CYTHON_VECTORCALL -#if PY_VERSION_HEX >= 0x03080000 - #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif - #define __Pxy_PyFrame_Initialize_Offsets() - #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) -#else - static size_t __pyx_pyframe_localsplus_offset = 0; - #include "frameobject.h" - #define __Pxy_PyFrame_Initialize_Offsets()\ - ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ - (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) - #define __Pyx_PyFrame_GetLocalsplus(frame)\ - (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) -#endif -#endif -#endif - -/* PyObjectCall.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); -#else -#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) -#endif - -/* PyObjectCallMethO.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); -#endif - -/* PyObjectFastCall.proto */ -#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); - -/* PyObjectCallOneArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); - -/* RaiseException.proto */ -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); - -/* IncludeCppStringH.proto */ -#include - -/* decode_c_string_utf16.proto */ -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 0; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = -1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} -static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { - int byteorder = 1; - return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); -} - -/* decode_c_bytes.proto */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); - -/* decode_cpp_string.proto */ -static CYTHON_INLINE PyObject* __Pyx_decode_cpp_string( - std::string cppstring, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - return __Pyx_decode_c_bytes( - cppstring.data(), cppstring.size(), start, stop, encoding, errors, decode_func); -} - -/* GetItemInt.proto */ -#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ - (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ - __Pyx_GetItemInt_Generic(o, to_py_func(i)))) -#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ - (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ - __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ - (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - int wraparound, int boundscheck); -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, - int is_list, int wraparound, int boundscheck); - -/* PyDictVersioning.proto */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) -#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ - (version_var) = __PYX_GET_DICT_VERSION(dict);\ - (cache_var) = (value); -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ - (VAR) = __pyx_dict_cached_value;\ - } else {\ - (VAR) = __pyx_dict_cached_value = (LOOKUP);\ - __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ - }\ -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); -#else -#define __PYX_GET_DICT_VERSION(dict) (0) -#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) -#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); -#endif - -/* GetModuleGlobalName.proto */ -#if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) do {\ - static PY_UINT64_T __pyx_dict_version = 0;\ - static PyObject *__pyx_dict_cached_value = NULL;\ - (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ - (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ - __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ - PY_UINT64_T __pyx_dict_version;\ - PyObject *__pyx_dict_cached_value;\ - (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} while(0) -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); -#else -#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) -#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); -#endif - -/* dict_getitem_default.proto */ -static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); - -/* UnpackUnboundCMethod.proto */ -typedef struct { - PyObject *type; - PyObject **method_name; - PyCFunction func; - PyObject *method; - int flag; -} __Pyx_CachedCFunction; - -/* CallUnboundCMethod1.proto */ -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg); -#else -#define __Pyx_CallUnboundCMethod1(cfunc, self, arg) __Pyx__CallUnboundCMethod1(cfunc, self, arg) -#endif - -/* CallUnboundCMethod2.proto */ -static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 -static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); -#else -#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) -#endif - -/* PyDictContains.proto */ -static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { - int result = PyDict_Contains(dict, item); - return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); -} - -/* JoinPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char); - -/* DictGetItem.proto */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); -#define __Pyx_PyObject_Dict_GetItem(obj, name)\ - (likely(PyDict_CheckExact(obj)) ?\ - __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) -#else -#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) -#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) -#endif - -/* PyObjectCallNoArg.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); - -/* PyObjectGetMethod.proto */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); - -/* PyObjectCallMethod0.proto */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); - -/* RaiseNoneIterError.proto */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); - -/* UnpackTupleError.proto */ -static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); - -/* UnpackTuple2.proto */ -#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ - (likely(is_tuple || PyTuple_Check(tuple)) ?\ - (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ - __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ - (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ - __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); -static int __Pyx_unpack_tuple2_generic( - PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); - -/* dict_iter.proto */ -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_is_dict); -static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); - -/* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); - -/* ObjectGetItem.proto */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); -#else -#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) -#endif - -/* ListCompAppend.proto */ -#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS -static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { - PyListObject* L = (PyListObject*) list; - Py_ssize_t len = Py_SIZE(list); - if (likely(L->allocated > len)) { - Py_INCREF(x); - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 - L->ob_item[len] = x; - #else - PyList_SET_ITEM(list, len, x); - #endif - __Pyx_SET_SIZE(list, len + 1); - return 0; - } - return PyList_Append(list, x); -} -#else -#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) -#endif - -/* RaiseUnexpectedTypeError.proto */ -static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); - -/* IncludeStructmemberH.proto */ -#include - -/* FixUpExtensionType.proto */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); -#endif - -/* ValidateBasesTuple.proto */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); -#endif - -/* PyType_Ready.proto */ -CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); - -/* PyObject_GenericGetAttrNoDict.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr -#endif - -/* PyObject_GenericGetAttr.proto */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); -#else -#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr -#endif - -/* SetupReduce.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce(PyObject* type_obj); -#endif - -/* Import.proto */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); - -/* ImportDottedModule.proto */ -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple); -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple); -#endif - -/* ImportFrom.proto */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); - -/* FetchSharedCythonModule.proto */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void); - -/* FetchCommonType.proto */ -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); -#else -static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); -#endif - -/* PyMethodNew.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - typesModule = PyImport_ImportModule("types"); - if (!typesModule) return NULL; - methodType = PyObject_GetAttrString(typesModule, "MethodType"); - Py_DECREF(typesModule); - if (!methodType) return NULL; - result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); - Py_DECREF(methodType); - return result; -} -#elif PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { - CYTHON_UNUSED_VAR(typ); - if (!self) - return __Pyx_NewRef(func); - return PyMethod_New(func, self); -} -#else - #define __Pyx_PyMethod_New PyMethod_New -#endif - -/* PyVectorcallFastCallDict.proto */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); -#endif - -/* CythonFunctionShared.proto */ -#define __Pyx_CyFunction_USED -#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 -#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 -#define __Pyx_CYFUNCTION_CCLASS 0x04 -#define __Pyx_CYFUNCTION_COROUTINE 0x08 -#define __Pyx_CyFunction_GetClosure(f)\ - (((__pyx_CyFunctionObject *) (f))->func_closure) -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - #define __Pyx_CyFunction_GetClassObj(f)\ - (((__pyx_CyFunctionObject *) (f))->func_classobj) -#else - #define __Pyx_CyFunction_GetClassObj(f)\ - ((PyObject*) ((PyCMethodObject *) (f))->mm_class) -#endif -#define __Pyx_CyFunction_SetClassObj(f, classobj)\ - __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) -#define __Pyx_CyFunction_Defaults(type, f)\ - ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) -#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ - ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) -typedef struct { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject_HEAD - PyObject *func; -#elif PY_VERSION_HEX < 0x030900B1 - PyCFunctionObject func; -#else - PyCMethodObject func; -#endif -#if CYTHON_BACKPORT_VECTORCALL - __pyx_vectorcallfunc func_vectorcall; -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_weakreflist; -#endif - PyObject *func_dict; - PyObject *func_name; - PyObject *func_qualname; - PyObject *func_doc; - PyObject *func_globals; - PyObject *func_code; - PyObject *func_closure; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - PyObject *func_classobj; -#endif - void *defaults; - int defaults_pyobjects; - size_t defaults_size; - int flags; - PyObject *defaults_tuple; - PyObject *defaults_kwdict; - PyObject *(*defaults_getter)(PyObject *); - PyObject *func_annotations; - PyObject *func_is_coroutine; -} __pyx_CyFunctionObject; -#undef __Pyx_CyOrPyCFunction_Check -#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) -#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) -#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); -#undef __Pyx_IsSameCFunction -#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, - size_t size, - int pyobjects); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, - PyObject *tuple); -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, - PyObject *dict); -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, - PyObject *dict); -static int __pyx_CyFunction_init(PyObject *module); -#if CYTHON_METH_FASTCALL -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); -#if CYTHON_BACKPORT_VECTORCALL -#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) -#else -#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) -#endif -#endif - -/* CythonFunction.proto */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, - int flags, PyObject* qualname, - PyObject *closure, - PyObject *module, PyObject *globals, - PyObject* code); - -/* CLineInTraceback.proto */ -#ifdef CYTHON_CLINE_IN_TRACEBACK -#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) -#else -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); -#endif - -/* CodeObjectCache.proto */ -#if !CYTHON_COMPILING_IN_LIMITED_API -typedef struct { - PyCodeObject* code_object; - int code_line; -} __Pyx_CodeObjectCacheEntry; -struct __Pyx_CodeObjectCache { - int count; - int max_count; - __Pyx_CodeObjectCacheEntry* entries; -}; -static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); -static PyCodeObject *__pyx_find_code_object(int code_line); -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); -#endif - -/* AddTraceback.proto */ -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename); - -/* None.proto */ -#include - -/* CppExceptionConversion.proto */ -#ifndef __Pyx_CppExn2PyErr -#include -#include -#include -#include -static void __Pyx_CppExn2PyErr() { - try { - if (PyErr_Occurred()) - ; // let the latest Python exn pass through and ignore the current one - else - throw; - } catch (const std::bad_alloc& exn) { - PyErr_SetString(PyExc_MemoryError, exn.what()); - } catch (const std::bad_cast& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::bad_typeid& exn) { - PyErr_SetString(PyExc_TypeError, exn.what()); - } catch (const std::domain_error& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::invalid_argument& exn) { - PyErr_SetString(PyExc_ValueError, exn.what()); - } catch (const std::ios_base::failure& exn) { - PyErr_SetString(PyExc_IOError, exn.what()); - } catch (const std::out_of_range& exn) { - PyErr_SetString(PyExc_IndexError, exn.what()); - } catch (const std::overflow_error& exn) { - PyErr_SetString(PyExc_OverflowError, exn.what()); - } catch (const std::range_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::underflow_error& exn) { - PyErr_SetString(PyExc_ArithmeticError, exn.what()); - } catch (const std::exception& exn) { - PyErr_SetString(PyExc_RuntimeError, exn.what()); - } - catch (...) - { - PyErr_SetString(PyExc_RuntimeError, "Unknown exception"); - } -} -#endif - -/* GCCDiagnostics.proto */ -#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC -#endif - -/* CIntFromPy.proto */ -static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); - -/* CIntFromPy.proto */ -static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *); - -/* CIntFromPy.proto */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); - -/* CIntToPy.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); - -/* FormatTypeName.proto */ -#if CYTHON_COMPILING_IN_LIMITED_API -typedef PyObject *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%U" -static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); -#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) -#else -typedef const char *__Pyx_TypeName; -#define __Pyx_FMT_TYPENAME "%.200s" -#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) -#define __Pyx_DECREF_TypeName(obj) -#endif - -/* CIntFromPy.proto */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); - -/* FastTypeChecks.proto */ -#if CYTHON_COMPILING_IN_CPYTHON -#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); -static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); -#else -#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) -#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) -#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) -#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) -#endif -#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) -#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) - -/* CheckBinaryVersion.proto */ -static unsigned long __Pyx_get_runtime_version(void); -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); - -/* InitStrings.proto */ -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); - -/* #### Code section: module_declarations ### */ - -/* Module declarations from "libcpp.utility" */ - -/* Module declarations from "libcpp.pair" */ - -/* Module declarations from "libc.string" */ - -/* Module declarations from "libcpp.string" */ - -/* Module declarations from "libcpp.vector" */ - -/* Module declarations from "libcpp.unordered_set" */ - -/* Module declarations from "libc.stdint" */ - -/* Module declarations from "libcpp" */ - -/* Module declarations from "opendbc.can.common" */ - -/* Module declarations from "opendbc.can.parser_pyx" */ -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &); /*proto*/ -static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &); /*proto*/ -static std::pair __pyx_convert_pair_from_py_uint32_t__and_int(PyObject *); /*proto*/ -static std::vector __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *); /*proto*/ -static PyObject *__pyx_convert_vector_to_py_double(std::vector const &); /*proto*/ -static PyObject *__pyx_convert_unordered_set_to_py_uint32_t(std::unordered_set const &); /*proto*/ -/* #### Code section: typeinfo ### */ -/* #### Code section: before_global_var ### */ -#define __Pyx_MODULE_NAME "opendbc.can.parser_pyx" -extern int __pyx_module_is_main_opendbc__can__parser_pyx; -int __pyx_module_is_main_opendbc__can__parser_pyx = 0; - -/* Implementation of "opendbc.can.parser_pyx" */ -/* #### Code section: global_var ### */ -static PyObject *__pyx_builtin_RuntimeError; -static PyObject *__pyx_builtin_range; -static PyObject *__pyx_builtin_TypeError; -static PyObject *__pyx_builtin_zip; -static PyObject *__pyx_builtin_MemoryError; -/* #### Code section: string_decls ### */ -static const char __pyx_k_[] = "'"; -static const char __pyx_k_l[] = "l"; -static const char __pyx_k_v[] = "v"; -static const char __pyx_k__4[] = "*"; -static const char __pyx_k__5[] = "."; -static const char __pyx_k_cv[] = "cv"; -static const char __pyx_k_gc[] = "gc"; -static const char __pyx_k_it[] = "it"; -static const char __pyx_k__15[] = "?"; -static const char __pyx_k_bus[] = "bus"; -static const char __pyx_k_get[] = "get"; -static const char __pyx_k_zip[] = "zip"; -static const char __pyx_k_main[] = "__main__"; -static const char __pyx_k_name[] = "__name__"; -static const char __pyx_k_self[] = "self"; -static const char __pyx_k_spec[] = "__spec__"; -static const char __pyx_k_test[] = "__test__"; -static const char __pyx_k_clear[] = "clear"; -static const char __pyx_k_range[] = "range"; -static const char __pyx_k_split[] = "split"; -static const char __pyx_k_Number[] = "Number"; -static const char __pyx_k_enable[] = "enable"; -static const char __pyx_k_import[] = "__import__"; -static const char __pyx_k_in_DBC[] = " in DBC "; -static const char __pyx_k_reduce[] = "__reduce__"; -static const char __pyx_k_values[] = "values"; -static const char __pyx_k_cv_name[] = "cv_name"; -static const char __pyx_k_disable[] = "disable"; -static const char __pyx_k_numbers[] = "numbers"; -static const char __pyx_k_sendcan[] = "sendcan"; -static const char __pyx_k_strings[] = "strings"; -static const char __pyx_k_dbc_name[] = "dbc_name"; -static const char __pyx_k_getstate[] = "__getstate__"; -static const char __pyx_k_messages[] = "messages"; -static const char __pyx_k_new_vals[] = "new_vals"; -static const char __pyx_k_setstate[] = "__setstate__"; -static const char __pyx_k_CANDefine[] = "CANDefine"; -static const char __pyx_k_CANParser[] = "CANParser"; -static const char __pyx_k_TypeError[] = "TypeError"; -static const char __pyx_k_isenabled[] = "isenabled"; -static const char __pyx_k_pyx_state[] = "__pyx_state"; -static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; -static const char __pyx_k_MemoryError[] = "MemoryError"; -static const char __pyx_k_collections[] = "collections"; -static const char __pyx_k_defaultdict[] = "defaultdict"; -static const char __pyx_k_RuntimeError[] = "RuntimeError"; -static const char __pyx_k_initializing[] = "_initializing"; -static const char __pyx_k_is_coroutine[] = "_is_coroutine"; -static const char __pyx_k_stringsource[] = ""; -static const char __pyx_k_class_getitem[] = "__class_getitem__"; -static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; -static const char __pyx_k_updated_addrs[] = "updated_addrs"; -static const char __pyx_k_Can_t_find_DBC[] = "Can't find DBC: "; -static const char __pyx_k_update_strings[] = "update_strings"; -static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; -static const char __pyx_k_Can_t_find_DBC_2[] = "Can't find DBC: '"; -static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; -static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; -static const char __pyx_k_could_not_find_message[] = "could not find message "; -static const char __pyx_k_opendbc_can_parser_pyx[] = "opendbc.can.parser_pyx"; -static const char __pyx_k_CANParser_update_strings[] = "CANParser.update_strings"; -static const char __pyx_k_CANDefine___reduce_cython[] = "CANDefine.__reduce_cython__"; -static const char __pyx_k_CANParser___reduce_cython[] = "CANParser.__reduce_cython__"; -static const char __pyx_k_opendbc_can_parser_pyx_pyx[] = "opendbc/can/parser_pyx.pyx"; -static const char __pyx_k_CANDefine___setstate_cython[] = "CANDefine.__setstate_cython__"; -static const char __pyx_k_CANParser___setstate_cython[] = "CANParser.__setstate_cython__"; -static const char __pyx_k_self_dbc_cannot_be_converted_to[] = "self.dbc cannot be converted to a Python object for pickling"; -static const char __pyx_k_self_can_self_dbc_cannot_be_conv[] = "self.can,self.dbc cannot be converted to a Python object for pickling"; -/* #### Code section: decls ### */ -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser___init__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, PyObject *__pyx_v_dbc_name, PyObject *__pyx_v_messages, PyObject *__pyx_v_bus); /* proto */ -static void __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2__dealloc__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_4update_strings(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, PyObject *__pyx_v_strings, PyObject *__pyx_v_sendcan); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_9can_valid___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2vl___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6vl_all___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine___init__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_dbc_name); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self); /* proto */ -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_2__set__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_4__del__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self); /* proto */ -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_2__set__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ -static PyObject *__pyx_tp_new_7opendbc_3can_10parser_pyx_CANParser(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_tp_new_7opendbc_3can_10parser_pyx_CANDefine(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_get = {0, 0, 0, 0, 0}; -/* #### Code section: late_includes ### */ -/* #### Code section: module_state ### */ -typedef struct { - PyObject *__pyx_d; - PyObject *__pyx_b; - PyObject *__pyx_cython_runtime; - PyObject *__pyx_empty_tuple; - PyObject *__pyx_empty_bytes; - PyObject *__pyx_empty_unicode; - #ifdef __Pyx_CyFunction_USED - PyTypeObject *__pyx_CyFunctionType; - #endif - #ifdef __Pyx_FusedFunction_USED - PyTypeObject *__pyx_FusedFunctionType; - #endif - #ifdef __Pyx_Generator_USED - PyTypeObject *__pyx_GeneratorType; - #endif - #ifdef __Pyx_IterableCoroutine_USED - PyTypeObject *__pyx_IterableCoroutineType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineAwaitType; - #endif - #ifdef __Pyx_Coroutine_USED - PyTypeObject *__pyx_CoroutineType; - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - #endif - #if CYTHON_USE_MODULE_STATE - PyObject *__pyx_type_7opendbc_3can_10parser_pyx_CANParser; - PyObject *__pyx_type_7opendbc_3can_10parser_pyx_CANDefine; - #endif - PyTypeObject *__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser; - PyTypeObject *__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine; - PyObject *__pyx_kp_u_; - PyObject *__pyx_n_s_CANDefine; - PyObject *__pyx_n_s_CANDefine___reduce_cython; - PyObject *__pyx_n_s_CANDefine___setstate_cython; - PyObject *__pyx_n_s_CANParser; - PyObject *__pyx_n_s_CANParser___reduce_cython; - PyObject *__pyx_n_s_CANParser___setstate_cython; - PyObject *__pyx_n_s_CANParser_update_strings; - PyObject *__pyx_kp_u_Can_t_find_DBC; - PyObject *__pyx_kp_u_Can_t_find_DBC_2; - PyObject *__pyx_n_s_MemoryError; - PyObject *__pyx_n_s_Number; - PyObject *__pyx_n_s_RuntimeError; - PyObject *__pyx_n_s_TypeError; - PyObject *__pyx_n_s__15; - PyObject *__pyx_n_s__4; - PyObject *__pyx_kp_u__5; - PyObject *__pyx_n_s_asyncio_coroutines; - PyObject *__pyx_n_s_bus; - PyObject *__pyx_n_s_class_getitem; - PyObject *__pyx_n_s_clear; - PyObject *__pyx_n_s_cline_in_traceback; - PyObject *__pyx_n_s_collections; - PyObject *__pyx_kp_u_could_not_find_message; - PyObject *__pyx_n_s_cv; - PyObject *__pyx_n_s_cv_name; - PyObject *__pyx_n_s_dbc_name; - PyObject *__pyx_n_s_defaultdict; - PyObject *__pyx_kp_u_disable; - PyObject *__pyx_kp_u_enable; - PyObject *__pyx_kp_u_gc; - PyObject *__pyx_n_s_get; - PyObject *__pyx_n_s_getstate; - PyObject *__pyx_n_s_import; - PyObject *__pyx_kp_u_in_DBC; - PyObject *__pyx_n_s_initializing; - PyObject *__pyx_n_s_is_coroutine; - PyObject *__pyx_kp_u_isenabled; - PyObject *__pyx_n_s_it; - PyObject *__pyx_n_s_l; - PyObject *__pyx_n_s_main; - PyObject *__pyx_n_s_messages; - PyObject *__pyx_n_s_name; - PyObject *__pyx_n_s_new_vals; - PyObject *__pyx_n_s_numbers; - PyObject *__pyx_n_s_opendbc_can_parser_pyx; - PyObject *__pyx_kp_s_opendbc_can_parser_pyx_pyx; - PyObject *__pyx_n_s_pyx_state; - PyObject *__pyx_n_s_range; - PyObject *__pyx_n_s_reduce; - PyObject *__pyx_n_s_reduce_cython; - PyObject *__pyx_n_s_reduce_ex; - PyObject *__pyx_n_s_self; - PyObject *__pyx_kp_s_self_can_self_dbc_cannot_be_conv; - PyObject *__pyx_kp_s_self_dbc_cannot_be_converted_to; - PyObject *__pyx_n_s_sendcan; - PyObject *__pyx_n_s_setstate; - PyObject *__pyx_n_s_setstate_cython; - PyObject *__pyx_n_s_spec; - PyObject *__pyx_n_s_split; - PyObject *__pyx_n_s_strings; - PyObject *__pyx_kp_s_stringsource; - PyObject *__pyx_n_s_test; - PyObject *__pyx_n_s_update_strings; - PyObject *__pyx_n_s_updated_addrs; - PyObject *__pyx_n_s_v; - PyObject *__pyx_n_s_values; - PyObject *__pyx_n_s_zip; - PyObject *__pyx_int_0; - PyObject *__pyx_int_1; - PyObject *__pyx_int_2; - PyObject *__pyx_slice__2; - PyObject *__pyx_slice__3; - PyObject *__pyx_tuple__6; - PyObject *__pyx_tuple__8; - PyObject *__pyx_tuple__9; - PyObject *__pyx_tuple__11; - PyObject *__pyx_codeobj__7; - PyObject *__pyx_codeobj__10; - PyObject *__pyx_codeobj__12; - PyObject *__pyx_codeobj__13; - PyObject *__pyx_codeobj__14; -} __pyx_mstate; - -#if CYTHON_USE_MODULE_STATE -#ifdef __cplusplus -namespace { - extern struct PyModuleDef __pyx_moduledef; -} /* anonymous namespace */ -#else -static struct PyModuleDef __pyx_moduledef; -#endif - -#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) - -#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) - -#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) -#else -static __pyx_mstate __pyx_mstate_global_static = -#ifdef __cplusplus - {}; -#else - {0}; -#endif -static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; -#endif -/* #### Code section: module_state_clear ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_clear(PyObject *m) { - __pyx_mstate *clear_module_state = __pyx_mstate(m); - if (!clear_module_state) return 0; - Py_CLEAR(clear_module_state->__pyx_d); - Py_CLEAR(clear_module_state->__pyx_b); - Py_CLEAR(clear_module_state->__pyx_cython_runtime); - Py_CLEAR(clear_module_state->__pyx_empty_tuple); - Py_CLEAR(clear_module_state->__pyx_empty_bytes); - Py_CLEAR(clear_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_CLEAR(clear_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); - #endif - Py_CLEAR(clear_module_state->__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser); - Py_CLEAR(clear_module_state->__pyx_type_7opendbc_3can_10parser_pyx_CANParser); - Py_CLEAR(clear_module_state->__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine); - Py_CLEAR(clear_module_state->__pyx_type_7opendbc_3can_10parser_pyx_CANDefine); - Py_CLEAR(clear_module_state->__pyx_kp_u_); - Py_CLEAR(clear_module_state->__pyx_n_s_CANDefine); - Py_CLEAR(clear_module_state->__pyx_n_s_CANDefine___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANDefine___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANParser); - Py_CLEAR(clear_module_state->__pyx_n_s_CANParser___reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANParser___setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_CANParser_update_strings); - Py_CLEAR(clear_module_state->__pyx_kp_u_Can_t_find_DBC); - Py_CLEAR(clear_module_state->__pyx_kp_u_Can_t_find_DBC_2); - Py_CLEAR(clear_module_state->__pyx_n_s_MemoryError); - Py_CLEAR(clear_module_state->__pyx_n_s_Number); - Py_CLEAR(clear_module_state->__pyx_n_s_RuntimeError); - Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); - Py_CLEAR(clear_module_state->__pyx_n_s__15); - Py_CLEAR(clear_module_state->__pyx_n_s__4); - Py_CLEAR(clear_module_state->__pyx_kp_u__5); - Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); - Py_CLEAR(clear_module_state->__pyx_n_s_bus); - Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem); - Py_CLEAR(clear_module_state->__pyx_n_s_clear); - Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); - Py_CLEAR(clear_module_state->__pyx_n_s_collections); - Py_CLEAR(clear_module_state->__pyx_kp_u_could_not_find_message); - Py_CLEAR(clear_module_state->__pyx_n_s_cv); - Py_CLEAR(clear_module_state->__pyx_n_s_cv_name); - Py_CLEAR(clear_module_state->__pyx_n_s_dbc_name); - Py_CLEAR(clear_module_state->__pyx_n_s_defaultdict); - Py_CLEAR(clear_module_state->__pyx_kp_u_disable); - Py_CLEAR(clear_module_state->__pyx_kp_u_enable); - Py_CLEAR(clear_module_state->__pyx_kp_u_gc); - Py_CLEAR(clear_module_state->__pyx_n_s_get); - Py_CLEAR(clear_module_state->__pyx_n_s_getstate); - Py_CLEAR(clear_module_state->__pyx_n_s_import); - Py_CLEAR(clear_module_state->__pyx_kp_u_in_DBC); - Py_CLEAR(clear_module_state->__pyx_n_s_initializing); - Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); - Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); - Py_CLEAR(clear_module_state->__pyx_n_s_it); - Py_CLEAR(clear_module_state->__pyx_n_s_l); - Py_CLEAR(clear_module_state->__pyx_n_s_main); - Py_CLEAR(clear_module_state->__pyx_n_s_messages); - Py_CLEAR(clear_module_state->__pyx_n_s_name); - Py_CLEAR(clear_module_state->__pyx_n_s_new_vals); - Py_CLEAR(clear_module_state->__pyx_n_s_numbers); - Py_CLEAR(clear_module_state->__pyx_n_s_opendbc_can_parser_pyx); - Py_CLEAR(clear_module_state->__pyx_kp_s_opendbc_can_parser_pyx_pyx); - Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); - Py_CLEAR(clear_module_state->__pyx_n_s_range); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); - Py_CLEAR(clear_module_state->__pyx_n_s_self); - Py_CLEAR(clear_module_state->__pyx_kp_s_self_can_self_dbc_cannot_be_conv); - Py_CLEAR(clear_module_state->__pyx_kp_s_self_dbc_cannot_be_converted_to); - Py_CLEAR(clear_module_state->__pyx_n_s_sendcan); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate); - Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); - Py_CLEAR(clear_module_state->__pyx_n_s_spec); - Py_CLEAR(clear_module_state->__pyx_n_s_split); - Py_CLEAR(clear_module_state->__pyx_n_s_strings); - Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); - Py_CLEAR(clear_module_state->__pyx_n_s_test); - Py_CLEAR(clear_module_state->__pyx_n_s_update_strings); - Py_CLEAR(clear_module_state->__pyx_n_s_updated_addrs); - Py_CLEAR(clear_module_state->__pyx_n_s_v); - Py_CLEAR(clear_module_state->__pyx_n_s_values); - Py_CLEAR(clear_module_state->__pyx_n_s_zip); - Py_CLEAR(clear_module_state->__pyx_int_0); - Py_CLEAR(clear_module_state->__pyx_int_1); - Py_CLEAR(clear_module_state->__pyx_int_2); - Py_CLEAR(clear_module_state->__pyx_slice__2); - Py_CLEAR(clear_module_state->__pyx_slice__3); - Py_CLEAR(clear_module_state->__pyx_tuple__6); - Py_CLEAR(clear_module_state->__pyx_tuple__8); - Py_CLEAR(clear_module_state->__pyx_tuple__9); - Py_CLEAR(clear_module_state->__pyx_tuple__11); - Py_CLEAR(clear_module_state->__pyx_codeobj__7); - Py_CLEAR(clear_module_state->__pyx_codeobj__10); - Py_CLEAR(clear_module_state->__pyx_codeobj__12); - Py_CLEAR(clear_module_state->__pyx_codeobj__13); - Py_CLEAR(clear_module_state->__pyx_codeobj__14); - return 0; -} -#endif -/* #### Code section: module_state_traverse ### */ -#if CYTHON_USE_MODULE_STATE -static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { - __pyx_mstate *traverse_module_state = __pyx_mstate(m); - if (!traverse_module_state) return 0; - Py_VISIT(traverse_module_state->__pyx_d); - Py_VISIT(traverse_module_state->__pyx_b); - Py_VISIT(traverse_module_state->__pyx_cython_runtime); - Py_VISIT(traverse_module_state->__pyx_empty_tuple); - Py_VISIT(traverse_module_state->__pyx_empty_bytes); - Py_VISIT(traverse_module_state->__pyx_empty_unicode); - #ifdef __Pyx_CyFunction_USED - Py_VISIT(traverse_module_state->__pyx_CyFunctionType); - #endif - #ifdef __Pyx_FusedFunction_USED - Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); - #endif - Py_VISIT(traverse_module_state->__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser); - Py_VISIT(traverse_module_state->__pyx_type_7opendbc_3can_10parser_pyx_CANParser); - Py_VISIT(traverse_module_state->__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine); - Py_VISIT(traverse_module_state->__pyx_type_7opendbc_3can_10parser_pyx_CANDefine); - Py_VISIT(traverse_module_state->__pyx_kp_u_); - Py_VISIT(traverse_module_state->__pyx_n_s_CANDefine); - Py_VISIT(traverse_module_state->__pyx_n_s_CANDefine___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANDefine___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANParser); - Py_VISIT(traverse_module_state->__pyx_n_s_CANParser___reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANParser___setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_CANParser_update_strings); - Py_VISIT(traverse_module_state->__pyx_kp_u_Can_t_find_DBC); - Py_VISIT(traverse_module_state->__pyx_kp_u_Can_t_find_DBC_2); - Py_VISIT(traverse_module_state->__pyx_n_s_MemoryError); - Py_VISIT(traverse_module_state->__pyx_n_s_Number); - Py_VISIT(traverse_module_state->__pyx_n_s_RuntimeError); - Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); - Py_VISIT(traverse_module_state->__pyx_n_s__15); - Py_VISIT(traverse_module_state->__pyx_n_s__4); - Py_VISIT(traverse_module_state->__pyx_kp_u__5); - Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); - Py_VISIT(traverse_module_state->__pyx_n_s_bus); - Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem); - Py_VISIT(traverse_module_state->__pyx_n_s_clear); - Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); - Py_VISIT(traverse_module_state->__pyx_n_s_collections); - Py_VISIT(traverse_module_state->__pyx_kp_u_could_not_find_message); - Py_VISIT(traverse_module_state->__pyx_n_s_cv); - Py_VISIT(traverse_module_state->__pyx_n_s_cv_name); - Py_VISIT(traverse_module_state->__pyx_n_s_dbc_name); - Py_VISIT(traverse_module_state->__pyx_n_s_defaultdict); - Py_VISIT(traverse_module_state->__pyx_kp_u_disable); - Py_VISIT(traverse_module_state->__pyx_kp_u_enable); - Py_VISIT(traverse_module_state->__pyx_kp_u_gc); - Py_VISIT(traverse_module_state->__pyx_n_s_get); - Py_VISIT(traverse_module_state->__pyx_n_s_getstate); - Py_VISIT(traverse_module_state->__pyx_n_s_import); - Py_VISIT(traverse_module_state->__pyx_kp_u_in_DBC); - Py_VISIT(traverse_module_state->__pyx_n_s_initializing); - Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); - Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); - Py_VISIT(traverse_module_state->__pyx_n_s_it); - Py_VISIT(traverse_module_state->__pyx_n_s_l); - Py_VISIT(traverse_module_state->__pyx_n_s_main); - Py_VISIT(traverse_module_state->__pyx_n_s_messages); - Py_VISIT(traverse_module_state->__pyx_n_s_name); - Py_VISIT(traverse_module_state->__pyx_n_s_new_vals); - Py_VISIT(traverse_module_state->__pyx_n_s_numbers); - Py_VISIT(traverse_module_state->__pyx_n_s_opendbc_can_parser_pyx); - Py_VISIT(traverse_module_state->__pyx_kp_s_opendbc_can_parser_pyx_pyx); - Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); - Py_VISIT(traverse_module_state->__pyx_n_s_range); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); - Py_VISIT(traverse_module_state->__pyx_n_s_self); - Py_VISIT(traverse_module_state->__pyx_kp_s_self_can_self_dbc_cannot_be_conv); - Py_VISIT(traverse_module_state->__pyx_kp_s_self_dbc_cannot_be_converted_to); - Py_VISIT(traverse_module_state->__pyx_n_s_sendcan); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate); - Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); - Py_VISIT(traverse_module_state->__pyx_n_s_spec); - Py_VISIT(traverse_module_state->__pyx_n_s_split); - Py_VISIT(traverse_module_state->__pyx_n_s_strings); - Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); - Py_VISIT(traverse_module_state->__pyx_n_s_test); - Py_VISIT(traverse_module_state->__pyx_n_s_update_strings); - Py_VISIT(traverse_module_state->__pyx_n_s_updated_addrs); - Py_VISIT(traverse_module_state->__pyx_n_s_v); - Py_VISIT(traverse_module_state->__pyx_n_s_values); - Py_VISIT(traverse_module_state->__pyx_n_s_zip); - Py_VISIT(traverse_module_state->__pyx_int_0); - Py_VISIT(traverse_module_state->__pyx_int_1); - Py_VISIT(traverse_module_state->__pyx_int_2); - Py_VISIT(traverse_module_state->__pyx_slice__2); - Py_VISIT(traverse_module_state->__pyx_slice__3); - Py_VISIT(traverse_module_state->__pyx_tuple__6); - Py_VISIT(traverse_module_state->__pyx_tuple__8); - Py_VISIT(traverse_module_state->__pyx_tuple__9); - Py_VISIT(traverse_module_state->__pyx_tuple__11); - Py_VISIT(traverse_module_state->__pyx_codeobj__7); - Py_VISIT(traverse_module_state->__pyx_codeobj__10); - Py_VISIT(traverse_module_state->__pyx_codeobj__12); - Py_VISIT(traverse_module_state->__pyx_codeobj__13); - Py_VISIT(traverse_module_state->__pyx_codeobj__14); - return 0; -} -#endif -/* #### Code section: module_state_defines ### */ -#define __pyx_d __pyx_mstate_global->__pyx_d -#define __pyx_b __pyx_mstate_global->__pyx_b -#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime -#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple -#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes -#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode -#ifdef __Pyx_CyFunction_USED -#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType -#endif -#ifdef __Pyx_FusedFunction_USED -#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType -#endif -#ifdef __Pyx_Generator_USED -#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType -#endif -#ifdef __Pyx_IterableCoroutine_USED -#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType -#endif -#ifdef __Pyx_Coroutine_USED -#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#endif -#if CYTHON_USE_MODULE_STATE -#define __pyx_type_7opendbc_3can_10parser_pyx_CANParser __pyx_mstate_global->__pyx_type_7opendbc_3can_10parser_pyx_CANParser -#define __pyx_type_7opendbc_3can_10parser_pyx_CANDefine __pyx_mstate_global->__pyx_type_7opendbc_3can_10parser_pyx_CANDefine -#endif -#define __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser __pyx_mstate_global->__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser -#define __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine __pyx_mstate_global->__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine -#define __pyx_kp_u_ __pyx_mstate_global->__pyx_kp_u_ -#define __pyx_n_s_CANDefine __pyx_mstate_global->__pyx_n_s_CANDefine -#define __pyx_n_s_CANDefine___reduce_cython __pyx_mstate_global->__pyx_n_s_CANDefine___reduce_cython -#define __pyx_n_s_CANDefine___setstate_cython __pyx_mstate_global->__pyx_n_s_CANDefine___setstate_cython -#define __pyx_n_s_CANParser __pyx_mstate_global->__pyx_n_s_CANParser -#define __pyx_n_s_CANParser___reduce_cython __pyx_mstate_global->__pyx_n_s_CANParser___reduce_cython -#define __pyx_n_s_CANParser___setstate_cython __pyx_mstate_global->__pyx_n_s_CANParser___setstate_cython -#define __pyx_n_s_CANParser_update_strings __pyx_mstate_global->__pyx_n_s_CANParser_update_strings -#define __pyx_kp_u_Can_t_find_DBC __pyx_mstate_global->__pyx_kp_u_Can_t_find_DBC -#define __pyx_kp_u_Can_t_find_DBC_2 __pyx_mstate_global->__pyx_kp_u_Can_t_find_DBC_2 -#define __pyx_n_s_MemoryError __pyx_mstate_global->__pyx_n_s_MemoryError -#define __pyx_n_s_Number __pyx_mstate_global->__pyx_n_s_Number -#define __pyx_n_s_RuntimeError __pyx_mstate_global->__pyx_n_s_RuntimeError -#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError -#define __pyx_n_s__15 __pyx_mstate_global->__pyx_n_s__15 -#define __pyx_n_s__4 __pyx_mstate_global->__pyx_n_s__4 -#define __pyx_kp_u__5 __pyx_mstate_global->__pyx_kp_u__5 -#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines -#define __pyx_n_s_bus __pyx_mstate_global->__pyx_n_s_bus -#define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem -#define __pyx_n_s_clear __pyx_mstate_global->__pyx_n_s_clear -#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback -#define __pyx_n_s_collections __pyx_mstate_global->__pyx_n_s_collections -#define __pyx_kp_u_could_not_find_message __pyx_mstate_global->__pyx_kp_u_could_not_find_message -#define __pyx_n_s_cv __pyx_mstate_global->__pyx_n_s_cv -#define __pyx_n_s_cv_name __pyx_mstate_global->__pyx_n_s_cv_name -#define __pyx_n_s_dbc_name __pyx_mstate_global->__pyx_n_s_dbc_name -#define __pyx_n_s_defaultdict __pyx_mstate_global->__pyx_n_s_defaultdict -#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable -#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable -#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc -#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get -#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate -#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import -#define __pyx_kp_u_in_DBC __pyx_mstate_global->__pyx_kp_u_in_DBC -#define __pyx_n_s_initializing __pyx_mstate_global->__pyx_n_s_initializing -#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine -#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled -#define __pyx_n_s_it __pyx_mstate_global->__pyx_n_s_it -#define __pyx_n_s_l __pyx_mstate_global->__pyx_n_s_l -#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main -#define __pyx_n_s_messages __pyx_mstate_global->__pyx_n_s_messages -#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name -#define __pyx_n_s_new_vals __pyx_mstate_global->__pyx_n_s_new_vals -#define __pyx_n_s_numbers __pyx_mstate_global->__pyx_n_s_numbers -#define __pyx_n_s_opendbc_can_parser_pyx __pyx_mstate_global->__pyx_n_s_opendbc_can_parser_pyx -#define __pyx_kp_s_opendbc_can_parser_pyx_pyx __pyx_mstate_global->__pyx_kp_s_opendbc_can_parser_pyx_pyx -#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state -#define __pyx_n_s_range __pyx_mstate_global->__pyx_n_s_range -#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce -#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython -#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex -#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self -#define __pyx_kp_s_self_can_self_dbc_cannot_be_conv __pyx_mstate_global->__pyx_kp_s_self_can_self_dbc_cannot_be_conv -#define __pyx_kp_s_self_dbc_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_dbc_cannot_be_converted_to -#define __pyx_n_s_sendcan __pyx_mstate_global->__pyx_n_s_sendcan -#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate -#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython -#define __pyx_n_s_spec __pyx_mstate_global->__pyx_n_s_spec -#define __pyx_n_s_split __pyx_mstate_global->__pyx_n_s_split -#define __pyx_n_s_strings __pyx_mstate_global->__pyx_n_s_strings -#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource -#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test -#define __pyx_n_s_update_strings __pyx_mstate_global->__pyx_n_s_update_strings -#define __pyx_n_s_updated_addrs __pyx_mstate_global->__pyx_n_s_updated_addrs -#define __pyx_n_s_v __pyx_mstate_global->__pyx_n_s_v -#define __pyx_n_s_values __pyx_mstate_global->__pyx_n_s_values -#define __pyx_n_s_zip __pyx_mstate_global->__pyx_n_s_zip -#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 -#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 -#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 -#define __pyx_slice__2 __pyx_mstate_global->__pyx_slice__2 -#define __pyx_slice__3 __pyx_mstate_global->__pyx_slice__3 -#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 -#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 -#define __pyx_tuple__9 __pyx_mstate_global->__pyx_tuple__9 -#define __pyx_tuple__11 __pyx_mstate_global->__pyx_tuple__11 -#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 -#define __pyx_codeobj__10 __pyx_mstate_global->__pyx_codeobj__10 -#define __pyx_codeobj__12 __pyx_mstate_global->__pyx_codeobj__12 -#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 -#define __pyx_codeobj__14 __pyx_mstate_global->__pyx_codeobj__14 -/* #### Code section: module_code ### */ - -/* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - -static std::string __pyx_convert_string_from_py_std__in_string(PyObject *__pyx_v_o) { - Py_ssize_t __pyx_v_length; - char const *__pyx_v_data; - std::string __pyx_r; - char const *__pyx_t_1; - std::string __pyx_t_2; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - - /* "string.from_py":14 - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 # <<<<<<<<<<<<<< - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) - */ - __pyx_v_length = 0; - - /* "string.from_py":15 - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) # <<<<<<<<<<<<<< - * return string(data, length) - * - */ - __pyx_t_1 = __Pyx_PyObject_AsStringAndSize(__pyx_v_o, (&__pyx_v_length)); if (unlikely(__pyx_t_1 == ((char const *)NULL))) __PYX_ERR(1, 15, __pyx_L1_error) - __pyx_v_data = __pyx_t_1; - - /* "string.from_py":16 - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - * return string(data, length) # <<<<<<<<<<<<<< - * - * - */ - try { - __pyx_t_2 = std::string(__pyx_v_data, __pyx_v_length); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(1, 16, __pyx_L1_error) - } - __pyx_r = __pyx_t_2; - goto __pyx_L0; - - /* "string.from_py":13 - * - * @cname("__pyx_convert_string_from_py_std__in_string") - * cdef string __pyx_convert_string_from_py_std__in_string(object o) except *: # <<<<<<<<<<<<<< - * cdef Py_ssize_t length = 0 - * cdef const char* data = __Pyx_PyObject_AsStringAndSize(o, &length) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("string.from_py.__pyx_convert_string_from_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - return __pyx_r; -} - -/* "string.to_py":31 - * - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyObject_string_to_py_std__in_string(std::string const &__pyx_v_s) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_PyObject_string_to_py_std__in_string", 1); - - /* "string.to_py":32 - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyUnicode_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyObject_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 32, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":31 - * - * @cname("__pyx_convert_PyObject_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyObject_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyObject_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyObject_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":37 - * - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyUnicode_string_to_py_std__in_string(std::string const &__pyx_v_s) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_PyUnicode_string_to_py_std__in_string", 1); - - /* "string.to_py":38 - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyStr_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyUnicode_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":37 - * - * @cname("__pyx_convert_PyUnicode_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyUnicode_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyUnicode_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyUnicode_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":43 - * - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyStr_string_to_py_std__in_string(std::string const &__pyx_v_s) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_PyStr_string_to_py_std__in_string", 1); - - /* "string.to_py":44 - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyBytes_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyStr_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":43 - * - * @cname("__pyx_convert_PyStr_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyStr_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyStr_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyStr_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":49 - * - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyBytes_string_to_py_std__in_string(std::string const &__pyx_v_s) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_PyBytes_string_to_py_std__in_string", 1); - - /* "string.to_py":50 - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * cdef extern from *: - * cdef object __Pyx_PyByteArray_FromStringAndSize(const char*, size_t) - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 50, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":49 - * - * @cname("__pyx_convert_PyBytes_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyBytes_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyBytes_FromStringAndSize(s.data(), s.size()) - * cdef extern from *: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyBytes_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "string.to_py":55 - * - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) - * - */ - -static CYTHON_INLINE PyObject *__pyx_convert_PyByteArray_string_to_py_std__in_string(std::string const &__pyx_v_s) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_PyByteArray_string_to_py_std__in_string", 1); - - /* "string.to_py":56 - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyByteArray_FromStringAndSize(__pyx_v_s.data(), __pyx_v_s.size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "string.to_py":55 - * - * @cname("__pyx_convert_PyByteArray_string_to_py_std__in_string") - * cdef inline object __pyx_convert_PyByteArray_string_to_py_std__in_string(const string& s): # <<<<<<<<<<<<<< - * return __Pyx_PyByteArray_FromStringAndSize(s.data(), s.size()) - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("string.to_py.__pyx_convert_PyByteArray_string_to_py_std__in_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "pair.from_py":177 - * - * @cname("__pyx_convert_pair_from_py_uint32_t__and_int") - * cdef pair[X,Y] __pyx_convert_pair_from_py_uint32_t__and_int(object o) except *: # <<<<<<<<<<<<<< - * x, y = o - * return pair[X,Y](x, y) - */ - -static std::pair __pyx_convert_pair_from_py_uint32_t__and_int(PyObject *__pyx_v_o) { - PyObject *__pyx_v_x = NULL; - PyObject *__pyx_v_y = NULL; - std::pair __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - PyObject *(*__pyx_t_4)(PyObject *); - uint32_t __pyx_t_5; - int __pyx_t_6; - std::pair __pyx_t_7; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_pair_from_py_uint32_t__and_int", 1); - - /* "pair.from_py":178 - * @cname("__pyx_convert_pair_from_py_uint32_t__and_int") - * cdef pair[X,Y] __pyx_convert_pair_from_py_uint32_t__and_int(object o) except *: - * x, y = o # <<<<<<<<<<<<<< - * return pair[X,Y](x, y) - * - */ - if ((likely(PyTuple_CheckExact(__pyx_v_o))) || (PyList_CheckExact(__pyx_v_o))) { - PyObject* sequence = __pyx_v_o; - Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); - if (unlikely(size != 2)) { - if (size > 2) __Pyx_RaiseTooManyValuesError(2); - else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); - __PYX_ERR(1, 178, __pyx_L1_error) - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - if (likely(PyTuple_CheckExact(sequence))) { - __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); - __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); - } else { - __pyx_t_1 = PyList_GET_ITEM(sequence, 0); - __pyx_t_2 = PyList_GET_ITEM(sequence, 1); - } - __Pyx_INCREF(__pyx_t_1); - __Pyx_INCREF(__pyx_t_2); - #else - __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - #endif - } else { - Py_ssize_t index = -1; - __pyx_t_3 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 178, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_t_4 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); - index = 0; __pyx_t_1 = __pyx_t_4(__pyx_t_3); if (unlikely(!__pyx_t_1)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_1); - index = 1; __pyx_t_2 = __pyx_t_4(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; - __Pyx_GOTREF(__pyx_t_2); - if (__Pyx_IternextUnpackEndCheck(__pyx_t_4(__pyx_t_3), 2) < 0) __PYX_ERR(1, 178, __pyx_L1_error) - __pyx_t_4 = NULL; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - goto __pyx_L4_unpacking_done; - __pyx_L3_unpacking_failed:; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = NULL; - if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); - __PYX_ERR(1, 178, __pyx_L1_error) - __pyx_L4_unpacking_done:; - } - __pyx_v_x = __pyx_t_1; - __pyx_t_1 = 0; - __pyx_v_y = __pyx_t_2; - __pyx_t_2 = 0; - - /* "pair.from_py":179 - * cdef pair[X,Y] __pyx_convert_pair_from_py_uint32_t__and_int(object o) except *: - * x, y = o - * return pair[X,Y](x, y) # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_5 = __Pyx_PyInt_As_uint32_t(__pyx_v_x); if (unlikely((__pyx_t_5 == ((uint32_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 179, __pyx_L1_error) - __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_y); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 179, __pyx_L1_error) - try { - __pyx_t_7 = std::pair (((uint32_t)__pyx_t_5), ((int)__pyx_t_6)); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(1, 179, __pyx_L1_error) - } - __pyx_r = __pyx_t_7; - goto __pyx_L0; - - /* "pair.from_py":177 - * - * @cname("__pyx_convert_pair_from_py_uint32_t__and_int") - * cdef pair[X,Y] __pyx_convert_pair_from_py_uint32_t__and_int(object o) except *: # <<<<<<<<<<<<<< - * x, y = o - * return pair[X,Y](x, y) - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - __Pyx_AddTraceback("pair.from_py.__pyx_convert_pair_from_py_uint32_t__and_int", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_x); - __Pyx_XDECREF(__pyx_v_y); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "vector.from_py":45 - * - * @cname("__pyx_convert_vector_from_py_std_3a__3a_string") - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: - */ - -static std::vector __pyx_convert_vector_from_py_std_3a__3a_string(PyObject *__pyx_v_o) { - std::vector __pyx_v_v; - PyObject *__pyx_v_item = NULL; - std::vector __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - PyObject *(*__pyx_t_3)(PyObject *); - PyObject *__pyx_t_4 = NULL; - std::string __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_std_3a__3a_string", 1); - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v - */ - if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) { - __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); - __pyx_t_2 = 0; - __pyx_t_3 = NULL; - } else { - __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_3 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 47, __pyx_L1_error) - } - for (;;) { - if (likely(!__pyx_t_3)) { - if (likely(PyList_CheckExact(__pyx_t_1))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 47, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 47, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 47, __pyx_L1_error) - #endif - if (__pyx_t_2 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely((0 < 0))) __PYX_ERR(1, 47, __pyx_L1_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_3(__pyx_t_1); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(1, 47, __pyx_L1_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4); - __pyx_t_4 = 0; - - /* "vector.from_py":48 - * cdef vector[X] v - * for item in o: - * v.push_back(item) # <<<<<<<<<<<<<< - * return v - * - */ - __pyx_t_5 = __pyx_convert_string_from_py_std__in_string(__pyx_v_item); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 48, __pyx_L1_error) - try { - __pyx_v_v.push_back(((std::string)__pyx_t_5)); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(1, 48, __pyx_L1_error) - } - - /* "vector.from_py":47 - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: - * cdef vector[X] v - * for item in o: # <<<<<<<<<<<<<< - * v.push_back(item) - * return v - */ - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "vector.from_py":49 - * for item in o: - * v.push_back(item) - * return v # <<<<<<<<<<<<<< - * - * - */ - __pyx_r = __pyx_v_v; - goto __pyx_L0; - - /* "vector.from_py":45 - * - * @cname("__pyx_convert_vector_from_py_std_3a__3a_string") - * cdef vector[X] __pyx_convert_vector_from_py_std_3a__3a_string(object o) except *: # <<<<<<<<<<<<<< - * cdef vector[X] v - * for item in o: - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_std_3a__3a_string", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_pretend_to_initialize(&__pyx_r); - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_item); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "vector.to_py":66 - * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v): # <<<<<<<<<<<<<< - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - */ - -static PyObject *__pyx_convert_vector_to_py_double(std::vector const &__pyx_v_v) { - Py_ssize_t __pyx_v_v_size_signed; - PyObject *__pyx_v_o = NULL; - Py_ssize_t __pyx_v_i; - PyObject *__pyx_v_item = 0; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_t_1; - PyObject *__pyx_t_2 = NULL; - Py_ssize_t __pyx_t_3; - Py_ssize_t __pyx_t_4; - Py_ssize_t __pyx_t_5; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_double", 1); - - /* "vector.to_py":67 - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< - * raise MemoryError() - * v_size_signed = v.size() - */ - __pyx_t_1 = (__pyx_v_v.size() > ((size_t)PY_SSIZE_T_MAX)); - if (unlikely(__pyx_t_1)) { - - /* "vector.to_py":68 - * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() # <<<<<<<<<<<<<< - * v_size_signed = v.size() - * - */ - PyErr_NoMemory(); __PYX_ERR(1, 68, __pyx_L1_error) - - /* "vector.to_py":67 - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v): - * if v.size() > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< - * raise MemoryError() - * v_size_signed = v.size() - */ - } - - /* "vector.to_py":69 - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - * v_size_signed = v.size() # <<<<<<<<<<<<<< - * - * o = PyList_New(v_size_signed) - */ - __pyx_v_v_size_signed = ((Py_ssize_t)__pyx_v_v.size()); - - /* "vector.to_py":71 - * v_size_signed = v.size() - * - * o = PyList_New(v_size_signed) # <<<<<<<<<<<<<< - * - * cdef Py_ssize_t i - */ - __pyx_t_2 = PyList_New(__pyx_v_v_size_signed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 71, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_v_o = ((PyObject*)__pyx_t_2); - __pyx_t_2 = 0; - - /* "vector.to_py":76 - * cdef object item - * - * for i in range(v_size_signed): # <<<<<<<<<<<<<< - * item = v[i] - * Py_INCREF(item) - */ - __pyx_t_3 = __pyx_v_v_size_signed; - __pyx_t_4 = __pyx_t_3; - for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { - __pyx_v_i = __pyx_t_5; - - /* "vector.to_py":77 - * - * for i in range(v_size_signed): - * item = v[i] # <<<<<<<<<<<<<< - * Py_INCREF(item) - * PyList_SET_ITEM(o, i, item) - */ - __pyx_t_2 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 77, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_2); - __pyx_t_2 = 0; - - /* "vector.to_py":78 - * for i in range(v_size_signed): - * item = v[i] - * Py_INCREF(item) # <<<<<<<<<<<<<< - * PyList_SET_ITEM(o, i, item) - * - */ - Py_INCREF(__pyx_v_item); - - /* "vector.to_py":79 - * item = v[i] - * Py_INCREF(item) - * PyList_SET_ITEM(o, i, item) # <<<<<<<<<<<<<< - * - * return o - */ - PyList_SET_ITEM(__pyx_v_o, __pyx_v_i, __pyx_v_item); - } - - /* "vector.to_py":81 - * PyList_SET_ITEM(o, i, item) - * - * return o # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_o); - __pyx_r = __pyx_v_o; - goto __pyx_L0; - - /* "vector.to_py":66 - * - * @cname("__pyx_convert_vector_to_py_double") - * cdef object __pyx_convert_vector_to_py_double(const vector[X]& v): # <<<<<<<<<<<<<< - * if v.size() > PY_SSIZE_T_MAX: - * raise MemoryError() - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_double", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_o); - __Pyx_XDECREF(__pyx_v_item); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "set.to_py":166 - * - * @cname("__pyx_convert_unordered_set_to_py_uint32_t") - * cdef object __pyx_convert_unordered_set_to_py_uint32_t(const cpp_set[X]& s): # <<<<<<<<<<<<<< - * return {v for v in s} - * - */ - -static PyObject *__pyx_convert_unordered_set_to_py_uint32_t(std::unordered_set const &__pyx_v_s) { - uint32_t __pyx_7genexpr__pyx_v_v; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - std::unordered_set ::const_iterator __pyx_t_2; - uint32_t __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_convert_unordered_set_to_py_uint32_t", 1); - - /* "set.to_py":167 - * @cname("__pyx_convert_unordered_set_to_py_uint32_t") - * cdef object __pyx_convert_unordered_set_to_py_uint32_t(const cpp_set[X]& s): - * return {v for v in s} # <<<<<<<<<<<<<< - * - */ - __Pyx_XDECREF(__pyx_r); - { /* enter inner scope */ - __pyx_t_1 = PySet_New(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = __pyx_v_s.begin(); - for (;;) { - if (!(__pyx_t_2 != __pyx_v_s.end())) break; - __pyx_t_3 = *__pyx_t_2; - ++__pyx_t_2; - __pyx_7genexpr__pyx_v_v = __pyx_t_3; - __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_7genexpr__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 167, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(PySet_Add(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(1, 167, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - } /* exit inner scope */ - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "set.to_py":166 - * - * @cname("__pyx_convert_unordered_set_to_py_uint32_t") - * cdef object __pyx_convert_unordered_set_to_py_uint32_t(const cpp_set[X]& s): # <<<<<<<<<<<<<< - * return {v for v in s} - * - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("set.to_py.__pyx_convert_unordered_set_to_py_uint32_t", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = 0; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":30 - * string dbc_name - * - * def __init__(self, dbc_name, messages, bus=0): # <<<<<<<<<<<<<< - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - */ - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_dbc_name = 0; - PyObject *__pyx_v_messages = 0; - PyObject *__pyx_v_bus = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[3] = {0,0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dbc_name,&__pyx_n_s_messages,&__pyx_n_s_bus,0}; - values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_int_0)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dbc_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_messages)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[1]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) - else { - __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 30, __pyx_L3_error) - } - CYTHON_FALLTHROUGH; - case 2: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_bus); - if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 30, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); - CYTHON_FALLTHROUGH; - case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_dbc_name = values[0]; - __pyx_v_messages = values[1]; - __pyx_v_bus = values[2]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 30, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser___init__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self), __pyx_v_dbc_name, __pyx_v_messages, __pyx_v_bus); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser___init__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, PyObject *__pyx_v_dbc_name, PyObject *__pyx_v_messages, PyObject *__pyx_v_bus) { - PyObject *__pyx_v_msg_name_to_address = NULL; - PyObject *__pyx_v_address_to_msg_name = NULL; - std::vector ::size_type __pyx_v_i; - struct Msg __pyx_v_msg; - PyObject *__pyx_v_name = NULL; - std::vector > __pyx_v_message_v; - PyObject *__pyx_v_c = NULL; - PyObject *__pyx_v_address = NULL; - int __pyx_r; - __Pyx_RefNannyDeclarations - std::string __pyx_t_1; - struct DBC const *__pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - std::vector ::size_type __pyx_t_6; - std::vector ::size_type __pyx_t_7; - std::vector ::size_type __pyx_t_8; - Py_ssize_t __pyx_t_9; - Py_ssize_t __pyx_t_10; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - Py_ssize_t __pyx_t_13; - Py_UCS4 __pyx_t_14; - std::pair __pyx_t_15; - int __pyx_t_16; - CANParser *__pyx_t_17; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); - - /* "opendbc/can/parser_pyx.pyx":31 - * - * def __init__(self, dbc_name, messages, bus=0): - * self.dbc_name = dbc_name # <<<<<<<<<<<<<< - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error) - __pyx_v_self->dbc_name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1); - - /* "opendbc/can/parser_pyx.pyx":32 - * def __init__(self, dbc_name, messages, bus=0): - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) # <<<<<<<<<<<<<< - * if not self.dbc: - * raise RuntimeError(f"Can't find DBC: {dbc_name}") - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L1_error) - try { - __pyx_t_2 = dbc_lookup(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1)); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 32, __pyx_L1_error) - } - __pyx_v_self->dbc = __pyx_t_2; - - /* "opendbc/can/parser_pyx.pyx":33 - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't find DBC: {dbc_name}") - * - */ - __pyx_t_3 = (!(__pyx_v_self->dbc != 0)); - if (unlikely(__pyx_t_3)) { - - /* "opendbc/can/parser_pyx.pyx":34 - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - * raise RuntimeError(f"Can't find DBC: {dbc_name}") # <<<<<<<<<<<<<< - * - * self.vl = {} - */ - __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_dbc_name, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_kp_u_Can_t_find_DBC, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 34, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 34, __pyx_L1_error) - - /* "opendbc/can/parser_pyx.pyx":33 - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't find DBC: {dbc_name}") - * - */ - } - - /* "opendbc/can/parser_pyx.pyx":36 - * raise RuntimeError(f"Can't find DBC: {dbc_name}") - * - * self.vl = {} # <<<<<<<<<<<<<< - * self.vl_all = {} - * self.ts_nanos = {} - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 36, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->vl); - __Pyx_DECREF(__pyx_v_self->vl); - __pyx_v_self->vl = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":37 - * - * self.vl = {} - * self.vl_all = {} # <<<<<<<<<<<<<< - * self.ts_nanos = {} - * msg_name_to_address = {} - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 37, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->vl_all); - __Pyx_DECREF(__pyx_v_self->vl_all); - __pyx_v_self->vl_all = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":38 - * self.vl = {} - * self.vl_all = {} - * self.ts_nanos = {} # <<<<<<<<<<<<<< - * msg_name_to_address = {} - * address_to_msg_name = {} - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 38, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_GIVEREF(__pyx_t_4); - __Pyx_GOTREF(__pyx_v_self->ts_nanos); - __Pyx_DECREF(__pyx_v_self->ts_nanos); - __pyx_v_self->ts_nanos = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":39 - * self.vl_all = {} - * self.ts_nanos = {} - * msg_name_to_address = {} # <<<<<<<<<<<<<< - * address_to_msg_name = {} - * - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 39, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_msg_name_to_address = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":40 - * self.ts_nanos = {} - * msg_name_to_address = {} - * address_to_msg_name = {} # <<<<<<<<<<<<<< - * - * for i in range(self.dbc[0].msgs.size()): - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 40, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_address_to_msg_name = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":42 - * address_to_msg_name = {} - * - * for i in range(self.dbc[0].msgs.size()): # <<<<<<<<<<<<<< - * msg = self.dbc[0].msgs[i] - * name = msg.name.decode("utf8") - */ - __pyx_t_6 = (__pyx_v_self->dbc[0]).msgs.size(); - __pyx_t_7 = __pyx_t_6; - for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { - __pyx_v_i = __pyx_t_8; - - /* "opendbc/can/parser_pyx.pyx":43 - * - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] # <<<<<<<<<<<<<< - * name = msg.name.decode("utf8") - * - */ - __pyx_v_msg = ((__pyx_v_self->dbc[0]).msgs[__pyx_v_i]); - - /* "opendbc/can/parser_pyx.pyx":44 - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] - * name = msg.name.decode("utf8") # <<<<<<<<<<<<<< - * - * msg_name_to_address[name] = msg.address - */ - __pyx_t_4 = __Pyx_decode_cpp_string(__pyx_v_msg.name, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 44, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":46 - * name = msg.name.decode("utf8") - * - * msg_name_to_address[name] = msg.address # <<<<<<<<<<<<<< - * address_to_msg_name[msg.address] = name - * - */ - __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_msg.address); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyDict_SetItem(__pyx_v_msg_name_to_address, __pyx_v_name, __pyx_t_4) < 0))) __PYX_ERR(0, 46, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":47 - * - * msg_name_to_address[name] = msg.address - * address_to_msg_name[msg.address] = name # <<<<<<<<<<<<<< - * - * # Convert message names into addresses and check existence in DBC - */ - __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_msg.address); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyDict_SetItem(__pyx_v_address_to_msg_name, __pyx_t_4, __pyx_v_name) < 0))) __PYX_ERR(0, 47, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - - /* "opendbc/can/parser_pyx.pyx":51 - * # Convert message names into addresses and check existence in DBC - * cdef vector[pair[uint32_t, int]] message_v - * for i in range(len(messages)): # <<<<<<<<<<<<<< - * c = messages[i] - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) - */ - __pyx_t_9 = PyObject_Length(__pyx_v_messages); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 51, __pyx_L1_error) - __pyx_t_10 = __pyx_t_9; - for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_10; __pyx_t_6+=1) { - __pyx_v_i = __pyx_t_6; - - /* "opendbc/can/parser_pyx.pyx":52 - * cdef vector[pair[uint32_t, int]] message_v - * for i in range(len(messages)): - * c = messages[i] # <<<<<<<<<<<<<< - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) - * if address not in address_to_msg_name: - */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_messages, __pyx_v_i, std::vector ::size_type, 0, __Pyx_PyInt_FromSize_t, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_c, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":53 - * for i in range(len(messages)): - * c = messages[i] - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) # <<<<<<<<<<<<<< - * if address not in address_to_msg_name: - * raise RuntimeError(f"could not find message {repr(c[0])} in DBC {self.dbc_name}") - */ - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_c, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_numbers); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_Number); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - __pyx_t_3 = PyObject_IsInstance(__pyx_t_5, __pyx_t_12); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - if (__pyx_t_3) { - __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_c, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __pyx_t_4 = __pyx_t_12; - __pyx_t_12 = 0; - } else { - __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_c, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __pyx_t_5 = __Pyx_PyDict_GetItemDefault(__pyx_v_msg_name_to_address, __pyx_t_12, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_4 = __pyx_t_5; - __pyx_t_5 = 0; - } - __Pyx_XDECREF_SET(__pyx_v_address, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":54 - * c = messages[i] - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) - * if address not in address_to_msg_name: # <<<<<<<<<<<<<< - * raise RuntimeError(f"could not find message {repr(c[0])} in DBC {self.dbc_name}") - * message_v.push_back((address, c[1])) - */ - __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_v_address, __pyx_v_address_to_msg_name, Py_NE)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 54, __pyx_L1_error) - if (unlikely(__pyx_t_3)) { - - /* "opendbc/can/parser_pyx.pyx":55 - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) - * if address not in address_to_msg_name: - * raise RuntimeError(f"could not find message {repr(c[0])} in DBC {self.dbc_name}") # <<<<<<<<<<<<<< - * message_v.push_back((address, c[1])) - * - */ - __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_13 = 0; - __pyx_t_14 = 127; - __Pyx_INCREF(__pyx_kp_u_could_not_find_message); - __pyx_t_13 += 23; - __Pyx_GIVEREF(__pyx_kp_u_could_not_find_message); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_could_not_find_message); - __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_c, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = PyObject_Repr(__pyx_t_5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_5 = __Pyx_PyObject_FormatSimple(__pyx_t_12, __pyx_empty_unicode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_14 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) > __pyx_t_14) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_5) : __pyx_t_14; - __pyx_t_13 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5); - __Pyx_GIVEREF(__pyx_t_5); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5); - __pyx_t_5 = 0; - __Pyx_INCREF(__pyx_kp_u_in_DBC); - __pyx_t_13 += 8; - __Pyx_GIVEREF(__pyx_kp_u_in_DBC); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_in_DBC); - __pyx_t_5 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->dbc_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_12 = __Pyx_PyObject_FormatSimple(__pyx_t_5, __pyx_empty_unicode); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - __pyx_t_14 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_12) > __pyx_t_14) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_12) : __pyx_t_14; - __pyx_t_13 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_12); - __Pyx_GIVEREF(__pyx_t_12); - PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_12); - __pyx_t_12 = 0; - __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_4, 4, __pyx_t_13, __pyx_t_14); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 55, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 55, __pyx_L1_error) - - /* "opendbc/can/parser_pyx.pyx":54 - * c = messages[i] - * address = c[0] if isinstance(c[0], numbers.Number) else msg_name_to_address.get(c[0]) - * if address not in address_to_msg_name: # <<<<<<<<<<<<<< - * raise RuntimeError(f"could not find message {repr(c[0])} in DBC {self.dbc_name}") - * message_v.push_back((address, c[1])) - */ - } - - /* "opendbc/can/parser_pyx.pyx":56 - * if address not in address_to_msg_name: - * raise RuntimeError(f"could not find message {repr(c[0])} in DBC {self.dbc_name}") - * message_v.push_back((address, c[1])) # <<<<<<<<<<<<<< - * - * name = address_to_msg_name[address] - */ - __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_c, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_INCREF(__pyx_v_address); - __Pyx_GIVEREF(__pyx_v_address); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_v_address)) __PYX_ERR(0, 56, __pyx_L1_error); - __Pyx_GIVEREF(__pyx_t_4); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_4)) __PYX_ERR(0, 56, __pyx_L1_error); - __pyx_t_4 = 0; - __pyx_t_15 = __pyx_convert_pair_from_py_uint32_t__and_int(__pyx_t_12); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 56, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - try { - __pyx_v_message_v.push_back(__pyx_t_15); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 56, __pyx_L1_error) - } - - /* "opendbc/can/parser_pyx.pyx":58 - * message_v.push_back((address, c[1])) - * - * name = address_to_msg_name[address] # <<<<<<<<<<<<<< - * self.vl[address] = {} - * self.vl[name] = self.vl[address] - */ - __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_address_to_msg_name, __pyx_v_address); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 58, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_12); - __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":59 - * - * name = address_to_msg_name[address] - * self.vl[address] = {} # <<<<<<<<<<<<<< - * self.vl[name] = self.vl[address] - * self.vl_all[address] = {} - */ - __pyx_t_12 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->vl == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 59, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->vl, __pyx_v_address, __pyx_t_12) < 0))) __PYX_ERR(0, 59, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":60 - * name = address_to_msg_name[address] - * self.vl[address] = {} - * self.vl[name] = self.vl[address] # <<<<<<<<<<<<<< - * self.vl_all[address] = {} - * self.vl_all[name] = self.vl_all[address] - */ - if (unlikely(__pyx_v_self->vl == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 60, __pyx_L1_error) - } - __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_self->vl, __pyx_v_address); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->vl == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 60, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->vl, __pyx_v_name, __pyx_t_12) < 0))) __PYX_ERR(0, 60, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":61 - * self.vl[address] = {} - * self.vl[name] = self.vl[address] - * self.vl_all[address] = {} # <<<<<<<<<<<<<< - * self.vl_all[name] = self.vl_all[address] - * self.ts_nanos[address] = {} - */ - __pyx_t_12 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->vl_all == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 61, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->vl_all, __pyx_v_address, __pyx_t_12) < 0))) __PYX_ERR(0, 61, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":62 - * self.vl[name] = self.vl[address] - * self.vl_all[address] = {} - * self.vl_all[name] = self.vl_all[address] # <<<<<<<<<<<<<< - * self.ts_nanos[address] = {} - * self.ts_nanos[name] = self.ts_nanos[address] - */ - if (unlikely(__pyx_v_self->vl_all == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 62, __pyx_L1_error) - } - __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_self->vl_all, __pyx_v_address); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->vl_all == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 62, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->vl_all, __pyx_v_name, __pyx_t_12) < 0))) __PYX_ERR(0, 62, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":63 - * self.vl_all[address] = {} - * self.vl_all[name] = self.vl_all[address] - * self.ts_nanos[address] = {} # <<<<<<<<<<<<<< - * self.ts_nanos[name] = self.ts_nanos[address] - * - */ - __pyx_t_12 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->ts_nanos == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 63, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->ts_nanos, __pyx_v_address, __pyx_t_12) < 0))) __PYX_ERR(0, 63, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":64 - * self.vl_all[name] = self.vl_all[address] - * self.ts_nanos[address] = {} - * self.ts_nanos[name] = self.ts_nanos[address] # <<<<<<<<<<<<<< - * - * self.can = new cpp_CANParser(bus, dbc_name, message_v) - */ - if (unlikely(__pyx_v_self->ts_nanos == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 64, __pyx_L1_error) - } - __pyx_t_12 = __Pyx_PyDict_GetItem(__pyx_v_self->ts_nanos, __pyx_v_address); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely(__pyx_v_self->ts_nanos == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 64, __pyx_L1_error) - } - if (unlikely((PyDict_SetItem(__pyx_v_self->ts_nanos, __pyx_v_name, __pyx_t_12) < 0))) __PYX_ERR(0, 64, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - } - - /* "opendbc/can/parser_pyx.pyx":66 - * self.ts_nanos[name] = self.ts_nanos[address] - * - * self.can = new cpp_CANParser(bus, dbc_name, message_v) # <<<<<<<<<<<<<< - * self.update_strings([]) - * - */ - __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_v_bus); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L1_error) - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L1_error) - try { - __pyx_t_17 = new CANParser(__pyx_t_16, __pyx_t_1, __pyx_v_message_v); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 66, __pyx_L1_error) - } - __pyx_v_self->can = __pyx_t_17; - - /* "opendbc/can/parser_pyx.pyx":67 - * - * self.can = new cpp_CANParser(bus, dbc_name, message_v) - * self.update_strings([]) # <<<<<<<<<<<<<< - * - * def __dealloc__(self): - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_update_strings); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_t_11 = NULL; - __pyx_t_16 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_11)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_11); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_16 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_5}; - __pyx_t_12 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_16, 1+__pyx_t_16); - __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 67, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":30 - * string dbc_name - * - * def __init__(self, dbc_name, messages, bus=0): # <<<<<<<<<<<<<< - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_12); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_msg_name_to_address); - __Pyx_XDECREF(__pyx_v_address_to_msg_name); - __Pyx_XDECREF(__pyx_v_name); - __Pyx_XDECREF(__pyx_v_c); - __Pyx_XDECREF(__pyx_v_address); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":69 - * self.update_strings([]) - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self.can: - * del self.can - */ - -/* Python wrapper */ -static void __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ -static void __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_3__dealloc__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2__dealloc__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); -} - -static void __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2__dealloc__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - int __pyx_t_1; - - /* "opendbc/can/parser_pyx.pyx":70 - * - * def __dealloc__(self): - * if self.can: # <<<<<<<<<<<<<< - * del self.can - * - */ - __pyx_t_1 = (__pyx_v_self->can != 0); - if (__pyx_t_1) { - - /* "opendbc/can/parser_pyx.pyx":71 - * def __dealloc__(self): - * if self.can: - * del self.can # <<<<<<<<<<<<<< - * - * def update_strings(self, strings, sendcan=False): - */ - delete __pyx_v_self->can; - - /* "opendbc/can/parser_pyx.pyx":70 - * - * def __dealloc__(self): - * if self.can: # <<<<<<<<<<<<<< - * del self.can - * - */ - } - - /* "opendbc/can/parser_pyx.pyx":69 - * self.update_strings([]) - * - * def __dealloc__(self): # <<<<<<<<<<<<<< - * if self.can: - * del self.can - */ - - /* function exit code */ -} - -/* "opendbc/can/parser_pyx.pyx":73 - * del self.can - * - * def update_strings(self, strings, sendcan=False): # <<<<<<<<<<<<<< - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_5update_strings(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_5update_strings = {"update_strings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_5update_strings, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_5update_strings(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - PyObject *__pyx_v_strings = 0; - PyObject *__pyx_v_sendcan = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[2] = {0,0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("update_strings (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_strings,&__pyx_n_s_sendcan,0}; - values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_False)); - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_strings)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - CYTHON_FALLTHROUGH; - case 1: - if (kw_args > 0) { - PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sendcan); - if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L3_error) - } - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "update_strings") < 0)) __PYX_ERR(0, 73, __pyx_L3_error) - } - } else { - switch (__pyx_nargs) { - case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); - CYTHON_FALLTHROUGH; - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - break; - default: goto __pyx_L5_argtuple_error; - } - } - __pyx_v_strings = values[0]; - __pyx_v_sendcan = values[1]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("update_strings", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 73, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.update_strings", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_4update_strings(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self), __pyx_v_strings, __pyx_v_sendcan); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_4update_strings(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, PyObject *__pyx_v_strings, PyObject *__pyx_v_sendcan) { - PyObject *__pyx_v_v = NULL; - PyObject *__pyx_v_l = NULL; - std::vector __pyx_v_new_vals; - std::unordered_set __pyx_v_updated_addrs; - std::vector ::iterator __pyx_v_it; - struct SignalValue *__pyx_v_cv; - PyObject *__pyx_v_cv_name = NULL; - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - Py_ssize_t __pyx_t_2; - Py_ssize_t __pyx_t_3; - int __pyx_t_4; - PyObject *__pyx_t_5 = NULL; - int __pyx_t_6; - Py_ssize_t __pyx_t_7; - Py_ssize_t __pyx_t_8; - PyObject *__pyx_t_9 = NULL; - int __pyx_t_10; - PyObject *__pyx_t_11 = NULL; - PyObject *__pyx_t_12 = NULL; - std::vector __pyx_t_13; - bool __pyx_t_14; - int __pyx_t_15; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("update_strings", 1); - - /* "opendbc/can/parser_pyx.pyx":74 - * - * def update_strings(self, strings, sendcan=False): - * for v in self.vl_all.values(): # <<<<<<<<<<<<<< - * for l in v.values(): # no-cython-lint - * l.clear() - */ - __pyx_t_2 = 0; - if (unlikely(__pyx_v_self->vl_all == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(0, 74, __pyx_L1_error) - } - __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_self->vl_all, 1, __pyx_n_s_values, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_1); - __pyx_t_1 = __pyx_t_5; - __pyx_t_5 = 0; - while (1) { - __pyx_t_6 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, NULL, &__pyx_t_5, NULL, __pyx_t_4); - if (unlikely(__pyx_t_6 == 0)) break; - if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 74, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_5); - __pyx_t_5 = 0; - - /* "opendbc/can/parser_pyx.pyx":75 - * def update_strings(self, strings, sendcan=False): - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint # <<<<<<<<<<<<<< - * l.clear() - * - */ - __pyx_t_7 = 0; - if (unlikely(__pyx_v_v == Py_None)) { - PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "values"); - __PYX_ERR(0, 75, __pyx_L1_error) - } - __pyx_t_9 = __Pyx_dict_iterator(__pyx_v_v, 0, __pyx_n_s_values, (&__pyx_t_8), (&__pyx_t_6)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_5); - __pyx_t_5 = __pyx_t_9; - __pyx_t_9 = 0; - while (1) { - __pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_8, &__pyx_t_7, NULL, &__pyx_t_9, NULL, __pyx_t_6); - if (unlikely(__pyx_t_10 == 0)) break; - if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 75, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_9); - __pyx_t_9 = 0; - - /* "opendbc/can/parser_pyx.pyx":76 - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint - * l.clear() # <<<<<<<<<<<<<< - * - * cdef vector[SignalValue] new_vals - */ - __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_l, __pyx_n_s_clear); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_11); - __pyx_t_12 = NULL; - __pyx_t_10 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_11))) { - __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); - if (likely(__pyx_t_12)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_11, function); - __pyx_t_10 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; - __pyx_t_9 = __Pyx_PyObject_FastCall(__pyx_t_11, __pyx_callargs+1-__pyx_t_10, 0+__pyx_t_10); - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 76, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; - } - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - } - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - } - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - - /* "opendbc/can/parser_pyx.pyx":81 - * cdef unordered_set[uint32_t] updated_addrs - * - * self.can.update_strings(strings, new_vals, sendcan) # <<<<<<<<<<<<<< - * cdef vector[SignalValue].iterator it = new_vals.begin() - * cdef SignalValue* cv - */ - __pyx_t_13 = __pyx_convert_vector_from_py_std_3a__3a_string(__pyx_v_strings); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L1_error) - __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_sendcan); if (unlikely((__pyx_t_14 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L1_error) - try { - __pyx_v_self->can->update_strings(__pyx_t_13, __pyx_v_new_vals, __pyx_t_14); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 81, __pyx_L1_error) - } - - /* "opendbc/can/parser_pyx.pyx":82 - * - * self.can.update_strings(strings, new_vals, sendcan) - * cdef vector[SignalValue].iterator it = new_vals.begin() # <<<<<<<<<<<<<< - * cdef SignalValue* cv - * while it != new_vals.end(): - */ - __pyx_v_it = __pyx_v_new_vals.begin(); - - /* "opendbc/can/parser_pyx.pyx":84 - * cdef vector[SignalValue].iterator it = new_vals.begin() - * cdef SignalValue* cv - * while it != new_vals.end(): # <<<<<<<<<<<<<< - * cv = &deref(it) - * # Cast char * directly to unicode - */ - while (1) { - __pyx_t_15 = (__pyx_v_it != __pyx_v_new_vals.end()); - if (!__pyx_t_15) break; - - /* "opendbc/can/parser_pyx.pyx":85 - * cdef SignalValue* cv - * while it != new_vals.end(): - * cv = &deref(it) # <<<<<<<<<<<<<< - * # Cast char * directly to unicode - * cv_name = cv.name - */ - __pyx_v_cv = (&(*__pyx_v_it)); - - /* "opendbc/can/parser_pyx.pyx":87 - * cv = &deref(it) - * # Cast char * directly to unicode - * cv_name = cv.name # <<<<<<<<<<<<<< - * self.vl[cv.address][cv_name] = cv.value - * self.vl_all[cv.address][cv_name] = cv.all_values - */ - __pyx_t_1 = __pyx_convert_PyUnicode_string_to_py_std__in_string(__pyx_v_cv->name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __pyx_t_1; - __Pyx_INCREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_XDECREF_SET(__pyx_v_cv_name, ((PyObject*)__pyx_t_5)); - __pyx_t_5 = 0; - - /* "opendbc/can/parser_pyx.pyx":88 - * # Cast char * directly to unicode - * cv_name = cv.name - * self.vl[cv.address][cv_name] = cv.value # <<<<<<<<<<<<<< - * self.vl_all[cv.address][cv_name] = cv.all_values - * self.ts_nanos[cv.address][cv_name] = cv.ts_nanos - */ - __pyx_t_5 = PyFloat_FromDouble(__pyx_v_cv->value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__pyx_v_self->vl == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 88, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_cv->address); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyDict_GetItem(__pyx_v_self->vl, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_cv_name, __pyx_t_5) < 0))) __PYX_ERR(0, 88, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "opendbc/can/parser_pyx.pyx":89 - * cv_name = cv.name - * self.vl[cv.address][cv_name] = cv.value - * self.vl_all[cv.address][cv_name] = cv.all_values # <<<<<<<<<<<<<< - * self.ts_nanos[cv.address][cv_name] = cv.ts_nanos - * updated_addrs.insert(cv.address) - */ - __pyx_t_5 = __pyx_convert_vector_to_py_double(__pyx_v_cv->all_values); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__pyx_v_self->vl_all == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 89, __pyx_L1_error) - } - __pyx_t_9 = __Pyx_PyInt_From_uint32_t(__pyx_v_cv->address); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->vl_all, __pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_cv_name, __pyx_t_5) < 0))) __PYX_ERR(0, 89, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "opendbc/can/parser_pyx.pyx":90 - * self.vl[cv.address][cv_name] = cv.value - * self.vl_all[cv.address][cv_name] = cv.all_values - * self.ts_nanos[cv.address][cv_name] = cv.ts_nanos # <<<<<<<<<<<<<< - * updated_addrs.insert(cv.address) - * preinc(it) - */ - __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_cv->ts_nanos); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - if (unlikely(__pyx_v_self->ts_nanos == Py_None)) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); - __PYX_ERR(0, 90, __pyx_L1_error) - } - __pyx_t_1 = __Pyx_PyInt_From_uint32_t(__pyx_v_cv->address); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_PyDict_GetItem(__pyx_v_self->ts_nanos, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely((PyObject_SetItem(__pyx_t_9, __pyx_v_cv_name, __pyx_t_5) < 0))) __PYX_ERR(0, 90, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; - - /* "opendbc/can/parser_pyx.pyx":91 - * self.vl_all[cv.address][cv_name] = cv.all_values - * self.ts_nanos[cv.address][cv_name] = cv.ts_nanos - * updated_addrs.insert(cv.address) # <<<<<<<<<<<<<< - * preinc(it) - * - */ - try { - __pyx_v_updated_addrs.insert(__pyx_v_cv->address); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 91, __pyx_L1_error) - } - - /* "opendbc/can/parser_pyx.pyx":92 - * self.ts_nanos[cv.address][cv_name] = cv.ts_nanos - * updated_addrs.insert(cv.address) - * preinc(it) # <<<<<<<<<<<<<< - * - * return updated_addrs - */ - (void)((++__pyx_v_it)); - } - - /* "opendbc/can/parser_pyx.pyx":94 - * preinc(it) - * - * return updated_addrs # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_5 = __pyx_convert_unordered_set_to_py_uint32_t(__pyx_v_updated_addrs); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __pyx_r = __pyx_t_5; - __pyx_t_5 = 0; - goto __pyx_L0; - - /* "opendbc/can/parser_pyx.pyx":73 - * del self.can - * - * def update_strings(self, strings, sendcan=False): # <<<<<<<<<<<<<< - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_9); - __Pyx_XDECREF(__pyx_t_11); - __Pyx_XDECREF(__pyx_t_12); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.update_strings", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_v); - __Pyx_XDECREF(__pyx_v_l); - __Pyx_XDECREF(__pyx_v_cv_name); - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":96 - * return updated_addrs - * - * @property # <<<<<<<<<<<<<< - * def can_valid(self): - * return self.can.can_valid - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9can_valid_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9can_valid_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_9can_valid___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_9can_valid___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - - /* "opendbc/can/parser_pyx.pyx":98 - * @property - * def can_valid(self): - * return self.can.can_valid # <<<<<<<<<<<<<< - * - * @property - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can->can_valid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 98, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "opendbc/can/parser_pyx.pyx":96 - * return updated_addrs - * - * @property # <<<<<<<<<<<<<< - * def can_valid(self): - * return self.can.can_valid - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.can_valid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":100 - * return self.can.can_valid - * - * @property # <<<<<<<<<<<<<< - * def bus_timeout(self): - * return self.can.bus_timeout - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - - /* "opendbc/can/parser_pyx.pyx":102 - * @property - * def bus_timeout(self): - * return self.can.bus_timeout # <<<<<<<<<<<<<< - * - * - */ - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can->bus_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* "opendbc/can/parser_pyx.pyx":100 - * return self.can.can_valid - * - * @property # <<<<<<<<<<<<<< - * def bus_timeout(self): - * return self.can.bus_timeout - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.bus_timeout.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":25 - * - * cdef readonly: - * dict vl # <<<<<<<<<<<<<< - * dict vl_all - * dict ts_nanos - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_2vl_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_2vl_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2vl___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_2vl___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->vl); - __pyx_r = __pyx_v_self->vl; - goto __pyx_L0; - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":26 - * cdef readonly: - * dict vl - * dict vl_all # <<<<<<<<<<<<<< - * dict ts_nanos - * string dbc_name - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_6vl_all_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_6vl_all_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6vl_all___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6vl_all___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->vl_all); - __pyx_r = __pyx_v_self->vl_all; - goto __pyx_L0; - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":27 - * dict vl - * dict vl_all - * dict ts_nanos # <<<<<<<<<<<<<< - * string dbc_name - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->ts_nanos); - __pyx_r = __pyx_v_self->ts_nanos; - goto __pyx_L0; - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":28 - * dict vl_all - * dict ts_nanos - * string dbc_name # <<<<<<<<<<<<<< - * - * def __init__(self, dbc_name, messages, bus=0): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->dbc_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.dbc_name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6__reduce_cython__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_can_self_dbc_cannot_be_conv, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8__setstate_cython__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANParser_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":4 - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_can_self_dbc_cannot_be_conv, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANParser.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":113 - * string dbc_name - * - * def __init__(self, dbc_name): # <<<<<<<<<<<<<< - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - */ - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_dbc_name = 0; - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; - #endif - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dbc_name,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dbc_name)) != 0)) { - (void)__Pyx_Arg_NewRef_VARARGS(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 113, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); - } - __pyx_v_dbc_name = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 113, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return -1; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine___init__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self), __pyx_v_dbc_name); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine___init__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_dbc_name) { - PyObject *__pyx_v_address_to_msg_name = NULL; - std::vector ::size_type __pyx_v_i; - struct Msg __pyx_v_msg; - PyObject *__pyx_v_name = NULL; - uint32_t __pyx_v_address; - PyObject *__pyx_v_dv = NULL; - struct Val __pyx_v_val; - PyObject *__pyx_v_sgname = NULL; - PyObject *__pyx_v_def_val = NULL; - PyObject *__pyx_v_msgname = NULL; - PyObject *__pyx_v_values = NULL; - PyObject *__pyx_v_defs = NULL; - PyObject *__pyx_7genexpr__pyx_v_v = NULL; - int __pyx_r; - __Pyx_RefNannyDeclarations - std::string __pyx_t_1; - struct DBC const *__pyx_t_2; - int __pyx_t_3; - PyObject *__pyx_t_4 = NULL; - Py_ssize_t __pyx_t_5; - Py_UCS4 __pyx_t_6; - PyObject *__pyx_t_7 = NULL; - std::vector ::size_type __pyx_t_8; - std::vector ::size_type __pyx_t_9; - std::vector ::size_type __pyx_t_10; - uint32_t __pyx_t_11; - PyObject *__pyx_t_12 = NULL; - int __pyx_t_13; - std::vector ::size_type __pyx_t_14; - std::vector ::size_type __pyx_t_15; - PyObject *(*__pyx_t_16)(PyObject *); - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 1); - - /* "opendbc/can/parser_pyx.pyx":114 - * - * def __init__(self, dbc_name): - * self.dbc_name = dbc_name # <<<<<<<<<<<<<< - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 114, __pyx_L1_error) - __pyx_v_self->dbc_name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1); - - /* "opendbc/can/parser_pyx.pyx":115 - * def __init__(self, dbc_name): - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) # <<<<<<<<<<<<<< - * if not self.dbc: - * raise RuntimeError(f"Can't find DBC: '{dbc_name}'") - */ - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_dbc_name); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L1_error) - try { - __pyx_t_2 = dbc_lookup(__PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1)); - } catch(...) { - __Pyx_CppExn2PyErr(); - __PYX_ERR(0, 115, __pyx_L1_error) - } - __pyx_v_self->dbc = __pyx_t_2; - - /* "opendbc/can/parser_pyx.pyx":116 - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't find DBC: '{dbc_name}'") - * - */ - __pyx_t_3 = (!(__pyx_v_self->dbc != 0)); - if (unlikely(__pyx_t_3)) { - - /* "opendbc/can/parser_pyx.pyx":117 - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: - * raise RuntimeError(f"Can't find DBC: '{dbc_name}'") # <<<<<<<<<<<<<< - * - * address_to_msg_name = {} - */ - __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_5 = 0; - __pyx_t_6 = 127; - __Pyx_INCREF(__pyx_kp_u_Can_t_find_DBC_2); - __pyx_t_5 += 17; - __Pyx_GIVEREF(__pyx_kp_u_Can_t_find_DBC_2); - PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_Can_t_find_DBC_2); - __pyx_t_7 = __Pyx_PyObject_FormatSimple(__pyx_v_dbc_name, __pyx_empty_unicode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_6 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) > __pyx_t_6) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_7) : __pyx_t_6; - __pyx_t_5 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_7); - __Pyx_GIVEREF(__pyx_t_7); - PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7); - __pyx_t_7 = 0; - __Pyx_INCREF(__pyx_kp_u_); - __pyx_t_5 += 1; - __Pyx_GIVEREF(__pyx_kp_u_); - PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_kp_u_); - __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, __pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 117, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __PYX_ERR(0, 117, __pyx_L1_error) - - /* "opendbc/can/parser_pyx.pyx":116 - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - * if not self.dbc: # <<<<<<<<<<<<<< - * raise RuntimeError(f"Can't find DBC: '{dbc_name}'") - * - */ - } - - /* "opendbc/can/parser_pyx.pyx":119 - * raise RuntimeError(f"Can't find DBC: '{dbc_name}'") - * - * address_to_msg_name = {} # <<<<<<<<<<<<<< - * - * for i in range(self.dbc[0].msgs.size()): - */ - __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 119, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_v_address_to_msg_name = ((PyObject*)__pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":121 - * address_to_msg_name = {} - * - * for i in range(self.dbc[0].msgs.size()): # <<<<<<<<<<<<<< - * msg = self.dbc[0].msgs[i] - * name = msg.name.decode("utf8") - */ - __pyx_t_8 = (__pyx_v_self->dbc[0]).msgs.size(); - __pyx_t_9 = __pyx_t_8; - for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) { - __pyx_v_i = __pyx_t_10; - - /* "opendbc/can/parser_pyx.pyx":122 - * - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] # <<<<<<<<<<<<<< - * name = msg.name.decode("utf8") - * address = msg.address - */ - __pyx_v_msg = ((__pyx_v_self->dbc[0]).msgs[__pyx_v_i]); - - /* "opendbc/can/parser_pyx.pyx":123 - * for i in range(self.dbc[0].msgs.size()): - * msg = self.dbc[0].msgs[i] - * name = msg.name.decode("utf8") # <<<<<<<<<<<<<< - * address = msg.address - * address_to_msg_name[address] = name - */ - __pyx_t_4 = __Pyx_decode_cpp_string(__pyx_v_msg.name, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 123, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":124 - * msg = self.dbc[0].msgs[i] - * name = msg.name.decode("utf8") - * address = msg.address # <<<<<<<<<<<<<< - * address_to_msg_name[address] = name - * - */ - __pyx_t_11 = __pyx_v_msg.address; - __pyx_v_address = __pyx_t_11; - - /* "opendbc/can/parser_pyx.pyx":125 - * name = msg.name.decode("utf8") - * address = msg.address - * address_to_msg_name[address] = name # <<<<<<<<<<<<<< - * - * dv = defaultdict(dict) - */ - __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_address); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely((PyDict_SetItem(__pyx_v_address_to_msg_name, __pyx_t_4, __pyx_v_name) < 0))) __PYX_ERR(0, 125, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - - /* "opendbc/can/parser_pyx.pyx":127 - * address_to_msg_name[address] = name - * - * dv = defaultdict(dict) # <<<<<<<<<<<<<< - * - * for i in range(self.dbc[0].vals.size()): - */ - __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_defaultdict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_12 = NULL; - __pyx_t_13 = 0; - #if CYTHON_UNPACK_METHODS - if (unlikely(PyMethod_Check(__pyx_t_7))) { - __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_7); - if (likely(__pyx_t_12)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_7, function); - __pyx_t_13 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_12, ((PyObject *)(&PyDict_Type))}; - __pyx_t_4 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_13, 1+__pyx_t_13); - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 127, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - } - __pyx_v_dv = __pyx_t_4; - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":129 - * dv = defaultdict(dict) - * - * for i in range(self.dbc[0].vals.size()): # <<<<<<<<<<<<<< - * val = self.dbc[0].vals[i] - * - */ - __pyx_t_10 = (__pyx_v_self->dbc[0]).vals.size(); - __pyx_t_14 = __pyx_t_10; - for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { - __pyx_v_i = __pyx_t_15; - - /* "opendbc/can/parser_pyx.pyx":130 - * - * for i in range(self.dbc[0].vals.size()): - * val = self.dbc[0].vals[i] # <<<<<<<<<<<<<< - * - * sgname = val.name.decode("utf8") - */ - __pyx_v_val = ((__pyx_v_self->dbc[0]).vals[__pyx_v_i]); - - /* "opendbc/can/parser_pyx.pyx":132 - * val = self.dbc[0].vals[i] - * - * sgname = val.name.decode("utf8") # <<<<<<<<<<<<<< - * def_val = val.def_val.decode("utf8") - * address = val.address - */ - __pyx_t_4 = __Pyx_decode_cpp_string(__pyx_v_val.name, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 132, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_sgname, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":133 - * - * sgname = val.name.decode("utf8") - * def_val = val.def_val.decode("utf8") # <<<<<<<<<<<<<< - * address = val.address - * msgname = address_to_msg_name[address] - */ - __pyx_t_4 = __Pyx_decode_cpp_string(__pyx_v_val.def_val, 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 133, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_XDECREF_SET(__pyx_v_def_val, __pyx_t_4); - __pyx_t_4 = 0; - - /* "opendbc/can/parser_pyx.pyx":134 - * sgname = val.name.decode("utf8") - * def_val = val.def_val.decode("utf8") - * address = val.address # <<<<<<<<<<<<<< - * msgname = address_to_msg_name[address] - * - */ - __pyx_t_11 = __pyx_v_val.address; - __pyx_v_address = __pyx_t_11; - - /* "opendbc/can/parser_pyx.pyx":135 - * def_val = val.def_val.decode("utf8") - * address = val.address - * msgname = address_to_msg_name[address] # <<<<<<<<<<<<<< - * - * # separate definition/value pairs - */ - __pyx_t_4 = __Pyx_PyInt_From_uint32_t(__pyx_v_address); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_address_to_msg_name, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 135, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_XDECREF_SET(__pyx_v_msgname, __pyx_t_7); - __pyx_t_7 = 0; - - /* "opendbc/can/parser_pyx.pyx":138 - * - * # separate definition/value pairs - * def_val = def_val.split() # <<<<<<<<<<<<<< - * values = [int(v) for v in def_val[::2]] - * defs = def_val[1::2] - */ - __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_def_val, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __pyx_t_12 = NULL; - __pyx_t_13 = 0; - #if CYTHON_UNPACK_METHODS - if (likely(PyMethod_Check(__pyx_t_4))) { - __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); - if (likely(__pyx_t_12)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); - __Pyx_INCREF(__pyx_t_12); - __Pyx_INCREF(function); - __Pyx_DECREF_SET(__pyx_t_4, function); - __pyx_t_13 = 1; - } - } - #endif - { - PyObject *__pyx_callargs[2] = {__pyx_t_12, NULL}; - __pyx_t_7 = __Pyx_PyObject_FastCall(__pyx_t_4, __pyx_callargs+1-__pyx_t_13, 0+__pyx_t_13); - __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; - if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 138, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __Pyx_DECREF_SET(__pyx_v_def_val, __pyx_t_7); - __pyx_t_7 = 0; - - /* "opendbc/can/parser_pyx.pyx":139 - * # separate definition/value pairs - * def_val = def_val.split() - * values = [int(v) for v in def_val[::2]] # <<<<<<<<<<<<<< - * defs = def_val[1::2] - * - */ - { /* enter inner scope */ - __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_def_val, __pyx_slice__2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_4); - if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { - __pyx_t_12 = __pyx_t_4; __Pyx_INCREF(__pyx_t_12); - __pyx_t_5 = 0; - __pyx_t_16 = NULL; - } else { - __pyx_t_5 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_12); - __pyx_t_16 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_12); if (unlikely(!__pyx_t_16)) __PYX_ERR(0, 139, __pyx_L10_error) - } - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - for (;;) { - if (likely(!__pyx_t_16)) { - if (likely(PyList_CheckExact(__pyx_t_12))) { - { - Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_12); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 139, __pyx_L10_error) - #endif - if (__pyx_t_5 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyList_GET_ITEM(__pyx_t_12, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 139, __pyx_L10_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_12, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } else { - { - Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_12); - #if !CYTHON_ASSUME_SAFE_MACROS - if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 139, __pyx_L10_error) - #endif - if (__pyx_t_5 >= __pyx_temp) break; - } - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely((0 < 0))) __PYX_ERR(0, 139, __pyx_L10_error) - #else - __pyx_t_4 = __Pyx_PySequence_ITEM(__pyx_t_12, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_4); - #endif - } - } else { - __pyx_t_4 = __pyx_t_16(__pyx_t_12); - if (unlikely(!__pyx_t_4)) { - PyObject* exc_type = PyErr_Occurred(); - if (exc_type) { - if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); - else __PYX_ERR(0, 139, __pyx_L10_error) - } - break; - } - __Pyx_GOTREF(__pyx_t_4); - } - __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_v, __pyx_t_4); - __pyx_t_4 = 0; - __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_7genexpr__pyx_v_v); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_GOTREF(__pyx_t_4); - if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 139, __pyx_L10_error) - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - } - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v); __pyx_7genexpr__pyx_v_v = 0; - goto __pyx_L14_exit_scope; - __pyx_L10_error:; - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v); __pyx_7genexpr__pyx_v_v = 0; - goto __pyx_L1_error; - __pyx_L14_exit_scope:; - } /* exit inner scope */ - __Pyx_XDECREF_SET(__pyx_v_values, ((PyObject*)__pyx_t_7)); - __pyx_t_7 = 0; - - /* "opendbc/can/parser_pyx.pyx":140 - * def_val = def_val.split() - * values = [int(v) for v in def_val[::2]] - * defs = def_val[1::2] # <<<<<<<<<<<<<< - * - * # two ways to lookup: address or msg name - */ - __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_def_val, __pyx_slice__3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_XDECREF_SET(__pyx_v_defs, __pyx_t_7); - __pyx_t_7 = 0; - - /* "opendbc/can/parser_pyx.pyx":143 - * - * # two ways to lookup: address or msg name - * dv[address][sgname] = dict(zip(values, defs)) # <<<<<<<<<<<<<< - * dv[msgname][sgname] = dv[address][sgname] - * - */ - __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_INCREF(__pyx_v_values); - __Pyx_GIVEREF(__pyx_v_values); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_values)) __PYX_ERR(0, 143, __pyx_L1_error); - __Pyx_INCREF(__pyx_v_defs); - __Pyx_GIVEREF(__pyx_v_defs); - if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_defs)) __PYX_ERR(0, 143, __pyx_L1_error); - __pyx_t_12 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_7, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __pyx_t_12 = __Pyx_GetItemInt(__pyx_v_dv, __pyx_v_address, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - if (unlikely((PyObject_SetItem(__pyx_t_12, __pyx_v_sgname, __pyx_t_7) < 0))) __PYX_ERR(0, 143, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - - /* "opendbc/can/parser_pyx.pyx":144 - * # two ways to lookup: address or msg name - * dv[address][sgname] = dict(zip(values, defs)) - * dv[msgname][sgname] = dv[address][sgname] # <<<<<<<<<<<<<< - * - * self.dv = dict(dv) - */ - __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_dv, __pyx_v_address, uint32_t, 0, __Pyx_PyInt_From_uint32_t, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __pyx_t_12 = __Pyx_PyObject_GetItem(__pyx_t_7, __pyx_v_sgname); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_dv, __pyx_v_msgname); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (unlikely((PyObject_SetItem(__pyx_t_7, __pyx_v_sgname, __pyx_t_12) < 0))) __PYX_ERR(0, 144, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; - } - - /* "opendbc/can/parser_pyx.pyx":146 - * dv[msgname][sgname] = dv[address][sgname] - * - * self.dv = dict(dv) # <<<<<<<<<<<<<< - */ - __pyx_t_12 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyDict_Type)), __pyx_v_dv); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 146, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_12); - __Pyx_GIVEREF(__pyx_t_12); - __Pyx_GOTREF(__pyx_v_self->dv); - __Pyx_DECREF(__pyx_v_self->dv); - __pyx_v_self->dv = ((PyObject*)__pyx_t_12); - __pyx_t_12 = 0; - - /* "opendbc/can/parser_pyx.pyx":113 - * string dbc_name - * - * def __init__(self, dbc_name): # <<<<<<<<<<<<<< - * self.dbc_name = dbc_name - * self.dbc = dbc_lookup(dbc_name) - */ - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_12); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_XDECREF(__pyx_v_address_to_msg_name); - __Pyx_XDECREF(__pyx_v_name); - __Pyx_XDECREF(__pyx_v_dv); - __Pyx_XDECREF(__pyx_v_sgname); - __Pyx_XDECREF(__pyx_v_def_val); - __Pyx_XDECREF(__pyx_v_msgname); - __Pyx_XDECREF(__pyx_v_values); - __Pyx_XDECREF(__pyx_v_defs); - __Pyx_XDECREF(__pyx_7genexpr__pyx_v_v); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":110 - * - * cdef public: - * dict dv # <<<<<<<<<<<<<< - * string dbc_name - * - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(__pyx_v_self->dv); - __pyx_r = __pyx_v_self->dv; - goto __pyx_L0; - - /* function exit code */ - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_2__set__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_2__set__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_value) { - int __pyx_r; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__set__", 1); - if (!(likely(PyDict_CheckExact(__pyx_v_value))||((__pyx_v_value) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_v_value))) __PYX_ERR(0, 110, __pyx_L1_error) - __pyx_t_1 = __pyx_v_value; - __Pyx_INCREF(__pyx_t_1); - __Pyx_GIVEREF(__pyx_t_1); - __Pyx_GOTREF(__pyx_v_self->dv); - __Pyx_DECREF(__pyx_v_self->dv); - __pyx_v_self->dv = ((PyObject*)__pyx_t_1); - __pyx_t_1 = 0; - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.dv.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_5__del__(PyObject *__pyx_v_self); /*proto*/ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_5__del__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_4__del__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2dv_4__del__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self) { - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__del__", 1); - __Pyx_INCREF(Py_None); - __Pyx_GIVEREF(Py_None); - __Pyx_GOTREF(__pyx_v_self->dv); - __Pyx_DECREF(__pyx_v_self->dv); - __pyx_v_self->dv = ((PyObject*)Py_None); - - /* function exit code */ - __pyx_r = 0; - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "opendbc/can/parser_pyx.pyx":111 - * cdef public: - * dict dv - * string dbc_name # <<<<<<<<<<<<<< - * - * def __init__(self, dbc_name): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_1__get__(PyObject *__pyx_v_self); /*proto*/ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_1__get__(PyObject *__pyx_v_self) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name___get__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name___get__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - PyObject *__pyx_t_1 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 1); - __Pyx_XDECREF(__pyx_r); - __pyx_t_1 = __pyx_convert_PyBytes_string_to_py_std__in_string(__pyx_v_self->dbc_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_r = __pyx_t_1; - __pyx_t_1 = 0; - goto __pyx_L0; - - /* function exit code */ - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.dbc_name.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __pyx_L0:; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* Python wrapper */ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ -static int __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - int __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); - __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_2__set__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self), ((PyObject *)__pyx_v_value)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static int __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_2__set__(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, PyObject *__pyx_v_value) { - int __pyx_r; - std::string __pyx_t_1; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __pyx_t_1 = __pyx_convert_string_from_py_std__in_string(__pyx_v_value); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L1_error) - __pyx_v_self->dbc_name = __PYX_STD_MOVE_IF_SUPPORTED(__pyx_t_1); - - /* function exit code */ - __pyx_r = 0; - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.dbc_name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = -1; - __pyx_L0:; - return __pyx_r; -} - -/* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - if (unlikely(__pyx_nargs > 0)) { - __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} - if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2__reduce_cython__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 1); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_dbc_cannot_be_converted_to, 0, 0); - __PYX_ERR(1, 2, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -/* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - */ - -/* Python wrapper */ -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -); /*proto*/ -static PyMethodDef __pyx_mdef_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__(PyObject *__pyx_v_self, -#if CYTHON_METH_FASTCALL -PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds -#else -PyObject *__pyx_args, PyObject *__pyx_kwds -#endif -) { - CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; - #if !CYTHON_METH_FASTCALL - CYTHON_UNUSED Py_ssize_t __pyx_nargs; - #endif - CYTHON_UNUSED PyObject *const *__pyx_kwvalues; - PyObject* values[1] = {0}; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - #if !CYTHON_METH_FASTCALL - #if CYTHON_ASSUME_SAFE_MACROS - __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); - #else - __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; - #endif - #endif - __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); - { - PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; - if (__pyx_kwds) { - Py_ssize_t kw_args; - switch (__pyx_nargs) { - case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - CYTHON_FALLTHROUGH; - case 0: break; - default: goto __pyx_L5_argtuple_error; - } - kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); - switch (__pyx_nargs) { - case 0: - if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { - (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); - kw_args--; - } - else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) - else goto __pyx_L5_argtuple_error; - } - if (unlikely(kw_args > 0)) { - const Py_ssize_t kwd_pos_args = __pyx_nargs; - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) - } - } else if (unlikely(__pyx_nargs != 1)) { - goto __pyx_L5_argtuple_error; - } else { - values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); - } - __pyx_v___pyx_state = values[0]; - } - goto __pyx_L6_skip; - __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) - __pyx_L6_skip:; - goto __pyx_L4_argument_unpacking_done; - __pyx_L3_error:; - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __Pyx_RefNannyFinishContext(); - return NULL; - __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_4__setstate_cython__(((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)__pyx_v_self), __pyx_v___pyx_state); - - /* function exit code */ - { - Py_ssize_t __pyx_temp; - for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { - __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); - } - } - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_7opendbc_3can_10parser_pyx_9CANDefine_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { - PyObject *__pyx_r = NULL; - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 1); - - /* "(tree fragment)":4 - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< - */ - __Pyx_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_dbc_cannot_be_converted_to, 0, 0); - __PYX_ERR(1, 4, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - */ - - /* function exit code */ - __pyx_L1_error:; - __Pyx_AddTraceback("opendbc.can.parser_pyx.CANDefine.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); - __pyx_r = NULL; - __Pyx_XGIVEREF(__pyx_r); - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_tp_new_7opendbc_3can_10parser_pyx_CANParser(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)o); - new((void*)&(p->can_values)) std::vector (); - new((void*)&(p->dbc_name)) std::string(); - p->vl = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->vl_all = ((PyObject*)Py_None); Py_INCREF(Py_None); - p->ts_nanos = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANParser(PyObject *o) { - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANParser) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - { - PyObject *etype, *eval, *etb; - PyErr_Fetch(&etype, &eval, &etb); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); - __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_3__dealloc__(o); - __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); - PyErr_Restore(etype, eval, etb); - } - __Pyx_call_destructor(p->can_values); - __Pyx_call_destructor(p->dbc_name); - Py_CLEAR(p->vl); - Py_CLEAR(p->vl_all); - Py_CLEAR(p->ts_nanos); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANParser(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)o; - if (p->vl) { - e = (*v)(p->vl, a); if (e) return e; - } - if (p->vl_all) { - e = (*v)(p->vl_all, a); if (e) return e; - } - if (p->ts_nanos) { - e = (*v)(p->ts_nanos, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_7opendbc_3can_10parser_pyx_CANParser(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser *)o; - tmp = ((PyObject*)p->vl); - p->vl = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->vl_all); - p->vl_all = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - tmp = ((PyObject*)p->ts_nanos); - p->ts_nanos = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_can_valid(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9can_valid_1__get__(o); -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_bus_timeout(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_11bus_timeout_1__get__(o); -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_vl(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_2vl_1__get__(o); -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_vl_all(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_6vl_all_1__get__(o); -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_ts_nanos(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8ts_nanos_1__get__(o); -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_dbc_name(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_8dbc_name_1__get__(o); -} - -static PyMethodDef __pyx_methods_7opendbc_3can_10parser_pyx_CANParser[] = { - {"update_strings", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_5update_strings, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_7opendbc_3can_10parser_pyx_CANParser[] = { - {(char *)"can_valid", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_can_valid, 0, (char *)0, 0}, - {(char *)"bus_timeout", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_bus_timeout, 0, (char *)0, 0}, - {(char *)"vl", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_vl, 0, (char *)0, 0}, - {(char *)"vl_all", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_vl_all, 0, (char *)0, 0}, - {(char *)"ts_nanos", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_ts_nanos, 0, (char *)0, 0}, - {(char *)"dbc_name", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANParser_dbc_name, 0, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type_7opendbc_3can_10parser_pyx_CANParser_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANParser}, - {Py_tp_traverse, (void *)__pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANParser}, - {Py_tp_clear, (void *)__pyx_tp_clear_7opendbc_3can_10parser_pyx_CANParser}, - {Py_tp_methods, (void *)__pyx_methods_7opendbc_3can_10parser_pyx_CANParser}, - {Py_tp_getset, (void *)__pyx_getsets_7opendbc_3can_10parser_pyx_CANParser}, - {Py_tp_init, (void *)__pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_1__init__}, - {Py_tp_new, (void *)__pyx_tp_new_7opendbc_3can_10parser_pyx_CANParser}, - {0, 0}, -}; -static PyType_Spec __pyx_type_7opendbc_3can_10parser_pyx_CANParser_spec = { - "opendbc.can.parser_pyx.CANParser", - sizeof(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type_7opendbc_3can_10parser_pyx_CANParser_slots, -}; -#else - -static PyTypeObject __pyx_type_7opendbc_3can_10parser_pyx_CANParser = { - PyVarObject_HEAD_INIT(0, 0) - "opendbc.can.parser_pyx.""CANParser", /*tp_name*/ - sizeof(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANParser), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANParser, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANParser, /*tp_traverse*/ - __pyx_tp_clear_7opendbc_3can_10parser_pyx_CANParser, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_7opendbc_3can_10parser_pyx_CANParser, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_7opendbc_3can_10parser_pyx_CANParser, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - __pyx_pw_7opendbc_3can_10parser_pyx_9CANParser_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_7opendbc_3can_10parser_pyx_CANParser, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyObject *__pyx_tp_new_7opendbc_3can_10parser_pyx_CANDefine(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *p; - PyObject *o; - #if CYTHON_COMPILING_IN_LIMITED_API - allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); - o = alloc_func(t, 0); - #else - if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { - o = (*t->tp_alloc)(t, 0); - } else { - o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); - } - if (unlikely(!o)) return 0; - #endif - p = ((struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)o); - new((void*)&(p->dbc_name)) std::string(); - p->dv = ((PyObject*)Py_None); Py_INCREF(Py_None); - return o; -} - -static void __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANDefine(PyObject *o) { - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)o; - #if CYTHON_USE_TP_FINALIZE - if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { - if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANDefine) { - if (PyObject_CallFinalizerFromDealloc(o)) return; - } - } - #endif - PyObject_GC_UnTrack(o); - __Pyx_call_destructor(p->dbc_name); - Py_CLEAR(p->dv); - #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - (*Py_TYPE(o)->tp_free)(o); - #else - { - freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); - if (tp_free) tp_free(o); - } - #endif -} - -static int __pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANDefine(PyObject *o, visitproc v, void *a) { - int e; - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)o; - if (p->dv) { - e = (*v)(p->dv, a); if (e) return e; - } - return 0; -} - -static int __pyx_tp_clear_7opendbc_3can_10parser_pyx_CANDefine(PyObject *o) { - PyObject* tmp; - struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *p = (struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine *)o; - tmp = ((PyObject*)p->dv); - p->dv = ((PyObject*)Py_None); Py_INCREF(Py_None); - Py_XDECREF(tmp); - return 0; -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANDefine_dv(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_1__get__(o); -} - -static int __pyx_setprop_7opendbc_3can_10parser_pyx_9CANDefine_dv(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { - if (v) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_3__set__(o, v); - } - else { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_2dv_5__del__(o); - } -} - -static PyObject *__pyx_getprop_7opendbc_3can_10parser_pyx_9CANDefine_dbc_name(PyObject *o, CYTHON_UNUSED void *x) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_1__get__(o); -} - -static int __pyx_setprop_7opendbc_3can_10parser_pyx_9CANDefine_dbc_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { - if (v) { - return __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_8dbc_name_3__set__(o, v); - } - else { - PyErr_SetString(PyExc_NotImplementedError, "__del__"); - return -1; - } -} - -static PyMethodDef __pyx_methods_7opendbc_3can_10parser_pyx_CANDefine[] = { - {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, - {0, 0, 0, 0} -}; - -static struct PyGetSetDef __pyx_getsets_7opendbc_3can_10parser_pyx_CANDefine[] = { - {(char *)"dv", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANDefine_dv, __pyx_setprop_7opendbc_3can_10parser_pyx_9CANDefine_dv, (char *)0, 0}, - {(char *)"dbc_name", __pyx_getprop_7opendbc_3can_10parser_pyx_9CANDefine_dbc_name, __pyx_setprop_7opendbc_3can_10parser_pyx_9CANDefine_dbc_name, (char *)0, 0}, - {0, 0, 0, 0, 0} -}; -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_type_7opendbc_3can_10parser_pyx_CANDefine_slots[] = { - {Py_tp_dealloc, (void *)__pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANDefine}, - {Py_tp_traverse, (void *)__pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANDefine}, - {Py_tp_clear, (void *)__pyx_tp_clear_7opendbc_3can_10parser_pyx_CANDefine}, - {Py_tp_methods, (void *)__pyx_methods_7opendbc_3can_10parser_pyx_CANDefine}, - {Py_tp_getset, (void *)__pyx_getsets_7opendbc_3can_10parser_pyx_CANDefine}, - {Py_tp_init, (void *)__pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_1__init__}, - {Py_tp_new, (void *)__pyx_tp_new_7opendbc_3can_10parser_pyx_CANDefine}, - {0, 0}, -}; -static PyType_Spec __pyx_type_7opendbc_3can_10parser_pyx_CANDefine_spec = { - "opendbc.can.parser_pyx.CANDefine", - sizeof(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine), - 0, - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, - __pyx_type_7opendbc_3can_10parser_pyx_CANDefine_slots, -}; -#else - -static PyTypeObject __pyx_type_7opendbc_3can_10parser_pyx_CANDefine = { - PyVarObject_HEAD_INIT(0, 0) - "opendbc.can.parser_pyx.""CANDefine", /*tp_name*/ - sizeof(struct __pyx_obj_7opendbc_3can_10parser_pyx_CANDefine), /*tp_basicsize*/ - 0, /*tp_itemsize*/ - __pyx_tp_dealloc_7opendbc_3can_10parser_pyx_CANDefine, /*tp_dealloc*/ - #if PY_VERSION_HEX < 0x030800b4 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030800b4 - 0, /*tp_vectorcall_offset*/ - #endif - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - #if PY_MAJOR_VERSION < 3 - 0, /*tp_compare*/ - #endif - #if PY_MAJOR_VERSION >= 3 - 0, /*tp_as_async*/ - #endif - 0, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash*/ - 0, /*tp_call*/ - 0, /*tp_str*/ - 0, /*tp_getattro*/ - 0, /*tp_setattro*/ - 0, /*tp_as_buffer*/ - Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ - 0, /*tp_doc*/ - __pyx_tp_traverse_7opendbc_3can_10parser_pyx_CANDefine, /*tp_traverse*/ - __pyx_tp_clear_7opendbc_3can_10parser_pyx_CANDefine, /*tp_clear*/ - 0, /*tp_richcompare*/ - 0, /*tp_weaklistoffset*/ - 0, /*tp_iter*/ - 0, /*tp_iternext*/ - __pyx_methods_7opendbc_3can_10parser_pyx_CANDefine, /*tp_methods*/ - 0, /*tp_members*/ - __pyx_getsets_7opendbc_3can_10parser_pyx_CANDefine, /*tp_getset*/ - 0, /*tp_base*/ - 0, /*tp_dict*/ - 0, /*tp_descr_get*/ - 0, /*tp_descr_set*/ - #if !CYTHON_USE_TYPE_SPECS - 0, /*tp_dictoffset*/ - #endif - __pyx_pw_7opendbc_3can_10parser_pyx_9CANDefine_1__init__, /*tp_init*/ - 0, /*tp_alloc*/ - __pyx_tp_new_7opendbc_3can_10parser_pyx_CANDefine, /*tp_new*/ - 0, /*tp_free*/ - 0, /*tp_is_gc*/ - 0, /*tp_bases*/ - 0, /*tp_mro*/ - 0, /*tp_cache*/ - 0, /*tp_subclasses*/ - 0, /*tp_weaklist*/ - 0, /*tp_del*/ - 0, /*tp_version_tag*/ - #if PY_VERSION_HEX >= 0x030400a1 - #if CYTHON_USE_TP_FINALIZE - 0, /*tp_finalize*/ - #else - NULL, /*tp_finalize*/ - #endif - #endif - #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, /*tp_vectorcall*/ - #endif - #if __PYX_NEED_TP_PRINT_SLOT == 1 - 0, /*tp_print*/ - #endif - #if PY_VERSION_HEX >= 0x030C0000 - 0, /*tp_watched*/ - #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, /*tp_pypy_flags*/ - #endif -}; -#endif - -static PyMethodDef __pyx_methods[] = { - {0, 0, 0, 0} -}; -#ifndef CYTHON_SMALL_CODE -#if defined(__clang__) - #define CYTHON_SMALL_CODE -#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) - #define CYTHON_SMALL_CODE __attribute__((cold)) -#else - #define CYTHON_SMALL_CODE -#endif -#endif -/* #### Code section: pystring_table ### */ - -static int __Pyx_CreateStringTabAndInitStrings(void) { - __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_, __pyx_k_, sizeof(__pyx_k_), 0, 1, 0, 0}, - {&__pyx_n_s_CANDefine, __pyx_k_CANDefine, sizeof(__pyx_k_CANDefine), 0, 0, 1, 1}, - {&__pyx_n_s_CANDefine___reduce_cython, __pyx_k_CANDefine___reduce_cython, sizeof(__pyx_k_CANDefine___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANDefine___setstate_cython, __pyx_k_CANDefine___setstate_cython, sizeof(__pyx_k_CANDefine___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANParser, __pyx_k_CANParser, sizeof(__pyx_k_CANParser), 0, 0, 1, 1}, - {&__pyx_n_s_CANParser___reduce_cython, __pyx_k_CANParser___reduce_cython, sizeof(__pyx_k_CANParser___reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANParser___setstate_cython, __pyx_k_CANParser___setstate_cython, sizeof(__pyx_k_CANParser___setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_CANParser_update_strings, __pyx_k_CANParser_update_strings, sizeof(__pyx_k_CANParser_update_strings), 0, 0, 1, 1}, - {&__pyx_kp_u_Can_t_find_DBC, __pyx_k_Can_t_find_DBC, sizeof(__pyx_k_Can_t_find_DBC), 0, 1, 0, 0}, - {&__pyx_kp_u_Can_t_find_DBC_2, __pyx_k_Can_t_find_DBC_2, sizeof(__pyx_k_Can_t_find_DBC_2), 0, 1, 0, 0}, - {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, - {&__pyx_n_s_Number, __pyx_k_Number, sizeof(__pyx_k_Number), 0, 0, 1, 1}, - {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s__15, __pyx_k__15, sizeof(__pyx_k__15), 0, 0, 1, 1}, - {&__pyx_n_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 1}, - {&__pyx_kp_u__5, __pyx_k__5, sizeof(__pyx_k__5), 0, 1, 0, 0}, - {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, - {&__pyx_n_s_bus, __pyx_k_bus, sizeof(__pyx_k_bus), 0, 0, 1, 1}, - {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1}, - {&__pyx_n_s_clear, __pyx_k_clear, sizeof(__pyx_k_clear), 0, 0, 1, 1}, - {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, - {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, - {&__pyx_kp_u_could_not_find_message, __pyx_k_could_not_find_message, sizeof(__pyx_k_could_not_find_message), 0, 1, 0, 0}, - {&__pyx_n_s_cv, __pyx_k_cv, sizeof(__pyx_k_cv), 0, 0, 1, 1}, - {&__pyx_n_s_cv_name, __pyx_k_cv_name, sizeof(__pyx_k_cv_name), 0, 0, 1, 1}, - {&__pyx_n_s_dbc_name, __pyx_k_dbc_name, sizeof(__pyx_k_dbc_name), 0, 0, 1, 1}, - {&__pyx_n_s_defaultdict, __pyx_k_defaultdict, sizeof(__pyx_k_defaultdict), 0, 0, 1, 1}, - {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, - {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, - {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, - {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_kp_u_in_DBC, __pyx_k_in_DBC, sizeof(__pyx_k_in_DBC), 0, 1, 0, 0}, - {&__pyx_n_s_initializing, __pyx_k_initializing, sizeof(__pyx_k_initializing), 0, 0, 1, 1}, - {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, - {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, - {&__pyx_n_s_it, __pyx_k_it, sizeof(__pyx_k_it), 0, 0, 1, 1}, - {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_messages, __pyx_k_messages, sizeof(__pyx_k_messages), 0, 0, 1, 1}, - {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, - {&__pyx_n_s_new_vals, __pyx_k_new_vals, sizeof(__pyx_k_new_vals), 0, 0, 1, 1}, - {&__pyx_n_s_numbers, __pyx_k_numbers, sizeof(__pyx_k_numbers), 0, 0, 1, 1}, - {&__pyx_n_s_opendbc_can_parser_pyx, __pyx_k_opendbc_can_parser_pyx, sizeof(__pyx_k_opendbc_can_parser_pyx), 0, 0, 1, 1}, - {&__pyx_kp_s_opendbc_can_parser_pyx_pyx, __pyx_k_opendbc_can_parser_pyx_pyx, sizeof(__pyx_k_opendbc_can_parser_pyx_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, - {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, - {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, - {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, - {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, - {&__pyx_kp_s_self_can_self_dbc_cannot_be_conv, __pyx_k_self_can_self_dbc_cannot_be_conv, sizeof(__pyx_k_self_can_self_dbc_cannot_be_conv), 0, 0, 1, 0}, - {&__pyx_kp_s_self_dbc_cannot_be_converted_to, __pyx_k_self_dbc_cannot_be_converted_to, sizeof(__pyx_k_self_dbc_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_n_s_sendcan, __pyx_k_sendcan, sizeof(__pyx_k_sendcan), 0, 0, 1, 1}, - {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, - {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, - {&__pyx_n_s_spec, __pyx_k_spec, sizeof(__pyx_k_spec), 0, 0, 1, 1}, - {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, - {&__pyx_n_s_strings, __pyx_k_strings, sizeof(__pyx_k_strings), 0, 0, 1, 1}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_update_strings, __pyx_k_update_strings, sizeof(__pyx_k_update_strings), 0, 0, 1, 1}, - {&__pyx_n_s_updated_addrs, __pyx_k_updated_addrs, sizeof(__pyx_k_updated_addrs), 0, 0, 1, 1}, - {&__pyx_n_s_v, __pyx_k_v, sizeof(__pyx_k_v), 0, 0, 1, 1}, - {&__pyx_n_s_values, __pyx_k_values, sizeof(__pyx_k_values), 0, 0, 1, 1}, - {&__pyx_n_s_zip, __pyx_k_zip, sizeof(__pyx_k_zip), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} - }; - return __Pyx_InitStrings(__pyx_string_tab); -} -/* #### Code section: cached_builtins ### */ -static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { - __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 34, __pyx_L1_error) - __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 42, __pyx_L1_error) - __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) - __pyx_builtin_zip = __Pyx_GetBuiltinName(__pyx_n_s_zip); if (!__pyx_builtin_zip) __PYX_ERR(0, 143, __pyx_L1_error) - __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 68, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: cached_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); - - /* "opendbc/can/parser_pyx.pyx":139 - * # separate definition/value pairs - * def_val = def_val.split() - * values = [int(v) for v in def_val[::2]] # <<<<<<<<<<<<<< - * defs = def_val[1::2] - * - */ - __pyx_slice__2 = PySlice_New(Py_None, Py_None, __pyx_int_2); if (unlikely(!__pyx_slice__2)) __PYX_ERR(0, 139, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__2); - __Pyx_GIVEREF(__pyx_slice__2); - - /* "opendbc/can/parser_pyx.pyx":140 - * def_val = def_val.split() - * values = [int(v) for v in def_val[::2]] - * defs = def_val[1::2] # <<<<<<<<<<<<<< - * - * # two ways to lookup: address or msg name - */ - __pyx_slice__3 = PySlice_New(__pyx_int_1, Py_None, __pyx_int_2); if (unlikely(!__pyx_slice__3)) __PYX_ERR(0, 140, __pyx_L1_error) - __Pyx_GOTREF(__pyx_slice__3); - __Pyx_GIVEREF(__pyx_slice__3); - - /* "opendbc/can/parser_pyx.pyx":73 - * del self.can - * - * def update_strings(self, strings, sendcan=False): # <<<<<<<<<<<<<< - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint - */ - __pyx_tuple__6 = PyTuple_Pack(10, __pyx_n_s_self, __pyx_n_s_strings, __pyx_n_s_sendcan, __pyx_n_s_v, __pyx_n_s_l, __pyx_n_s_new_vals, __pyx_n_s_updated_addrs, __pyx_n_s_it, __pyx_n_s_cv, __pyx_n_s_cv_name); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_opendbc_can_parser_pyx_pyx, __pyx_n_s_update_strings, 73, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 73, __pyx_L1_error) - __pyx_tuple__8 = PyTuple_Pack(1, Py_False); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__8); - __Pyx_GIVEREF(__pyx_tuple__8); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_tuple__9 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__9); - __Pyx_GIVEREF(__pyx_tuple__9); - __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - */ - __pyx_tuple__11 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__11); - __Pyx_GIVEREF(__pyx_tuple__11); - __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(1, 3, __pyx_L1_error) - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__9, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 1, __pyx_L1_error) - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - */ - __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__11, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} -/* #### Code section: init_constants ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { - __pyx_umethod_PyDict_Type_get.type = (PyObject*)&PyDict_Type; - __pyx_umethod_PyDict_Type_get.method_name = &__pyx_n_s_get; - if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} -/* #### Code section: init_globals ### */ - -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - return 0; -} -/* #### Code section: init_module ### */ - -static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ -static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ - -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); - /*--- Variable export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_export_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); - /*--- Function export code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_type_init_code(void) { - __Pyx_RefNannyDeclarations - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); - /*--- Type init code ---*/ - #if CYTHON_USE_TYPE_SPECS - __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7opendbc_3can_10parser_pyx_CANParser_spec, NULL); if (unlikely(!__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser)) __PYX_ERR(0, 18, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7opendbc_3can_10parser_pyx_CANParser_spec, __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser) < 0) __PYX_ERR(0, 18, __pyx_L1_error) - #else - __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser = &__pyx_type_7opendbc_3can_10parser_pyx_CANParser; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser) < 0) __PYX_ERR(0, 18, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser->tp_dictoffset && __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_CANParser, (PyObject *) __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser) < 0) __PYX_ERR(0, 18, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7opendbc_3can_10parser_pyx_CANParser) < 0) __PYX_ERR(0, 18, __pyx_L1_error) - #endif - #if CYTHON_USE_TYPE_SPECS - __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_7opendbc_3can_10parser_pyx_CANDefine_spec, NULL); if (unlikely(!__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine)) __PYX_ERR(0, 105, __pyx_L1_error) - if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_7opendbc_3can_10parser_pyx_CANDefine_spec, __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine) < 0) __PYX_ERR(0, 105, __pyx_L1_error) - #else - __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine = &__pyx_type_7opendbc_3can_10parser_pyx_CANDefine; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - #endif - #if !CYTHON_USE_TYPE_SPECS - if (__Pyx_PyType_Ready(__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine) < 0) __PYX_ERR(0, 105, __pyx_L1_error) - #endif - #if PY_MAJOR_VERSION < 3 - __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine->tp_print = 0; - #endif - #if !CYTHON_COMPILING_IN_LIMITED_API - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine->tp_dictoffset && __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine->tp_getattro == PyObject_GenericGetAttr)) { - __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine->tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - #endif - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_CANDefine, (PyObject *) __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine) < 0) __PYX_ERR(0, 105, __pyx_L1_error) - #if !CYTHON_COMPILING_IN_LIMITED_API - if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_7opendbc_3can_10parser_pyx_CANDefine) < 0) __PYX_ERR(0, 105, __pyx_L1_error) - #endif - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} - -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_variable_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); - /*--- Variable import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - -static int __Pyx_modinit_function_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); - /*--- Function import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} - - -#if PY_MAJOR_VERSION >= 3 -#if CYTHON_PEP489_MULTI_PHASE_INIT -static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ -static int __pyx_pymod_exec_parser_pyx(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_parser_pyx}, - {0, NULL} -}; -#endif - -#ifdef __cplusplus -namespace { - struct PyModuleDef __pyx_moduledef = - #else - static struct PyModuleDef __pyx_moduledef = - #endif - { - PyModuleDef_HEAD_INIT, - "parser_pyx", - 0, /* m_doc */ - #if CYTHON_PEP489_MULTI_PHASE_INIT - 0, /* m_size */ - #elif CYTHON_USE_MODULE_STATE - sizeof(__pyx_mstate), /* m_size */ - #else - -1, /* m_size */ - #endif - __pyx_methods /* m_methods */, - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_moduledef_slots, /* m_slots */ - #else - NULL, /* m_reload */ - #endif - #if CYTHON_USE_MODULE_STATE - __pyx_m_traverse, /* m_traverse */ - __pyx_m_clear, /* m_clear */ - NULL /* m_free */ - #else - NULL, /* m_traverse */ - NULL, /* m_clear */ - NULL /* m_free */ - #endif - }; - #ifdef __cplusplus -} /* anonymous namespace */ -#endif -#endif - -#ifndef CYTHON_NO_PYINIT_EXPORT -#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC -#elif PY_MAJOR_VERSION < 3 -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" void -#else -#define __Pyx_PyMODINIT_FUNC void -#endif -#else -#ifdef __cplusplus -#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * -#else -#define __Pyx_PyMODINIT_FUNC PyObject * -#endif -#endif - - -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initparser_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initparser_pyx(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_parser_pyx(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_parser_pyx(void) -#if CYTHON_PEP489_MULTI_PHASE_INIT -{ - return PyModuleDef_Init(&__pyx_moduledef); -} -static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { - #if PY_VERSION_HEX >= 0x030700A1 - static PY_INT64_T main_interpreter_id = -1; - PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); - if (main_interpreter_id == -1) { - main_interpreter_id = current_id; - return (unlikely(current_id == -1)) ? -1 : 0; - } else if (unlikely(main_interpreter_id != current_id)) - #else - static PyInterpreterState *main_interpreter = NULL; - PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; - if (!main_interpreter) { - main_interpreter = current_interpreter; - } else if (unlikely(main_interpreter != current_interpreter)) - #endif - { - PyErr_SetString( - PyExc_ImportError, - "Interpreter change detected - this module can only be loaded into one interpreter per process."); - return -1; - } - return 0; -} -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) -#else -static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) -#endif -{ - PyObject *value = PyObject_GetAttrString(spec, from_name); - int result = 0; - if (likely(value)) { - if (allow_none || value != Py_None) { -#if CYTHON_COMPILING_IN_LIMITED_API - result = PyModule_AddObject(module, to_name, value); -#else - result = PyDict_SetItemString(moddict, to_name, value); -#endif - } - Py_DECREF(value); - } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { - PyErr_Clear(); - } else { - result = -1; - } - return result; -} -static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { - PyObject *module = NULL, *moddict, *modname; - CYTHON_UNUSED_VAR(def); - if (__Pyx_check_single_interpreter()) - return NULL; - if (__pyx_m) - return __Pyx_NewRef(__pyx_m); - modname = PyObject_GetAttrString(spec, "name"); - if (unlikely(!modname)) goto bad; - module = PyModule_NewObject(modname); - Py_DECREF(modname); - if (unlikely(!module)) goto bad; -#if CYTHON_COMPILING_IN_LIMITED_API - moddict = module; -#else - moddict = PyModule_GetDict(module); - if (unlikely(!moddict)) goto bad; -#endif - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; - if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; - return module; -bad: - Py_XDECREF(module); - return NULL; -} - - -static CYTHON_SMALL_CODE int __pyx_pymod_exec_parser_pyx(PyObject *__pyx_pyinit_module) -#endif -#endif -{ - int stringtab_initialized = 0; - #if CYTHON_USE_MODULE_STATE - int pystate_addmodule_run = 0; - #endif - PyObject *__pyx_t_1 = NULL; - PyObject *__pyx_t_2 = NULL; - PyObject *__pyx_t_3 = NULL; - int __pyx_lineno = 0; - const char *__pyx_filename = NULL; - int __pyx_clineno = 0; - __Pyx_RefNannyDeclarations - #if CYTHON_PEP489_MULTI_PHASE_INIT - if (__pyx_m) { - if (__pyx_m == __pyx_pyinit_module) return 0; - PyErr_SetString(PyExc_RuntimeError, "Module 'parser_pyx' has already been imported. Re-initialisation is not supported."); - return -1; - } - #elif PY_MAJOR_VERSION >= 3 - if (__pyx_m) return __Pyx_NewRef(__pyx_m); - #endif - /*--- Module creation code ---*/ - #if CYTHON_PEP489_MULTI_PHASE_INIT - __pyx_m = __pyx_pyinit_module; - Py_INCREF(__pyx_m); - #else - #if PY_MAJOR_VERSION < 3 - __pyx_m = Py_InitModule4("parser_pyx", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #elif CYTHON_USE_MODULE_STATE - __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) - { - int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); - __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "parser_pyx" pseudovariable */ - if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - pystate_addmodule_run = 1; - } - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #endif - CYTHON_UNUSED_VAR(__pyx_t_1); - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if CYTHON_REFNANNY -__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); -if (!__Pyx_RefNanny) { - PyErr_Clear(); - __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); - if (!__Pyx_RefNanny) - Py_FatalError("failed to import 'refnanny' module"); -} -#endif - __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_parser_pyx(void)", 0); - if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pxy_PyFrame_Initialize_Offsets - __Pxy_PyFrame_Initialize_Offsets(); - #endif - __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #endif - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - stringtab_initialized = 1; - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) - if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_opendbc__can__parser_pyx) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "opendbc.can.parser_pyx")) { - if (unlikely((PyDict_SetItemString(modules, "opendbc.can.parser_pyx", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Global type/function init code ---*/ - (void)__Pyx_modinit_global_init_code(); - (void)__Pyx_modinit_variable_export_code(); - (void)__Pyx_modinit_function_export_code(); - if (unlikely((__Pyx_modinit_type_init_code() < 0))) __PYX_ERR(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_import_code(); - (void)__Pyx_modinit_variable_import_code(); - (void)__Pyx_modinit_function_import_code(); - /*--- Execution code ---*/ - #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) - if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - - /* "opendbc/can/parser_pyx.pyx":14 - * from .common cimport dbc_lookup, SignalValue, DBC - * - * import numbers # <<<<<<<<<<<<<< - * from collections import defaultdict - * - */ - __pyx_t_2 = __Pyx_ImportDottedModule(__pyx_n_s_numbers, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_2) < 0) __PYX_ERR(0, 14, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - - /* "opendbc/can/parser_pyx.pyx":15 - * - * import numbers - * from collections import defaultdict # <<<<<<<<<<<<<< - * - * - */ - __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_INCREF(__pyx_n_s_defaultdict); - __Pyx_GIVEREF(__pyx_n_s_defaultdict); - if (__Pyx_PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_defaultdict)) __PYX_ERR(0, 15, __pyx_L1_error); - __pyx_t_3 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_defaultdict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_defaultdict, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "opendbc/can/parser_pyx.pyx":73 - * del self.can - * - * def update_strings(self, strings, sendcan=False): # <<<<<<<<<<<<<< - * for v in self.vl_all.values(): - * for l in v.values(): # no-cython-lint - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_5update_strings, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANParser_update_strings, NULL, __pyx_n_s_opendbc_can_parser_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_3, __pyx_tuple__8); - if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser, __pyx_n_s_update_strings, __pyx_t_3) < 0) __PYX_ERR(0, 73, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - PyType_Modified(__pyx_ptype_7opendbc_3can_10parser_pyx_CANParser); - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANParser___reduce_cython, NULL, __pyx_n_s_opendbc_can_parser_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__10)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.can,self.dbc cannot be converted to a Python object for pickling" - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10parser_pyx_9CANParser_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANParser___setstate_cython, NULL, __pyx_n_s_opendbc_can_parser_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__12)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":1 - * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10parser_pyx_9CANDefine_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANDefine___reduce_cython, NULL, __pyx_n_s_opendbc_can_parser_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "(tree fragment)":3 - * def __reduce_cython__(self): - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError, "self.dbc cannot be converted to a Python object for pickling" - */ - __pyx_t_3 = __Pyx_CyFunction_New(&__pyx_mdef_7opendbc_3can_10parser_pyx_9CANDefine_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_CANDefine___setstate_cython, NULL, __pyx_n_s_opendbc_can_parser_pyx, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_3) < 0) __PYX_ERR(1, 3, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "opendbc/can/parser_pyx.pyx":1 - * # distutils: language = c++ # <<<<<<<<<<<<<< - * # cython: c_string_encoding=ascii, language_level=3 - * - */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /*--- Wrapped vars code ---*/ - - goto __pyx_L0; - __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_2); - __Pyx_XDECREF(__pyx_t_3); - if (__pyx_m) { - if (__pyx_d && stringtab_initialized) { - __Pyx_AddTraceback("init opendbc.can.parser_pyx", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - #if !CYTHON_USE_MODULE_STATE - Py_CLEAR(__pyx_m); - #else - Py_DECREF(__pyx_m); - if (pystate_addmodule_run) { - PyObject *tp, *value, *tb; - PyErr_Fetch(&tp, &value, &tb); - PyState_RemoveModule(&__pyx_moduledef); - PyErr_Restore(tp, value, tb); - } - #endif - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init opendbc.can.parser_pyx"); - } - __pyx_L0:; - __Pyx_RefNannyFinishContext(); - #if CYTHON_PEP489_MULTI_PHASE_INIT - return (__pyx_m != NULL) ? 0 : -1; - #elif PY_MAJOR_VERSION >= 3 - return __pyx_m; - #else - return; - #endif -} -/* #### Code section: cleanup_globals ### */ -/* #### Code section: cleanup_module ### */ -/* #### Code section: main_method ### */ -/* #### Code section: utility_code_pragmas ### */ -#ifdef _MSC_VER -#pragma warning( push ) -/* Warning 4127: conditional expression is constant - * Cython uses constant conditional expressions to allow in inline functions to be optimized at - * compile-time, so this warning is not useful - */ -#pragma warning( disable : 4127 ) -#endif - - - -/* #### Code section: utility_code_def ### */ - -/* --- Runtime support code --- */ -/* Refnanny */ -#if CYTHON_REFNANNY -static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { - PyObject *m = NULL, *p = NULL; - void *r = NULL; - m = PyImport_ImportModule(modname); - if (!m) goto end; - p = PyObject_GetAttrString(m, "RefNannyAPI"); - if (!p) goto end; - r = PyLong_AsVoidPtr(p); -end: - Py_XDECREF(p); - Py_XDECREF(m); - return (__Pyx_RefNannyAPIStruct *)r; -} -#endif - -/* PyErrExceptionMatches */ -#if CYTHON_FAST_THREAD_STATE -static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030C00A6 - PyObject *current_exception = tstate->current_exception; - if (unlikely(!current_exception)) return 0; - exc_type = (PyObject*) Py_TYPE(current_exception); - if (exc_type == err) return 1; -#else - exc_type = tstate->curexc_type; - if (exc_type == err) return 1; - if (unlikely(!exc_type)) return 0; -#endif - #if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(exc_type); - #endif - if (unlikely(PyTuple_Check(err))) { - result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); - } else { - result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); - } - #if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(exc_type); - #endif - return result; -} -#endif - -/* PyErrFetchRestore */ -#if CYTHON_FAST_THREAD_STATE -static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject *tmp_value; - assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); - if (value) { - #if CYTHON_COMPILING_IN_CPYTHON - if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) - #endif - PyException_SetTraceback(value, tb); - } - tmp_value = tstate->current_exception; - tstate->current_exception = value; - Py_XDECREF(tmp_value); - Py_XDECREF(type); - Py_XDECREF(tb); -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - tmp_type = tstate->curexc_type; - tmp_value = tstate->curexc_value; - tmp_tb = tstate->curexc_traceback; - tstate->curexc_type = type; - tstate->curexc_value = value; - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_type); - Py_XDECREF(tmp_value); - Py_XDECREF(tmp_tb); -#endif -} -static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { -#if PY_VERSION_HEX >= 0x030C00A6 - PyObject* exc_value; - exc_value = tstate->current_exception; - tstate->current_exception = 0; - *value = exc_value; - *type = NULL; - *tb = NULL; - if (exc_value) { - *type = (PyObject*) Py_TYPE(exc_value); - Py_INCREF(*type); - #if CYTHON_COMPILING_IN_CPYTHON - *tb = ((PyBaseExceptionObject*) exc_value)->traceback; - Py_XINCREF(*tb); - #else - *tb = PyException_GetTraceback(exc_value); - #endif - } -#else - *type = tstate->curexc_type; - *value = tstate->curexc_value; - *tb = tstate->curexc_traceback; - tstate->curexc_type = 0; - tstate->curexc_value = 0; - tstate->curexc_traceback = 0; -#endif -} -#endif - -/* PyObjectGetAttrStr */ -#if CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro)) - return tp->tp_getattro(obj, attr_name); -#if PY_MAJOR_VERSION < 3 - if (likely(tp->tp_getattr)) - return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); -#endif - return PyObject_GetAttr(obj, attr_name); -} -#endif - -/* PyObjectGetAttrStrNoError */ -#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 -static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) - __Pyx_PyErr_Clear(); -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { - PyObject *result; -#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 - (void) PyObject_GetOptionalAttr(obj, attr_name, &result); - return result; -#else -#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 - PyTypeObject* tp = Py_TYPE(obj); - if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { - return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); - } -#endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); - } - return result; -#endif -} - -/* GetBuiltinName */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name) { - PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); - if (unlikely(!result) && !PyErr_Occurred()) { - PyErr_Format(PyExc_NameError, -#if PY_MAJOR_VERSION >= 3 - "name '%U' is not defined", name); -#else - "name '%.200s' is not defined", PyString_AS_STRING(name)); -#endif - } - return result; -} - -/* RaiseTooManyValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { - PyErr_Format(PyExc_ValueError, - "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); -} - -/* RaiseNeedMoreValuesToUnpack */ -static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { - PyErr_Format(PyExc_ValueError, - "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", - index, (index == 1) ? "" : "s"); -} - -/* IterFinish */ -static CYTHON_INLINE int __Pyx_IterFinish(void) { - PyObject* exc_type; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - exc_type = __Pyx_PyErr_CurrentExceptionType(); - if (unlikely(exc_type)) { - if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) - return -1; - __Pyx_PyErr_Clear(); - return 0; - } - return 0; -} - -/* UnpackItemEndCheck */ -static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { - if (unlikely(retval)) { - Py_DECREF(retval); - __Pyx_RaiseTooManyValuesError(expected); - return -1; - } - return __Pyx_IterFinish(); -} - -/* TupleAndListFromArray */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { - PyObject *v; - Py_ssize_t i; - for (i = 0; i < length; i++) { - v = dest[i] = src[i]; - Py_INCREF(v); - } -} -static CYTHON_INLINE PyObject * -__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - Py_INCREF(__pyx_empty_tuple); - return __pyx_empty_tuple; - } - res = PyTuple_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); - return res; -} -static CYTHON_INLINE PyObject * -__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) -{ - PyObject *res; - if (n <= 0) { - return PyList_New(0); - } - res = PyList_New(n); - if (unlikely(res == NULL)) return NULL; - __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); - return res; -} -#endif - -/* BytesEquals */ -static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - return PyObject_RichCompareBool(s1, s2, equals); -#else - if (s1 == s2) { - return (equals == Py_EQ); - } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { - const char *ps1, *ps2; - Py_ssize_t length = PyBytes_GET_SIZE(s1); - if (length != PyBytes_GET_SIZE(s2)) - return (equals == Py_NE); - ps1 = PyBytes_AS_STRING(s1); - ps2 = PyBytes_AS_STRING(s2); - if (ps1[0] != ps2[0]) { - return (equals == Py_NE); - } else if (length == 1) { - return (equals == Py_EQ); - } else { - int result; -#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) - Py_hash_t hash1, hash2; - hash1 = ((PyBytesObject*)s1)->ob_shash; - hash2 = ((PyBytesObject*)s2)->ob_shash; - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - return (equals == Py_NE); - } -#endif - result = memcmp(ps1, ps2, (size_t)length); - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { - return (equals == Py_NE); - } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { - return (equals == Py_NE); - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -#endif -} - -/* UnicodeEquals */ -static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { -#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API - return PyObject_RichCompareBool(s1, s2, equals); -#else -#if PY_MAJOR_VERSION < 3 - PyObject* owned_ref = NULL; -#endif - int s1_is_unicode, s2_is_unicode; - if (s1 == s2) { - goto return_eq; - } - s1_is_unicode = PyUnicode_CheckExact(s1); - s2_is_unicode = PyUnicode_CheckExact(s2); -#if PY_MAJOR_VERSION < 3 - if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { - owned_ref = PyUnicode_FromObject(s2); - if (unlikely(!owned_ref)) - return -1; - s2 = owned_ref; - s2_is_unicode = 1; - } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { - owned_ref = PyUnicode_FromObject(s1); - if (unlikely(!owned_ref)) - return -1; - s1 = owned_ref; - s1_is_unicode = 1; - } else if (((!s2_is_unicode) & (!s1_is_unicode))) { - return __Pyx_PyBytes_Equals(s1, s2, equals); - } -#endif - if (s1_is_unicode & s2_is_unicode) { - Py_ssize_t length; - int kind; - void *data1, *data2; - if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) - return -1; - length = __Pyx_PyUnicode_GET_LENGTH(s1); - if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { - goto return_ne; - } -#if CYTHON_USE_UNICODE_INTERNALS - { - Py_hash_t hash1, hash2; - #if CYTHON_PEP393_ENABLED - hash1 = ((PyASCIIObject*)s1)->hash; - hash2 = ((PyASCIIObject*)s2)->hash; - #else - hash1 = ((PyUnicodeObject*)s1)->hash; - hash2 = ((PyUnicodeObject*)s2)->hash; - #endif - if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { - goto return_ne; - } - } -#endif - kind = __Pyx_PyUnicode_KIND(s1); - if (kind != __Pyx_PyUnicode_KIND(s2)) { - goto return_ne; - } - data1 = __Pyx_PyUnicode_DATA(s1); - data2 = __Pyx_PyUnicode_DATA(s2); - if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { - goto return_ne; - } else if (length == 1) { - goto return_eq; - } else { - int result = memcmp(data1, data2, (size_t)(length * kind)); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ) ? (result == 0) : (result != 0); - } - } else if ((s1 == Py_None) & s2_is_unicode) { - goto return_ne; - } else if ((s2 == Py_None) & s1_is_unicode) { - goto return_ne; - } else { - int result; - PyObject* py_result = PyObject_RichCompare(s1, s2, equals); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - if (!py_result) - return -1; - result = __Pyx_PyObject_IsTrue(py_result); - Py_DECREF(py_result); - return result; - } -return_eq: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_EQ); -return_ne: - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(owned_ref); - #endif - return (equals == Py_NE); -#endif -} - -/* fastcall */ -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) -{ - Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); - for (i = 0; i < n; i++) - { - if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; - } - for (i = 0; i < n; i++) - { - int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); - if (unlikely(eq != 0)) { - if (unlikely(eq < 0)) return NULL; - return kwvalues[i]; - } - } - return NULL; -} -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 -CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { - Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); - PyObject *dict; - dict = PyDict_New(); - if (unlikely(!dict)) - return NULL; - for (i=0; i= 3 - "%s() got multiple values for keyword argument '%U'", func_name, kw_name); - #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); - #endif -} - -/* ParseKeywords */ -static int __Pyx_ParseOptionalKeywords( - PyObject *kwds, - PyObject *const *kwvalues, - PyObject **argnames[], - PyObject *kwds2, - PyObject *values[], - Py_ssize_t num_pos_args, - const char* function_name) -{ - PyObject *key = 0, *value = 0; - Py_ssize_t pos = 0; - PyObject*** name; - PyObject*** first_kw_arg = argnames + num_pos_args; - int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); - while (1) { - Py_XDECREF(key); key = NULL; - Py_XDECREF(value); value = NULL; - if (kwds_is_tuple) { - Py_ssize_t size; -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(kwds); -#else - size = PyTuple_Size(kwds); - if (size < 0) goto bad; -#endif - if (pos >= size) break; -#if CYTHON_AVOID_BORROWED_REFS - key = __Pyx_PySequence_ITEM(kwds, pos); - if (!key) goto bad; -#elif CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kwds, pos); -#else - key = PyTuple_GetItem(kwds, pos); - if (!key) goto bad; -#endif - value = kwvalues[pos]; - pos++; - } - else - { - if (!PyDict_Next(kwds, &pos, &key, &value)) break; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - } - name = first_kw_arg; - while (*name && (**name != key)) name++; - if (*name) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - Py_INCREF(value); - Py_DECREF(key); -#endif - key = NULL; - value = NULL; - continue; - } -#if !CYTHON_AVOID_BORROWED_REFS - Py_INCREF(key); -#endif - Py_INCREF(value); - name = first_kw_arg; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_Check(key))) { - while (*name) { - if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) - && _PyString_Eq(**name, key)) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - if ((**argname == key) || ( - (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) - && _PyString_Eq(**argname, key))) { - goto arg_passed_twice; - } - argname++; - } - } - } else - #endif - if (likely(PyUnicode_Check(key))) { - while (*name) { - int cmp = ( - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**name, key) - ); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) { - values[name-argnames] = value; -#if CYTHON_AVOID_BORROWED_REFS - value = NULL; -#endif - break; - } - name++; - } - if (*name) continue; - else { - PyObject*** argname = argnames; - while (argname != first_kw_arg) { - int cmp = (**argname == key) ? 0 : - #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 - (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : - #endif - PyUnicode_Compare(**argname, key); - if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; - if (cmp == 0) goto arg_passed_twice; - argname++; - } - } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; - } - } - Py_XDECREF(key); - Py_XDECREF(value); - return 0; -arg_passed_twice: - __Pyx_RaiseDoubleKeywordsError(function_name, key); - goto bad; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - goto bad; -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif -bad: - Py_XDECREF(key); - Py_XDECREF(value); - return -1; -} - -/* PyFunctionFastCall */ -#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL -static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, - PyObject *globals) { - PyFrameObject *f; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject **fastlocals; - Py_ssize_t i; - PyObject *result; - assert(globals != NULL); - /* XXX Perhaps we should create a specialized - PyFrame_New() that doesn't take locals, but does - take builtins without sanity checking them. - */ - assert(tstate != NULL); - f = PyFrame_New(tstate, co, globals, NULL); - if (f == NULL) { - return NULL; - } - fastlocals = __Pyx_PyFrame_GetLocalsplus(f); - for (i = 0; i < na; i++) { - Py_INCREF(*args); - fastlocals[i] = *args++; - } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; - return result; -} -static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { - PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); - PyObject *globals = PyFunction_GET_GLOBALS(func); - PyObject *argdefs = PyFunction_GET_DEFAULTS(func); - PyObject *closure; -#if PY_MAJOR_VERSION >= 3 - PyObject *kwdefs; -#endif - PyObject *kwtuple, **k; - PyObject **d; - Py_ssize_t nd; - Py_ssize_t nk; - PyObject *result; - assert(kwargs == NULL || PyDict_Check(kwargs)); - nk = kwargs ? PyDict_Size(kwargs) : 0; - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { - return NULL; - } - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { - return NULL; - } - #endif - if ( -#if PY_MAJOR_VERSION >= 3 - co->co_kwonlyargcount == 0 && -#endif - likely(kwargs == NULL || nk == 0) && - co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { - if (argdefs == NULL && co->co_argcount == nargs) { - result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); - goto done; - } - else if (nargs == 0 && argdefs != NULL - && co->co_argcount == Py_SIZE(argdefs)) { - /* function called with no arguments, but all parameters have - a default value: use default values as arguments .*/ - args = &PyTuple_GET_ITEM(argdefs, 0); - result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); - goto done; - } - } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; - } - k = &PyTuple_GET_ITEM(kwtuple, 0); - pos = i = 0; - while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { - Py_INCREF(k[i]); - Py_INCREF(k[i+1]); - i += 2; - } - nk = i / 2; - } - else { - kwtuple = NULL; - k = NULL; - } - closure = PyFunction_GET_CLOSURE(func); -#if PY_MAJOR_VERSION >= 3 - kwdefs = PyFunction_GET_KW_DEFAULTS(func); -#endif - if (argdefs != NULL) { - d = &PyTuple_GET_ITEM(argdefs, 0); - nd = Py_SIZE(argdefs); - } - else { - d = NULL; - nd = 0; - } -#if PY_MAJOR_VERSION >= 3 - result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, kwdefs, closure); -#else - result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, - args, (int)nargs, - k, (int)nk, - d, (int)nd, closure); -#endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} -#endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->tp_call; - if (unlikely(!call)) - return PyObject_Call(func, arg, kw); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = (*call)(func, arg, kw); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectCallMethO */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { - PyObject *self, *result; - PyCFunction cfunc; - cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); - self = __Pyx_CyOrPyCFunction_GET_SELF(func); - #if PY_MAJOR_VERSION < 3 - if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) - return NULL; - #else - if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) - return NULL; - #endif - result = cfunc(self, arg); - Py_LeaveRecursiveCall(); - if (unlikely(!result) && unlikely(!PyErr_Occurred())) { - PyErr_SetString( - PyExc_SystemError, - "NULL result without error in PyObject_Call"); - } - return result; -} -#endif - -/* PyObjectFastCall */ -#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API -static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { - PyObject *argstuple; - PyObject *result = 0; - size_t i; - argstuple = PyTuple_New((Py_ssize_t)nargs); - if (unlikely(!argstuple)) return NULL; - for (i = 0; i < nargs; i++) { - Py_INCREF(args[i]); - if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; - } - result = __Pyx_PyObject_Call(func, argstuple, kwargs); - bad: - Py_DECREF(argstuple); - return result; -} -#endif -static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { - Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); -#if CYTHON_COMPILING_IN_CPYTHON - if (nargs == 0 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) - return __Pyx_PyObject_CallMethO(func, NULL); - } - else if (nargs == 1 && kwargs == NULL) { - if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) - return __Pyx_PyObject_CallMethO(func, args[0]); - } -#endif - #if PY_VERSION_HEX < 0x030800B1 - #if CYTHON_FAST_PYCCALL - if (PyCFunction_Check(func)) { - if (kwargs) { - return _PyCFunction_FastCallDict(func, args, nargs, kwargs); - } else { - return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); - } - } - #if PY_VERSION_HEX >= 0x030700A1 - if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { - return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); - } - #endif - #endif - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(func)) { - return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); - } - #endif - #endif - if (kwargs == NULL) { - #if CYTHON_VECTORCALL - #if PY_VERSION_HEX < 0x03090000 - vectorcallfunc f = _PyVectorcall_Function(func); - #else - vectorcallfunc f = PyVectorcall_Function(func); - #endif - if (f) { - return f(func, args, (size_t)nargs, NULL); - } - #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL - if (__Pyx_CyFunction_CheckExact(func)) { - __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); - if (f) return f(func, args, (size_t)nargs, NULL); - } - #endif - } - if (nargs == 0) { - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); - } - #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API - return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); - #else - return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); - #endif -} - -/* PyObjectCallOneArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { - PyObject *args[2] = {NULL, arg}; - return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - __Pyx_PyThreadState_declare - CYTHON_UNUSED_VAR(cause); - Py_XINCREF(type); - if (!value || value == Py_None) - value = NULL; - else - Py_INCREF(value); - if (!tb || tb == Py_None) - tb = NULL; - else { - Py_INCREF(tb); - if (!PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto raise_error; - } - } - if (PyType_Check(type)) { -#if CYTHON_COMPILING_IN_PYPY - if (!value) { - Py_INCREF(Py_None); - value = Py_None; - } -#endif - PyErr_NormalizeException(&type, &value, &tb); - } else { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto raise_error; - } - value = type; - type = (PyObject*) Py_TYPE(type); - Py_INCREF(type); - if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto raise_error; - } - } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; -} -#else -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { - PyObject* owned_instance = NULL; - if (tb == Py_None) { - tb = 0; - } else if (tb && !PyTraceBack_Check(tb)) { - PyErr_SetString(PyExc_TypeError, - "raise: arg 3 must be a traceback or None"); - goto bad; - } - if (value == Py_None) - value = 0; - if (PyExceptionInstance_Check(type)) { - if (value) { - PyErr_SetString(PyExc_TypeError, - "instance exception may not have a separate value"); - goto bad; - } - value = type; - type = (PyObject*) Py_TYPE(value); - } else if (PyExceptionClass_Check(type)) { - PyObject *instance_class = NULL; - if (value && PyExceptionInstance_Check(value)) { - instance_class = (PyObject*) Py_TYPE(value); - if (instance_class != type) { - int is_subclass = PyObject_IsSubclass(instance_class, type); - if (!is_subclass) { - instance_class = NULL; - } else if (unlikely(is_subclass == -1)) { - goto bad; - } else { - type = instance_class; - } - } - } - if (!instance_class) { - PyObject *args; - if (!value) - args = PyTuple_New(0); - else if (PyTuple_Check(value)) { - Py_INCREF(value); - args = value; - } else - args = PyTuple_Pack(1, value); - if (!args) - goto bad; - owned_instance = PyObject_Call(type, args, NULL); - Py_DECREF(args); - if (!owned_instance) - goto bad; - value = owned_instance; - if (!PyExceptionInstance_Check(value)) { - PyErr_Format(PyExc_TypeError, - "calling %R should have returned an instance of " - "BaseException, not %R", - type, Py_TYPE(value)); - goto bad; - } - } - } else { - PyErr_SetString(PyExc_TypeError, - "raise: exception class must be a subclass of BaseException"); - goto bad; - } - if (cause) { - PyObject *fixed_cause; - if (cause == Py_None) { - fixed_cause = NULL; - } else if (PyExceptionClass_Check(cause)) { - fixed_cause = PyObject_CallObject(cause, NULL); - if (fixed_cause == NULL) - goto bad; - } else if (PyExceptionInstance_Check(cause)) { - fixed_cause = cause; - Py_INCREF(fixed_cause); - } else { - PyErr_SetString(PyExc_TypeError, - "exception causes must derive from " - "BaseException"); - goto bad; - } - PyException_SetCause(value, fixed_cause); - } - PyErr_SetObject(type, value); - if (tb) { - #if PY_VERSION_HEX >= 0x030C00A6 - PyException_SetTraceback(value, tb); - #elif CYTHON_FAST_THREAD_STATE - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject* tmp_tb = tstate->curexc_traceback; - if (tb != tmp_tb) { - Py_INCREF(tb); - tstate->curexc_traceback = tb; - Py_XDECREF(tmp_tb); - } -#else - PyObject *tmp_type, *tmp_value, *tmp_tb; - PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); - Py_INCREF(tb); - PyErr_Restore(tmp_type, tmp_value, tb); - Py_XDECREF(tmp_tb); -#endif - } -bad: - Py_XDECREF(owned_instance); - return; -} -#endif - -/* decode_c_bytes */ -static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( - const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, - const char* encoding, const char* errors, - PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { - if (unlikely((start < 0) | (stop < 0))) { - if (start < 0) { - start += length; - if (start < 0) - start = 0; - } - if (stop < 0) - stop += length; - } - if (stop > length) - stop = length; - if (unlikely(stop <= start)) - return __Pyx_NewRef(__pyx_empty_unicode); - length = stop - start; - cstring += start; - if (decode_func) { - return decode_func(cstring, length, errors); - } else { - return PyUnicode_Decode(cstring, length, encoding, errors); - } -} - -/* GetItemInt */ -static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { - PyObject *r; - if (unlikely(!j)) return NULL; - r = PyObject_GetItem(o, j); - Py_DECREF(j); - return r; -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyList_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { - PyObject *r = PyList_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - Py_ssize_t wrapped_i = i; - if (wraparound & unlikely(i < 0)) { - wrapped_i += PyTuple_GET_SIZE(o); - } - if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); - Py_INCREF(r); - return r; - } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -#else - return PySequence_GetItem(o, i); -#endif -} -static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, - CYTHON_NCP_UNUSED int wraparound, - CYTHON_NCP_UNUSED int boundscheck) { -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS - if (is_list || PyList_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); - if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { - PyObject *r = PyList_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } - else if (PyTuple_CheckExact(o)) { - Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); - if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { - PyObject *r = PyTuple_GET_ITEM(o, n); - Py_INCREF(r); - return r; - } - } else { - PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; - PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; - if (mm && mm->mp_subscript) { - PyObject *r, *key = PyInt_FromSsize_t(i); - if (unlikely(!key)) return NULL; - r = mm->mp_subscript(o, key); - Py_DECREF(key); - return r; - } - if (likely(sm && sm->sq_item)) { - if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { - Py_ssize_t l = sm->sq_length(o); - if (likely(l >= 0)) { - i += l; - } else { - if (!PyErr_ExceptionMatches(PyExc_OverflowError)) - return NULL; - PyErr_Clear(); - } - } - return sm->sq_item(o, i); - } - } -#else - if (is_list || !PyMapping_Check(o)) { - return PySequence_GetItem(o, i); - } -#endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); -} - -/* PyDictVersioning */ -#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS -static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; -} -static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { - PyObject **dictptr = NULL; - Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; - if (offset) { -#if CYTHON_COMPILING_IN_CPYTHON - dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); -#else - dictptr = _PyObject_GetDictPtr(obj); -#endif - } - return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; -} -static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { - PyObject *dict = Py_TYPE(obj)->tp_dict; - if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) - return 0; - return obj_dict_version == __Pyx_get_object_dict_version(obj); -} -#endif - -/* GetModuleGlobalName */ -#if CYTHON_USE_DICT_VERSIONS -static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) -#else -static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) -#endif -{ - PyObject *result; -#if !CYTHON_AVOID_BORROWED_REFS -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && PY_VERSION_HEX < 0x030d0000 - result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } else if (unlikely(PyErr_Occurred())) { - return NULL; - } -#elif CYTHON_COMPILING_IN_LIMITED_API - if (unlikely(!__pyx_m)) { - return NULL; - } - result = PyObject_GetAttr(__pyx_m, name); - if (likely(result)) { - return result; - } -#else - result = PyDict_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } -#endif -#else - result = PyObject_GetItem(__pyx_d, name); - __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) - if (likely(result)) { - return __Pyx_NewRef(result); - } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); -} - -/* UnpackUnboundCMethod */ -static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { - PyObject *result; - PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); - if (unlikely(!selfless_args)) return NULL; - result = PyObject_Call(method, selfless_args, kwargs); - Py_DECREF(selfless_args); - return result; -} -static PyMethodDef __Pyx_UnboundCMethod_Def = { - "CythonUnboundCMethod", - __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), - METH_VARARGS | METH_KEYWORDS, - NULL -}; -static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { - PyObject *method; - method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); - if (unlikely(!method)) - return -1; - target->method = method; -#if CYTHON_COMPILING_IN_CPYTHON - #if PY_MAJOR_VERSION >= 3 - if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) - #else - if (likely(!__Pyx_CyOrPyCFunction_Check(method))) - #endif - { - PyMethodDescrObject *descr = (PyMethodDescrObject*) method; - target->func = descr->d_method->ml_meth; - target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); - } else -#endif -#if CYTHON_COMPILING_IN_PYPY -#else - if (PyCFunction_Check(method)) -#endif - { - PyObject *self; - int self_found; -#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY - self = PyObject_GetAttrString(method, "__self__"); - if (!self) { - PyErr_Clear(); - } -#else - self = PyCFunction_GET_SELF(method); -#endif - self_found = (self && self != Py_None); -#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY - Py_XDECREF(self); -#endif - if (self_found) { - PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); - if (unlikely(!unbound_method)) return -1; - Py_DECREF(method); - target->method = unbound_method; - } - } - return 0; -} - -/* CallUnboundCMethod1 */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg) { - if (likely(cfunc->func)) { - int flag = cfunc->flag; - if (flag == METH_O) { - return (*(cfunc->func))(self, arg); - } else if ((PY_VERSION_HEX >= 0x030600B1) && flag == METH_FASTCALL) { - #if PY_VERSION_HEX >= 0x030700A0 - return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, &arg, 1); - #else - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - #endif - } else if ((PY_VERSION_HEX >= 0x030700A0) && flag == (METH_FASTCALL | METH_KEYWORDS)) { - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, &arg, 1, NULL); - } - } - return __Pyx__CallUnboundCMethod1(cfunc, self, arg); -} -#endif -static PyObject* __Pyx__CallUnboundCMethod1(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg){ - PyObject *args, *result = NULL; - if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; -#if CYTHON_COMPILING_IN_CPYTHON - if (cfunc->func && (cfunc->flag & METH_VARARGS)) { - args = PyTuple_New(1); - if (unlikely(!args)) goto bad; - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 0, arg); - if (cfunc->flag & METH_KEYWORDS) - result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); - else - result = (*cfunc->func)(self, args); - } else { - args = PyTuple_New(2); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); - Py_INCREF(arg); - PyTuple_SET_ITEM(args, 1, arg); - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - } -#else - args = PyTuple_Pack(2, self, arg); - if (unlikely(!args)) goto bad; - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); -#endif -bad: - Py_XDECREF(args); - return result; -} - -/* CallUnboundCMethod2 */ -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030600B1 -static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { - if (likely(cfunc->func)) { - PyObject *args[2] = {arg1, arg2}; - if (cfunc->flag == METH_FASTCALL) { - #if PY_VERSION_HEX >= 0x030700A0 - return (*(__Pyx_PyCFunctionFast)(void*)(PyCFunction)cfunc->func)(self, args, 2); - #else - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); - #endif - } - #if PY_VERSION_HEX >= 0x030700A0 - if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) - return (*(__Pyx_PyCFunctionFastWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, 2, NULL); - #endif - } - return __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); -} -#endif -static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ - PyObject *args, *result = NULL; - if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; -#if CYTHON_COMPILING_IN_CPYTHON - if (cfunc->func && (cfunc->flag & METH_VARARGS)) { - args = PyTuple_New(2); - if (unlikely(!args)) goto bad; - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 0, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 1, arg2); - if (cfunc->flag & METH_KEYWORDS) - result = (*(PyCFunctionWithKeywords)(void*)(PyCFunction)cfunc->func)(self, args, NULL); - else - result = (*cfunc->func)(self, args); - } else { - args = PyTuple_New(3); - if (unlikely(!args)) goto bad; - Py_INCREF(self); - PyTuple_SET_ITEM(args, 0, self); - Py_INCREF(arg1); - PyTuple_SET_ITEM(args, 1, arg1); - Py_INCREF(arg2); - PyTuple_SET_ITEM(args, 2, arg2); - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); - } -#else - args = PyTuple_Pack(3, self, arg1, arg2); - if (unlikely(!args)) goto bad; - result = __Pyx_PyObject_Call(cfunc->method, args, NULL); -#endif -bad: - Py_XDECREF(args); - return result; -} - -/* dict_getitem_default */ -static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { - PyObject* value; -#if PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (unlikely(PyErr_Occurred())) - return NULL; - value = default_value; - } - Py_INCREF(value); - if ((1)); -#else - if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { - value = PyDict_GetItem(d, key); - if (unlikely(!value)) { - value = default_value; - } - Py_INCREF(value); - } -#endif - else { - if (default_value == Py_None) - value = __Pyx_CallUnboundCMethod1(&__pyx_umethod_PyDict_Type_get, d, key); - else - value = __Pyx_CallUnboundCMethod2(&__pyx_umethod_PyDict_Type_get, d, key, default_value); - } - return value; -} - -/* JoinPyUnicode */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char) { -#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyObject *result_uval; - int result_ukind, kind_shift; - Py_ssize_t i, char_pos; - void *result_udata; - CYTHON_MAYBE_UNUSED_VAR(max_char); -#if CYTHON_PEP393_ENABLED - result_uval = PyUnicode_New(result_ulength, max_char); - if (unlikely(!result_uval)) return NULL; - result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; - kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; - result_udata = PyUnicode_DATA(result_uval); -#else - result_uval = PyUnicode_FromUnicode(NULL, result_ulength); - if (unlikely(!result_uval)) return NULL; - result_ukind = sizeof(Py_UNICODE); - kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; - result_udata = PyUnicode_AS_UNICODE(result_uval); -#endif - assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); - char_pos = 0; - for (i=0; i < value_count; i++) { - int ukind; - Py_ssize_t ulength; - void *udata; - PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); - if (unlikely(__Pyx_PyUnicode_READY(uval))) - goto bad; - ulength = __Pyx_PyUnicode_GET_LENGTH(uval); - if (unlikely(!ulength)) - continue; - if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) - goto overflow; - ukind = __Pyx_PyUnicode_KIND(uval); - udata = __Pyx_PyUnicode_DATA(uval); - if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { - memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); - } else { - #if PY_VERSION_HEX >= 0x030d0000 - if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; - #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) - _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); - #else - Py_ssize_t j; - for (j=0; j < ulength; j++) { - Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); - __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); - } - #endif - } - char_pos += ulength; - } - return result_uval; -overflow: - PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); -bad: - Py_DECREF(result_uval); - return NULL; -#else - CYTHON_UNUSED_VAR(max_char); - CYTHON_UNUSED_VAR(result_ulength); - CYTHON_UNUSED_VAR(value_count); - return PyUnicode_Join(__pyx_empty_unicode, value_tuple); -#endif -} - -/* DictGetItem */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } - return NULL; - } - Py_INCREF(value); - return value; -} -#endif - -/* PyObjectCallNoArg */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { - PyObject *arg[2] = {NULL, NULL}; - return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); -} - -/* PyObjectGetMethod */ -static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { - PyObject *attr; -#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP - __Pyx_TypeName type_name; - PyTypeObject *tp = Py_TYPE(obj); - PyObject *descr; - descrgetfunc f = NULL; - PyObject **dictptr, *dict; - int meth_found = 0; - assert (*method == NULL); - if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; - } - if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { - return 0; - } - descr = _PyType_Lookup(tp, name); - if (likely(descr != NULL)) { - Py_INCREF(descr); -#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR - if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) -#elif PY_MAJOR_VERSION >= 3 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) - #endif -#else - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif -#endif - { - meth_found = 1; - } else { - f = Py_TYPE(descr)->tp_descr_get; - if (f != NULL && PyDescr_IsData(descr)) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - } - } - dictptr = _PyObject_GetDictPtr(obj); - if (dictptr != NULL && (dict = *dictptr) != NULL) { - Py_INCREF(dict); - attr = __Pyx_PyDict_GetItemStr(dict, name); - if (attr != NULL) { - Py_INCREF(attr); - Py_DECREF(dict); - Py_XDECREF(descr); - goto try_unpack; - } - Py_DECREF(dict); - } - if (meth_found) { - *method = descr; - return 1; - } - if (f != NULL) { - attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); - Py_DECREF(descr); - goto try_unpack; - } - if (likely(descr != NULL)) { - *method = descr; - return 0; - } - type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return 0; -#else - attr = __Pyx_PyObject_GetAttrStr(obj, name); - goto try_unpack; -#endif -try_unpack: -#if CYTHON_UNPACK_METHODS - if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { - PyObject *function = PyMethod_GET_FUNCTION(attr); - Py_INCREF(function); - Py_DECREF(attr); - *method = function; - return 1; - } -#endif - *method = attr; - return 0; -} - -/* PyObjectCallMethod0 */ -static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { - PyObject *method = NULL, *result = NULL; - int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); - if (likely(is_method)) { - result = __Pyx_PyObject_CallOneArg(method, obj); - Py_DECREF(method); - return result; - } - if (unlikely(!method)) goto bad; - result = __Pyx_PyObject_CallNoArg(method); - Py_DECREF(method); -bad: - return result; -} - -/* RaiseNoneIterError */ -static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { - PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); -} - -/* UnpackTupleError */ -static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { - if (t == Py_None) { - __Pyx_RaiseNoneNotIterableError(); - } else if (PyTuple_GET_SIZE(t) < index) { - __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t)); - } else { - __Pyx_RaiseTooManyValuesError(index); - } -} - -/* UnpackTuple2 */ -static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( - PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { - PyObject *value1 = NULL, *value2 = NULL; -#if CYTHON_COMPILING_IN_PYPY - value1 = PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; - value2 = PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; -#else - value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); - value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); -#endif - if (decref_tuple) { - Py_DECREF(tuple); - } - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -#if CYTHON_COMPILING_IN_PYPY -bad: - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -#endif -} -static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, - int has_known_size, int decref_tuple) { - Py_ssize_t index; - PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; - iternextfunc iternext; - iter = PyObject_GetIter(tuple); - if (unlikely(!iter)) goto bad; - if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } - iternext = __Pyx_PyObject_GetIterNextFunc(iter); - value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } - value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } - if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; - Py_DECREF(iter); - *pvalue1 = value1; - *pvalue2 = value2; - return 0; -unpacking_failed: - if (!has_known_size && __Pyx_IterFinish() == 0) - __Pyx_RaiseNeedMoreValuesError(index); -bad: - Py_XDECREF(iter); - Py_XDECREF(value1); - Py_XDECREF(value2); - if (decref_tuple) { Py_XDECREF(tuple); } - return -1; -} - -/* dict_iter */ -#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 -#include -#endif -static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, - Py_ssize_t* p_orig_length, int* p_source_is_dict) { - is_dict = is_dict || likely(PyDict_CheckExact(iterable)); - *p_source_is_dict = is_dict; - if (is_dict) { -#if !CYTHON_COMPILING_IN_PYPY - *p_orig_length = PyDict_Size(iterable); - Py_INCREF(iterable); - return iterable; -#elif PY_MAJOR_VERSION >= 3 - static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; - PyObject **pp = NULL; - if (method_name) { - const char *name = PyUnicode_AsUTF8(method_name); - if (strcmp(name, "iteritems") == 0) pp = &py_items; - else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; - else if (strcmp(name, "itervalues") == 0) pp = &py_values; - if (pp) { - if (!*pp) { - *pp = PyUnicode_FromString(name + 4); - if (!*pp) - return NULL; - } - method_name = *pp; - } - } -#endif - } - *p_orig_length = 0; - if (method_name) { - PyObject* iter; - iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); - if (!iterable) - return NULL; -#if !CYTHON_COMPILING_IN_PYPY - if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) - return iterable; -#endif - iter = PyObject_GetIter(iterable); - Py_DECREF(iterable); - return iter; - } - return PyObject_GetIter(iterable); -} -static CYTHON_INLINE int __Pyx_dict_iter_next( - PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, - PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { - PyObject* next_item; -#if !CYTHON_COMPILING_IN_PYPY - if (source_is_dict) { - PyObject *key, *value; - if (unlikely(orig_length != PyDict_Size(iter_obj))) { - PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); - return -1; - } - if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { - return 0; - } - if (pitem) { - PyObject* tuple = PyTuple_New(2); - if (unlikely(!tuple)) { - return -1; - } - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(tuple, 0, key); - PyTuple_SET_ITEM(tuple, 1, value); - *pitem = tuple; - } else { - if (pkey) { - Py_INCREF(key); - *pkey = key; - } - if (pvalue) { - Py_INCREF(value); - *pvalue = value; - } - } - return 1; - } else if (PyTuple_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyTuple_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else if (PyList_CheckExact(iter_obj)) { - Py_ssize_t pos = *ppos; - if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; - *ppos = pos + 1; - next_item = PyList_GET_ITEM(iter_obj, pos); - Py_INCREF(next_item); - } else -#endif - { - next_item = PyIter_Next(iter_obj); - if (unlikely(!next_item)) { - return __Pyx_IterFinish(); - } - } - if (pitem) { - *pitem = next_item; - } else if (pkey && pvalue) { - if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) - return -1; - } else if (pkey) { - *pkey = next_item; - } else { - *pvalue = next_item; - } - return 1; -} - -/* KeywordStringCheck */ -static int __Pyx_CheckKeywordStrings( - PyObject *kw, - const char* function_name, - int kw_allowed) -{ - PyObject* key = 0; - Py_ssize_t pos = 0; -#if CYTHON_COMPILING_IN_PYPY - if (!kw_allowed && PyDict_Next(kw, &pos, &key, 0)) - goto invalid_keyword; - return 1; -#else - if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { - Py_ssize_t kwsize; -#if CYTHON_ASSUME_SAFE_MACROS - kwsize = PyTuple_GET_SIZE(kw); -#else - kwsize = PyTuple_Size(kw); - if (kwsize < 0) return 0; -#endif - if (unlikely(kwsize == 0)) - return 1; - if (!kw_allowed) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, 0); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - goto invalid_keyword; - } -#if PY_VERSION_HEX < 0x03090000 - for (pos = 0; pos < kwsize; pos++) { -#if CYTHON_ASSUME_SAFE_MACROS - key = PyTuple_GET_ITEM(kw, pos); -#else - key = PyTuple_GetItem(kw, pos); - if (!key) return 0; -#endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } -#endif - return 1; - } - while (PyDict_Next(kw, &pos, &key, 0)) { - #if PY_MAJOR_VERSION < 3 - if (unlikely(!PyString_Check(key))) - #endif - if (unlikely(!PyUnicode_Check(key))) - goto invalid_keyword_type; - } - if (!kw_allowed && unlikely(key)) - goto invalid_keyword; - return 1; -invalid_keyword_type: - PyErr_Format(PyExc_TypeError, - "%.200s() keywords must be strings", function_name); - return 0; -#endif -invalid_keyword: - #if PY_MAJOR_VERSION < 3 - PyErr_Format(PyExc_TypeError, - "%.200s() got an unexpected keyword argument '%.200s'", - function_name, PyString_AsString(key)); - #else - PyErr_Format(PyExc_TypeError, - "%s() got an unexpected keyword argument '%U'", - function_name, key); - #endif - return 0; -} - -/* ObjectGetItem */ -#if CYTHON_USE_TYPE_SLOTS -static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { - PyObject *runerr = NULL; - Py_ssize_t key_value; - key_value = __Pyx_PyIndex_AsSsize_t(index); - if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { - return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); - } - if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { - __Pyx_TypeName index_type_name = __Pyx_PyType_GetName(Py_TYPE(index)); - PyErr_Clear(); - PyErr_Format(PyExc_IndexError, - "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); - __Pyx_DECREF_TypeName(index_type_name); - } - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { - __Pyx_TypeName obj_type_name; - if (likely(PyType_Check(obj))) { - PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_n_s_class_getitem); - if (!meth) { - PyErr_Clear(); - } else { - PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); - Py_DECREF(meth); - return result; - } - } - obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, - "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return NULL; -} -static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { - PyTypeObject *tp = Py_TYPE(obj); - PyMappingMethods *mm = tp->tp_as_mapping; - PySequenceMethods *sm = tp->tp_as_sequence; - if (likely(mm && mm->mp_subscript)) { - return mm->mp_subscript(obj, key); - } - if (likely(sm && sm->sq_item)) { - return __Pyx_PyObject_GetIndex(obj, key); - } - return __Pyx_PyObject_GetItem_Slow(obj, key); -} -#endif - -/* RaiseUnexpectedTypeError */ -static int -__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) -{ - __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); - PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, - expected, obj_type_name); - __Pyx_DECREF_TypeName(obj_type_name); - return 0; -} - -/* FixUpExtensionType */ -#if CYTHON_USE_TYPE_SPECS -static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { -#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - CYTHON_UNUSED_VAR(spec); - CYTHON_UNUSED_VAR(type); -#else - const PyType_Slot *slot = spec->slots; - while (slot && slot->slot && slot->slot != Py_tp_members) - slot++; - if (slot && slot->slot == Py_tp_members) { - int changed = 0; -#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) - const -#endif - PyMemberDef *memb = (PyMemberDef*) slot->pfunc; - while (memb && memb->name) { - if (memb->name[0] == '_' && memb->name[1] == '_') { -#if PY_VERSION_HEX < 0x030900b1 - if (strcmp(memb->name, "__weaklistoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_weaklistoffset = memb->offset; - changed = 1; - } - else if (strcmp(memb->name, "__dictoffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); - type->tp_dictoffset = memb->offset; - changed = 1; - } -#if CYTHON_METH_FASTCALL - else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); -#if PY_VERSION_HEX >= 0x030800b4 - type->tp_vectorcall_offset = memb->offset; -#else - type->tp_print = (printfunc) memb->offset; -#endif - changed = 1; - } -#endif -#else - if ((0)); -#endif -#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON - else if (strcmp(memb->name, "__module__") == 0) { - PyObject *descr; - assert(memb->type == T_OBJECT); - assert(memb->flags == 0 || memb->flags == READONLY); - descr = PyDescr_NewMember(type, memb); - if (unlikely(!descr)) - return -1; - if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { - Py_DECREF(descr); - return -1; - } - Py_DECREF(descr); - changed = 1; - } -#endif - } - memb++; - } - if (changed) - PyType_Modified(type); - } -#endif - return 0; -} -#endif - -/* ValidateBasesTuple */ -#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS -static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { - Py_ssize_t i, n; -#if CYTHON_ASSUME_SAFE_MACROS - n = PyTuple_GET_SIZE(bases); -#else - n = PyTuple_Size(bases); - if (n < 0) return -1; -#endif - for (i = 1; i < n; i++) - { -#if CYTHON_AVOID_BORROWED_REFS - PyObject *b0 = PySequence_GetItem(bases, i); - if (!b0) return -1; -#elif CYTHON_ASSUME_SAFE_MACROS - PyObject *b0 = PyTuple_GET_ITEM(bases, i); -#else - PyObject *b0 = PyTuple_GetItem(bases, i); - if (!b0) return -1; -#endif - PyTypeObject *b; -#if PY_MAJOR_VERSION < 3 - if (PyClass_Check(b0)) - { - PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", - PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } -#endif - b = (PyTypeObject*) b0; - if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); - __Pyx_DECREF_TypeName(b_name); -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - if (dictoffset == 0) - { - Py_ssize_t b_dictoffset = 0; -#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY - b_dictoffset = b->tp_dictoffset; -#else - PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); - if (!py_b_dictoffset) goto dictoffset_return; - b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); - Py_DECREF(py_b_dictoffset); - if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; -#endif - if (b_dictoffset) { - { - __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); - PyErr_Format(PyExc_TypeError, - "extension type '%.200s' has no __dict__ slot, " - "but base type '" __Pyx_FMT_TYPENAME "' has: " - "either add 'cdef dict __dict__' to the extension type " - "or add '__slots__ = [...]' to the base type", - type_name, b_name); - __Pyx_DECREF_TypeName(b_name); - } -#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) - dictoffset_return: -#endif -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - return -1; - } - } -#if CYTHON_AVOID_BORROWED_REFS - Py_DECREF(b0); -#endif - } - return 0; -} -#endif - -/* PyType_Ready */ -static int __Pyx_PyType_Ready(PyTypeObject *t) { -#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) - (void)__Pyx_PyObject_CallMethod0; -#if CYTHON_USE_TYPE_SPECS - (void)__Pyx_validate_bases_tuple; -#endif - return PyType_Ready(t); -#else - int r; - PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); - if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) - return -1; -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - { - int gc_was_enabled; - #if PY_VERSION_HEX >= 0x030A00b1 - gc_was_enabled = PyGC_Disable(); - (void)__Pyx_PyObject_CallMethod0; - #else - PyObject *ret, *py_status; - PyObject *gc = NULL; - #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) - gc = PyImport_GetModule(__pyx_kp_u_gc); - #endif - if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); - if (unlikely(!gc)) return -1; - py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); - if (unlikely(!py_status)) { - Py_DECREF(gc); - return -1; - } - gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); - Py_DECREF(py_status); - if (gc_was_enabled > 0) { - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); - if (unlikely(!ret)) { - Py_DECREF(gc); - return -1; - } - Py_DECREF(ret); - } else if (unlikely(gc_was_enabled == -1)) { - Py_DECREF(gc); - return -1; - } - #endif - t->tp_flags |= Py_TPFLAGS_HEAPTYPE; -#if PY_VERSION_HEX >= 0x030A0000 - t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; -#endif -#else - (void)__Pyx_PyObject_CallMethod0; -#endif - r = PyType_Ready(t); -#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) - t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; - #if PY_VERSION_HEX >= 0x030A00b1 - if (gc_was_enabled) - PyGC_Enable(); - #else - if (gc_was_enabled) { - PyObject *tp, *v, *tb; - PyErr_Fetch(&tp, &v, &tb); - ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); - if (likely(ret || r == -1)) { - Py_XDECREF(ret); - PyErr_Restore(tp, v, tb); - } else { - Py_XDECREF(tp); - Py_XDECREF(v); - Py_XDECREF(tb); - r = -1; - } - } - Py_DECREF(gc); - #endif - } -#endif - return r; -#endif -} - -/* PyObject_GenericGetAttrNoDict */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { - __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); - PyErr_Format(PyExc_AttributeError, -#if PY_MAJOR_VERSION >= 3 - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", - type_name, attr_name); -#else - "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", - type_name, PyString_AS_STRING(attr_name)); -#endif - __Pyx_DECREF_TypeName(type_name); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { - PyObject *descr; - PyTypeObject *tp = Py_TYPE(obj); - if (unlikely(!PyString_Check(attr_name))) { - return PyObject_GenericGetAttr(obj, attr_name); - } - assert(!tp->tp_dictoffset); - descr = _PyType_Lookup(tp, attr_name); - if (unlikely(!descr)) { - return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); - } - Py_INCREF(descr); - #if PY_MAJOR_VERSION < 3 - if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) - #endif - { - descrgetfunc f = Py_TYPE(descr)->tp_descr_get; - if (unlikely(f)) { - PyObject *res = f(descr, obj, (PyObject *)tp); - Py_DECREF(descr); - return res; - } - } - return descr; -} -#endif - -/* PyObject_GenericGetAttr */ -#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 -static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { - if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { - return PyObject_GenericGetAttr(obj, attr_name); - } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); -} -#endif - -/* SetupReduce */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { - int ret; - PyObject *name_attr; - name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_n_s_name); - if (likely(name_attr)) { - ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); - } else { - ret = -1; - } - if (unlikely(ret < 0)) { - PyErr_Clear(); - ret = 0; - } - Py_XDECREF(name_attr); - return ret; -} -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); -#else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); -#else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } -#endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; -#endif - reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; - if (reduce_ex == object_reduce_ex) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; -#endif - reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; - if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { - reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); - if (likely(reduce_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (reduce == object_reduce || PyErr_Occurred()) { - goto __PYX_BAD; - } - setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate); - if (!setstate) PyErr_Clear(); - if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { - setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); - if (likely(setstate_cython)) { - ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; - } else if (!setstate || PyErr_Occurred()) { - goto __PYX_BAD; - } - } - PyType_Modified((PyTypeObject*)type_obj); - } - } - goto __PYX_GOOD; -__PYX_BAD: - if (!PyErr_Occurred()) { - __Pyx_TypeName type_obj_name = - __Pyx_PyType_GetName((PyTypeObject*)type_obj); - PyErr_Format(PyExc_RuntimeError, - "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); - __Pyx_DECREF_TypeName(type_obj_name); - } - ret = -1; -__PYX_GOOD: -#if !CYTHON_USE_PYTYPE_LOOKUP - Py_XDECREF(object_reduce); - Py_XDECREF(object_reduce_ex); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; -} -#endif - -/* Import */ -static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { - PyObject *module = 0; - PyObject *empty_dict = 0; - PyObject *empty_list = 0; - #if PY_MAJOR_VERSION < 3 - PyObject *py_import; - py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); - if (unlikely(!py_import)) - goto bad; - if (!from_list) { - empty_list = PyList_New(0); - if (unlikely(!empty_list)) - goto bad; - from_list = empty_list; - } - #endif - empty_dict = PyDict_New(); - if (unlikely(!empty_dict)) - goto bad; - { - #if PY_MAJOR_VERSION >= 3 - if (level == -1) { - if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, 1); - if (unlikely(!module)) { - if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) - goto bad; - PyErr_Clear(); - } - } - level = 0; - } - #endif - if (!module) { - #if PY_MAJOR_VERSION < 3 - PyObject *py_level = PyInt_FromLong(level); - if (unlikely(!py_level)) - goto bad; - module = PyObject_CallFunctionObjArgs(py_import, - name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); - Py_DECREF(py_level); - #else - module = PyImport_ImportModuleLevelObject( - name, __pyx_d, empty_dict, from_list, level); - #endif - } - } -bad: - Py_XDECREF(empty_dict); - Py_XDECREF(empty_list); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_import); - #endif - return module; -} - -/* ImportDottedModule */ -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Error(PyObject *name, PyObject *parts_tuple, Py_ssize_t count) { - PyObject *partial_name = NULL, *slice = NULL, *sep = NULL; - if (unlikely(PyErr_Occurred())) { - PyErr_Clear(); - } - if (likely(PyTuple_GET_SIZE(parts_tuple) == count)) { - partial_name = name; - } else { - slice = PySequence_GetSlice(parts_tuple, 0, count); - if (unlikely(!slice)) - goto bad; - sep = PyUnicode_FromStringAndSize(".", 1); - if (unlikely(!sep)) - goto bad; - partial_name = PyUnicode_Join(sep, slice); - } - PyErr_Format( -#if PY_MAJOR_VERSION < 3 - PyExc_ImportError, - "No module named '%s'", PyString_AS_STRING(partial_name)); -#else -#if PY_VERSION_HEX >= 0x030600B1 - PyExc_ModuleNotFoundError, -#else - PyExc_ImportError, -#endif - "No module named '%U'", partial_name); -#endif -bad: - Py_XDECREF(sep); - Py_XDECREF(slice); - Py_XDECREF(partial_name); - return NULL; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx__ImportDottedModule_Lookup(PyObject *name) { - PyObject *imported_module; -#if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - return NULL; - imported_module = __Pyx_PyDict_GetItemStr(modules, name); - Py_XINCREF(imported_module); -#else - imported_module = PyImport_GetModule(name); -#endif - return imported_module; -} -#endif -#if PY_MAJOR_VERSION >= 3 -static PyObject *__Pyx_ImportDottedModule_WalkParts(PyObject *module, PyObject *name, PyObject *parts_tuple) { - Py_ssize_t i, nparts; - nparts = PyTuple_GET_SIZE(parts_tuple); - for (i=1; i < nparts && module; i++) { - PyObject *part, *submodule; -#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - part = PyTuple_GET_ITEM(parts_tuple, i); -#else - part = PySequence_ITEM(parts_tuple, i); -#endif - submodule = __Pyx_PyObject_GetAttrStrNoError(module, part); -#if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(part); -#endif - Py_DECREF(module); - module = submodule; - } - if (unlikely(!module)) { - return __Pyx__ImportDottedModule_Error(name, parts_tuple, i); - } - return module; -} -#endif -static PyObject *__Pyx__ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if PY_MAJOR_VERSION < 3 - PyObject *module, *from_list, *star = __pyx_n_s__4; - CYTHON_UNUSED_VAR(parts_tuple); - from_list = PyList_New(1); - if (unlikely(!from_list)) - return NULL; - Py_INCREF(star); - PyList_SET_ITEM(from_list, 0, star); - module = __Pyx_Import(name, from_list, 0); - Py_DECREF(from_list); - return module; -#else - PyObject *imported_module; - PyObject *module = __Pyx_Import(name, NULL, 0); - if (!parts_tuple || unlikely(!module)) - return module; - imported_module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(imported_module)) { - Py_DECREF(module); - return imported_module; - } - PyErr_Clear(); - return __Pyx_ImportDottedModule_WalkParts(module, name, parts_tuple); -#endif -} -static PyObject *__Pyx_ImportDottedModule(PyObject *name, PyObject *parts_tuple) { -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030400B1 - PyObject *module = __Pyx__ImportDottedModule_Lookup(name); - if (likely(module)) { - PyObject *spec = __Pyx_PyObject_GetAttrStrNoError(module, __pyx_n_s_spec); - if (likely(spec)) { - PyObject *unsafe = __Pyx_PyObject_GetAttrStrNoError(spec, __pyx_n_s_initializing); - if (likely(!unsafe || !__Pyx_PyObject_IsTrue(unsafe))) { - Py_DECREF(spec); - spec = NULL; - } - Py_XDECREF(unsafe); - } - if (likely(!spec)) { - PyErr_Clear(); - return module; - } - Py_DECREF(spec); - Py_DECREF(module); - } else if (PyErr_Occurred()) { - PyErr_Clear(); - } -#endif - return __Pyx__ImportDottedModule(name, parts_tuple); -} - -/* ImportFrom */ -static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { - PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); - if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { - const char* module_name_str = 0; - PyObject* module_name = 0; - PyObject* module_dot = 0; - PyObject* full_name = 0; - PyErr_Clear(); - module_name_str = PyModule_GetName(module); - if (unlikely(!module_name_str)) { goto modbad; } - module_name = PyUnicode_FromString(module_name_str); - if (unlikely(!module_name)) { goto modbad; } - module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__5); - if (unlikely(!module_dot)) { goto modbad; } - full_name = PyUnicode_Concat(module_dot, name); - if (unlikely(!full_name)) { goto modbad; } - #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) - { - PyObject *modules = PyImport_GetModuleDict(); - if (unlikely(!modules)) - goto modbad; - value = PyObject_GetItem(modules, full_name); - } - #else - value = PyImport_GetModule(full_name); - #endif - modbad: - Py_XDECREF(full_name); - Py_XDECREF(module_dot); - Py_XDECREF(module_name); - } - if (unlikely(!value)) { - PyErr_Format(PyExc_ImportError, - #if PY_MAJOR_VERSION < 3 - "cannot import name %.230s", PyString_AS_STRING(name)); - #else - "cannot import name %S", name); - #endif - } - return value; -} - -/* FetchSharedCythonModule */ -static PyObject *__Pyx_FetchSharedCythonABIModule(void) { - return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); -} - -/* FetchCommonType */ -static int __Pyx_VerifyCachedType(PyObject *cached_type, - const char *name, - Py_ssize_t basicsize, - Py_ssize_t expected_basicsize) { - if (!PyType_Check(cached_type)) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s is not a type object", name); - return -1; - } - if (basicsize != expected_basicsize) { - PyErr_Format(PyExc_TypeError, - "Shared Cython type %.200s has the wrong size, try recompiling", - name); - return -1; - } - return 0; -} -#if !CYTHON_USE_TYPE_SPECS -static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { - PyObject* abi_module; - const char* object_name; - PyTypeObject *cached_type = NULL; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - object_name = strrchr(type->tp_name, '.'); - object_name = object_name ? object_name+1 : type->tp_name; - cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - if (__Pyx_VerifyCachedType( - (PyObject *)cached_type, - object_name, - cached_type->tp_basicsize, - type->tp_basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - if (PyType_Ready(type) < 0) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) - goto bad; - Py_INCREF(type); - cached_type = type; -done: - Py_DECREF(abi_module); - return cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#else -static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { - PyObject *abi_module, *cached_type = NULL; - const char* object_name = strrchr(spec->name, '.'); - object_name = object_name ? object_name+1 : spec->name; - abi_module = __Pyx_FetchSharedCythonABIModule(); - if (!abi_module) return NULL; - cached_type = PyObject_GetAttrString(abi_module, object_name); - if (cached_type) { - Py_ssize_t basicsize; -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *py_basicsize; - py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); - if (unlikely(!py_basicsize)) goto bad; - basicsize = PyLong_AsSsize_t(py_basicsize); - Py_DECREF(py_basicsize); - py_basicsize = 0; - if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; -#else - basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; -#endif - if (__Pyx_VerifyCachedType( - cached_type, - object_name, - basicsize, - spec->basicsize) < 0) { - goto bad; - } - goto done; - } - if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; - PyErr_Clear(); - CYTHON_UNUSED_VAR(module); - cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); - if (unlikely(!cached_type)) goto bad; - if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; - if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; -done: - Py_DECREF(abi_module); - assert(cached_type == NULL || PyType_Check(cached_type)); - return (PyTypeObject *) cached_type; -bad: - Py_XDECREF(cached_type); - cached_type = NULL; - goto done; -} -#endif - -/* PyVectorcallFastCallDict */ -#if CYTHON_METH_FASTCALL -static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - PyObject *res = NULL; - PyObject *kwnames; - PyObject **newargs; - PyObject **kwvalues; - Py_ssize_t i, pos; - size_t j; - PyObject *key, *value; - unsigned long keys_are_strings; - Py_ssize_t nkw = PyDict_GET_SIZE(kw); - newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); - if (unlikely(newargs == NULL)) { - PyErr_NoMemory(); - return NULL; - } - for (j = 0; j < nargs; j++) newargs[j] = args[j]; - kwnames = PyTuple_New(nkw); - if (unlikely(kwnames == NULL)) { - PyMem_Free(newargs); - return NULL; - } - kwvalues = newargs + nargs; - pos = i = 0; - keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; - while (PyDict_Next(kw, &pos, &key, &value)) { - keys_are_strings &= Py_TYPE(key)->tp_flags; - Py_INCREF(key); - Py_INCREF(value); - PyTuple_SET_ITEM(kwnames, i, key); - kwvalues[i] = value; - i++; - } - if (unlikely(!keys_are_strings)) { - PyErr_SetString(PyExc_TypeError, "keywords must be strings"); - goto cleanup; - } - res = vc(func, newargs, nargs, kwnames); -cleanup: - Py_DECREF(kwnames); - for (i = 0; i < nkw; i++) - Py_DECREF(kwvalues[i]); - PyMem_Free(newargs); - return res; -} -static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) -{ - if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { - return vc(func, args, nargs, NULL); - } - return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); -} -#endif - -/* CythonFunctionShared */ -#if CYTHON_COMPILING_IN_LIMITED_API -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - if (__Pyx_CyFunction_Check(func)) { - return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; - } else if (PyCFunction_Check(func)) { - return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; - } - return 0; -} -#else -static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { - return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; -} -#endif -static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - __Pyx_Py_XDECREF_SET( - __Pyx_CyFunction_GetClassObj(f), - ((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#else - __Pyx_Py_XDECREF_SET( - ((PyCMethodObject *) (f))->mm_class, - (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); -#endif -} -static PyObject * -__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) -{ - CYTHON_UNUSED_VAR(closure); - if (unlikely(op->func_doc == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); - if (unlikely(!op->func_doc)) return NULL; -#else - if (((PyCFunctionObject*)op)->m_ml->ml_doc) { -#if PY_MAJOR_VERSION >= 3 - op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#else - op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); -#endif - if (unlikely(op->func_doc == NULL)) - return NULL; - } else { - Py_INCREF(Py_None); - return Py_None; - } -#endif - } - Py_INCREF(op->func_doc); - return op->func_doc; -} -static int -__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (value == NULL) { - value = Py_None; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_doc, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_name == NULL)) { -#if CYTHON_COMPILING_IN_LIMITED_API - op->func_name = PyObject_GetAttrString(op->func, "__name__"); -#elif PY_MAJOR_VERSION >= 3 - op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#else - op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); -#endif - if (unlikely(op->func_name == NULL)) - return NULL; - } - Py_INCREF(op->func_name); - return op->func_name; -} -static int -__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__name__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_name, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_qualname); - return op->func_qualname; -} -static int -__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); -#if PY_MAJOR_VERSION >= 3 - if (unlikely(value == NULL || !PyUnicode_Check(value))) -#else - if (unlikely(value == NULL || !PyString_Check(value))) -#endif - { - PyErr_SetString(PyExc_TypeError, - "__qualname__ must be set to a string object"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_qualname, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(op->func_dict == NULL)) { - op->func_dict = PyDict_New(); - if (unlikely(op->func_dict == NULL)) - return NULL; - } - Py_INCREF(op->func_dict); - return op->func_dict; -} -static int -__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) -{ - CYTHON_UNUSED_VAR(context); - if (unlikely(value == NULL)) { - PyErr_SetString(PyExc_TypeError, - "function's dictionary may not be deleted"); - return -1; - } - if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "setting function's dictionary to a non-dict"); - return -1; - } - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->func_dict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(context); - Py_INCREF(op->func_globals); - return op->func_globals; -} -static PyObject * -__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) -{ - CYTHON_UNUSED_VAR(op); - CYTHON_UNUSED_VAR(context); - Py_INCREF(Py_None); - return Py_None; -} -static PyObject * -__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) -{ - PyObject* result = (op->func_code) ? op->func_code : Py_None; - CYTHON_UNUSED_VAR(context); - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { - int result = 0; - PyObject *res = op->defaults_getter((PyObject *) op); - if (unlikely(!res)) - return -1; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - op->defaults_tuple = PyTuple_GET_ITEM(res, 0); - Py_INCREF(op->defaults_tuple); - op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); - Py_INCREF(op->defaults_kwdict); - #else - op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); - if (unlikely(!op->defaults_tuple)) result = -1; - else { - op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); - if (unlikely(!op->defaults_kwdict)) result = -1; - } - #endif - Py_DECREF(res); - return result; -} -static int -__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__defaults__ must be set to a tuple object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_tuple; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_tuple; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value) { - value = Py_None; - } else if (unlikely(value != Py_None && !PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__kwdefaults__ must be set to a dict object"); - return -1; - } - PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " - "currently affect the values used in function calls", 1); - Py_INCREF(value); - __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->defaults_kwdict; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - if (op->defaults_getter) { - if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; - result = op->defaults_kwdict; - } else { - result = Py_None; - } - } - Py_INCREF(result); - return result; -} -static int -__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - if (!value || value == Py_None) { - value = NULL; - } else if (unlikely(!PyDict_Check(value))) { - PyErr_SetString(PyExc_TypeError, - "__annotations__ must be set to a dict object"); - return -1; - } - Py_XINCREF(value); - __Pyx_Py_XDECREF_SET(op->func_annotations, value); - return 0; -} -static PyObject * -__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { - PyObject* result = op->func_annotations; - CYTHON_UNUSED_VAR(context); - if (unlikely(!result)) { - result = PyDict_New(); - if (unlikely(!result)) return NULL; - op->func_annotations = result; - } - Py_INCREF(result); - return result; -} -static PyObject * -__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { - int is_coroutine; - CYTHON_UNUSED_VAR(context); - if (op->func_is_coroutine) { - return __Pyx_NewRef(op->func_is_coroutine); - } - is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; -#if PY_VERSION_HEX >= 0x03050000 - if (is_coroutine) { - PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; - fromlist = PyList_New(1); - if (unlikely(!fromlist)) return NULL; - Py_INCREF(marker); -#if CYTHON_ASSUME_SAFE_MACROS - PyList_SET_ITEM(fromlist, 0, marker); -#else - if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { - Py_DECREF(marker); - Py_DECREF(fromlist); - return NULL; - } -#endif - module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); - Py_DECREF(fromlist); - if (unlikely(!module)) goto ignore; - op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); - Py_DECREF(module); - if (likely(op->func_is_coroutine)) { - return __Pyx_NewRef(op->func_is_coroutine); - } -ignore: - PyErr_Clear(); - } -#endif - op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); - return __Pyx_NewRef(op->func_is_coroutine); -} -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject * -__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_GetAttrString(op->func, "__module__"); -} -static int -__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { - CYTHON_UNUSED_VAR(context); - return PyObject_SetAttrString(op->func, "__module__", value); -} -#endif -static PyGetSetDef __pyx_CyFunction_getsets[] = { - {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, - {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, - {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, - {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, - {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, - {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, - {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, - {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, - {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, - {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, - {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, -#if CYTHON_COMPILING_IN_LIMITED_API - {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, -#endif - {0, 0, 0, 0, 0} -}; -static PyMemberDef __pyx_CyFunction_members[] = { -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, -#endif -#if CYTHON_USE_TYPE_SPECS - {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, -#if CYTHON_METH_FASTCALL -#if CYTHON_BACKPORT_VECTORCALL - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, -#else -#if !CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, -#endif -#endif -#endif -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, -#else - {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, -#endif -#endif - {0, 0, 0, 0, 0} -}; -static PyObject * -__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) -{ - CYTHON_UNUSED_VAR(args); -#if PY_MAJOR_VERSION >= 3 - Py_INCREF(m->func_qualname); - return m->func_qualname; -#else - return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); -#endif -} -static PyMethodDef __pyx_CyFunction_methods[] = { - {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, - {0, 0, 0, 0} -}; -#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API -#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) -#else -#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) -#endif -static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { -#if !CYTHON_COMPILING_IN_LIMITED_API - PyCFunctionObject *cf = (PyCFunctionObject*) op; -#endif - if (unlikely(op == NULL)) - return NULL; -#if CYTHON_COMPILING_IN_LIMITED_API - op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); - if (unlikely(!op->func)) return NULL; -#endif - op->flags = flags; - __Pyx_CyFunction_weakreflist(op) = NULL; -#if !CYTHON_COMPILING_IN_LIMITED_API - cf->m_ml = ml; - cf->m_self = (PyObject *) op; -#endif - Py_XINCREF(closure); - op->func_closure = closure; -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_XINCREF(module); - cf->m_module = module; -#endif - op->func_dict = NULL; - op->func_name = NULL; - Py_INCREF(qualname); - op->func_qualname = qualname; - op->func_doc = NULL; -#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API - op->func_classobj = NULL; -#else - ((PyCMethodObject*)op)->mm_class = NULL; -#endif - op->func_globals = globals; - Py_INCREF(op->func_globals); - Py_XINCREF(code); - op->func_code = code; - op->defaults_pyobjects = 0; - op->defaults_size = 0; - op->defaults = NULL; - op->defaults_tuple = NULL; - op->defaults_kwdict = NULL; - op->defaults_getter = NULL; - op->func_annotations = NULL; - op->func_is_coroutine = NULL; -#if CYTHON_METH_FASTCALL - switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { - case METH_NOARGS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; - break; - case METH_O: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; - break; - case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; - break; - case METH_FASTCALL | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; - break; - case METH_VARARGS | METH_KEYWORDS: - __Pyx_CyFunction_func_vectorcall(op) = NULL; - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - Py_DECREF(op); - return NULL; - } -#endif - return (PyObject *) op; -} -static int -__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) -{ - Py_CLEAR(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_CLEAR(m->func); -#else - Py_CLEAR(((PyCFunctionObject*)m)->m_module); -#endif - Py_CLEAR(m->func_dict); - Py_CLEAR(m->func_name); - Py_CLEAR(m->func_qualname); - Py_CLEAR(m->func_doc); - Py_CLEAR(m->func_globals); - Py_CLEAR(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API -#if PY_VERSION_HEX < 0x030900B1 - Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); -#else - { - PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; - ((PyCMethodObject *) (m))->mm_class = NULL; - Py_XDECREF(cls); - } -#endif -#endif - Py_CLEAR(m->defaults_tuple); - Py_CLEAR(m->defaults_kwdict); - Py_CLEAR(m->func_annotations); - Py_CLEAR(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_XDECREF(pydefaults[i]); - PyObject_Free(m->defaults); - m->defaults = NULL; - } - return 0; -} -static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - if (__Pyx_CyFunction_weakreflist(m) != NULL) - PyObject_ClearWeakRefs((PyObject *) m); - __Pyx_CyFunction_clear(m); - __Pyx_PyHeapTypeObject_GC_Del(m); -} -static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) -{ - PyObject_GC_UnTrack(m); - __Pyx__CyFunction_dealloc(m); -} -static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) -{ - Py_VISIT(m->func_closure); -#if CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(m->func); -#else - Py_VISIT(((PyCFunctionObject*)m)->m_module); -#endif - Py_VISIT(m->func_dict); - Py_VISIT(m->func_name); - Py_VISIT(m->func_qualname); - Py_VISIT(m->func_doc); - Py_VISIT(m->func_globals); - Py_VISIT(m->func_code); -#if !CYTHON_COMPILING_IN_LIMITED_API - Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); -#endif - Py_VISIT(m->defaults_tuple); - Py_VISIT(m->defaults_kwdict); - Py_VISIT(m->func_is_coroutine); - if (m->defaults) { - PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); - int i; - for (i = 0; i < m->defaults_pyobjects; i++) - Py_VISIT(pydefaults[i]); - } - return 0; -} -static PyObject* -__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) -{ -#if PY_MAJOR_VERSION >= 3 - return PyUnicode_FromFormat("", - op->func_qualname, (void *)op); -#else - return PyString_FromFormat("", - PyString_AsString(op->func_qualname), (void *)op); -#endif -} -static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { -#if CYTHON_COMPILING_IN_LIMITED_API - PyObject *f = ((__pyx_CyFunctionObject*)func)->func; - PyObject *py_name = NULL; - PyCFunction meth; - int flags; - meth = PyCFunction_GetFunction(f); - if (unlikely(!meth)) return NULL; - flags = PyCFunction_GetFlags(f); - if (unlikely(flags < 0)) return NULL; -#else - PyCFunctionObject* f = (PyCFunctionObject*)func; - PyCFunction meth = f->m_ml->ml_meth; - int flags = f->m_ml->ml_flags; -#endif - Py_ssize_t size; - switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { - case METH_VARARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) - return (*meth)(self, arg); - break; - case METH_VARARGS | METH_KEYWORDS: - return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); - case METH_NOARGS: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 0)) - return (*meth)(self, NULL); -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - case METH_O: - if (likely(kw == NULL || PyDict_Size(kw) == 0)) { -#if CYTHON_ASSUME_SAFE_MACROS - size = PyTuple_GET_SIZE(arg); -#else - size = PyTuple_Size(arg); - if (unlikely(size < 0)) return NULL; -#endif - if (likely(size == 1)) { - PyObject *result, *arg0; - #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - arg0 = PyTuple_GET_ITEM(arg, 0); - #else - arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; - #endif - result = (*meth)(self, arg0); - #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) - Py_DECREF(arg0); - #endif - return result; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, - "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - py_name, size); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - f->m_ml->ml_name, size); -#endif - return NULL; - } - break; - default: - PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); - return NULL; - } -#if CYTHON_COMPILING_IN_LIMITED_API - py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); - if (!py_name) return NULL; - PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", - py_name); - Py_DECREF(py_name); -#else - PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", - f->m_ml->ml_name); -#endif - return NULL; -} -static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *self, *result; -#if CYTHON_COMPILING_IN_LIMITED_API - self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); - if (unlikely(!self) && PyErr_Occurred()) return NULL; -#else - self = ((PyCFunctionObject*)func)->m_self; -#endif - result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); - return result; -} -static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { - PyObject *result; - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; -#if CYTHON_METH_FASTCALL - __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); - if (vc) { -#if CYTHON_ASSUME_SAFE_MACROS - return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); -#else - (void) &__Pyx_PyVectorcall_FastCallDict; - return PyVectorcall_Call(func, args, kw); -#endif - } -#endif - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - Py_ssize_t argc; - PyObject *new_args; - PyObject *self; -#if CYTHON_ASSUME_SAFE_MACROS - argc = PyTuple_GET_SIZE(args); -#else - argc = PyTuple_Size(args); - if (unlikely(!argc) < 0) return NULL; -#endif - new_args = PyTuple_GetSlice(args, 1, argc); - if (unlikely(!new_args)) - return NULL; - self = PyTuple_GetItem(args, 0); - if (unlikely(!self)) { - Py_DECREF(new_args); -#if PY_MAJOR_VERSION > 2 - PyErr_Format(PyExc_TypeError, - "unbound method %.200S() needs an argument", - cyfunc->func_qualname); -#else - PyErr_SetString(PyExc_TypeError, - "unbound method needs an argument"); -#endif - return NULL; - } - result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); - Py_DECREF(new_args); - } else { - result = __Pyx_CyFunction_Call(func, args, kw); - } - return result; -} -#if CYTHON_METH_FASTCALL -static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) -{ - int ret = 0; - if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { - if (unlikely(nargs < 1)) { - PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", - ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - ret = 1; - } - if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); - return -1; - } - return ret; -} -static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 0)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, NULL); -} -static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - if (unlikely(nargs != 1)) { - PyErr_Format(PyExc_TypeError, - "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", - def->ml_name, nargs); - return NULL; - } - return def->ml_meth(self, args[0]); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); -} -static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) -{ - __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; - PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; - PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); -#if CYTHON_BACKPORT_VECTORCALL - Py_ssize_t nargs = (Py_ssize_t)nargsf; -#else - Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); -#endif - PyObject *self; - switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { - case 1: - self = args[0]; - args += 1; - nargs -= 1; - break; - case 0: - self = ((PyCFunctionObject*)cyfunc)->m_self; - break; - default: - return NULL; - } - return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); -} -#endif -#if CYTHON_USE_TYPE_SPECS -static PyType_Slot __pyx_CyFunctionType_slots[] = { - {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, - {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, - {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, - {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, - {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, - {Py_tp_methods, (void *)__pyx_CyFunction_methods}, - {Py_tp_members, (void *)__pyx_CyFunction_members}, - {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, - {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, - {0, 0}, -}; -static PyType_Spec __pyx_CyFunctionType_spec = { - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - __pyx_CyFunctionType_slots -}; -#else -static PyTypeObject __pyx_CyFunctionType_type = { - PyVarObject_HEAD_INIT(0, 0) - __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", - sizeof(__pyx_CyFunctionObject), - 0, - (destructor) __Pyx_CyFunction_dealloc, -#if !CYTHON_METH_FASTCALL - 0, -#elif CYTHON_BACKPORT_VECTORCALL - (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), -#else - offsetof(PyCFunctionObject, vectorcall), -#endif - 0, - 0, -#if PY_MAJOR_VERSION < 3 - 0, -#else - 0, -#endif - (reprfunc) __Pyx_CyFunction_repr, - 0, - 0, - 0, - 0, - __Pyx_CyFunction_CallAsMethod, - 0, - 0, - 0, - 0, -#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR - Py_TPFLAGS_METHOD_DESCRIPTOR | -#endif -#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL - _Py_TPFLAGS_HAVE_VECTORCALL | -#endif - Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, - 0, - (traverseproc) __Pyx_CyFunction_traverse, - (inquiry) __Pyx_CyFunction_clear, - 0, -#if PY_VERSION_HEX < 0x030500A0 - offsetof(__pyx_CyFunctionObject, func_weakreflist), -#else - offsetof(PyCFunctionObject, m_weakreflist), -#endif - 0, - 0, - __pyx_CyFunction_methods, - __pyx_CyFunction_members, - __pyx_CyFunction_getsets, - 0, - 0, - __Pyx_PyMethod_New, - 0, - offsetof(__pyx_CyFunctionObject, func_dict), - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, -#if PY_VERSION_HEX >= 0x030400a1 - 0, -#endif -#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) - 0, -#endif -#if __PYX_NEED_TP_PRINT_SLOT - 0, -#endif -#if PY_VERSION_HEX >= 0x030C0000 - 0, -#endif -#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 - 0, -#endif -}; -#endif -static int __pyx_CyFunction_init(PyObject *module) { -#if CYTHON_USE_TYPE_SPECS - __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); -#else - CYTHON_UNUSED_VAR(module); - __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); -#endif - if (unlikely(__pyx_CyFunctionType == NULL)) { - return -1; - } - return 0; -} -static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults = PyObject_Malloc(size); - if (unlikely(!m->defaults)) - return PyErr_NoMemory(); - memset(m->defaults, 0, size); - m->defaults_pyobjects = pyobjects; - m->defaults_size = size; - return m->defaults; -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_tuple = tuple; - Py_INCREF(tuple); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->defaults_kwdict = dict; - Py_INCREF(dict); -} -static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { - __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; - m->func_annotations = dict; - Py_INCREF(dict); -} - -/* CythonFunction */ -static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, - PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { - PyObject *op = __Pyx_CyFunction_Init( - PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), - ml, flags, qualname, closure, module, globals, code - ); - if (likely(op)) { - PyObject_GC_Track(op); - } - return op; -} - -/* CLineInTraceback */ -#ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { - PyObject *use_cline; - PyObject *ptype, *pvalue, *ptraceback; -#if CYTHON_COMPILING_IN_CPYTHON - PyObject **cython_runtime_dict; -#endif - CYTHON_MAYBE_UNUSED_VAR(tstate); - if (unlikely(!__pyx_cython_runtime)) { - return c_line; - } - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); -#if CYTHON_COMPILING_IN_CPYTHON - cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); - if (likely(cython_runtime_dict)) { - __PYX_PY_DICT_LOOKUP_IF_MODIFIED( - use_cline, *cython_runtime_dict, - __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) - } else -#endif - { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); - if (use_cline_obj) { - use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; - Py_DECREF(use_cline_obj); - } else { - PyErr_Clear(); - use_cline = NULL; - } - } - if (!use_cline) { - c_line = 0; - (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); - } - else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { - c_line = 0; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - return c_line; -} -#endif - -/* CodeObjectCache */ -#if !CYTHON_COMPILING_IN_LIMITED_API -static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { - int start = 0, mid = 0, end = count - 1; - if (end >= 0 && code_line > entries[end].code_line) { - return count; - } - while (start < end) { - mid = start + (end - start) / 2; - if (code_line < entries[mid].code_line) { - end = mid; - } else if (code_line > entries[mid].code_line) { - start = mid + 1; - } else { - return mid; - } - } - if (code_line <= entries[mid].code_line) { - return mid; - } else { - return mid + 1; - } -} -static PyCodeObject *__pyx_find_code_object(int code_line) { - PyCodeObject* code_object; - int pos; - if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { - return NULL; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { - return NULL; - } - code_object = __pyx_code_cache.entries[pos].code_object; - Py_INCREF(code_object); - return code_object; -} -static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { - int pos, i; - __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; - if (unlikely(!code_line)) { - return; - } - if (unlikely(!entries)) { - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); - if (likely(entries)) { - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = 64; - __pyx_code_cache.count = 1; - entries[0].code_line = code_line; - entries[0].code_object = code_object; - Py_INCREF(code_object); - } - return; - } - pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); - if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { - PyCodeObject* tmp = entries[pos].code_object; - entries[pos].code_object = code_object; - Py_DECREF(tmp); - return; - } - if (__pyx_code_cache.count == __pyx_code_cache.max_count) { - int new_max = __pyx_code_cache.max_count + 64; - entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( - __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); - if (unlikely(!entries)) { - return; - } - __pyx_code_cache.entries = entries; - __pyx_code_cache.max_count = new_max; - } - for (i=__pyx_code_cache.count; i>pos; i--) { - entries[i] = entries[i-1]; - } - entries[pos].code_line = code_line; - entries[pos].code_object = code_object; - __pyx_code_cache.count++; - Py_INCREF(code_object); -} -#endif - -/* AddTraceback */ -#include "compile.h" -#include "frameobject.h" -#include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API - #ifndef Py_BUILD_CORE - #define Py_BUILD_CORE 1 - #endif - #include "internal/pycore_frame.h" -#endif -#if CYTHON_COMPILING_IN_LIMITED_API -static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, - PyObject *firstlineno, PyObject *name) { - PyObject *replace = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; - replace = PyObject_GetAttrString(code, "replace"); - if (likely(replace)) { - PyObject *result; - result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); - Py_DECREF(replace); - return result; - } - PyErr_Clear(); - #if __PYX_LIMITED_VERSION_HEX < 0x030780000 - { - PyObject *compiled = NULL, *result = NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; - if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; - compiled = Py_CompileString( - "out = type(code)(\n" - " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" - " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" - " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" - " code.co_lnotab)\n", "", Py_file_input); - if (!compiled) return NULL; - result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); - Py_DECREF(compiled); - if (!result) PyErr_Print(); - Py_DECREF(result); - result = PyDict_GetItemString(scratch_dict, "out"); - if (result) Py_INCREF(result); - return result; - } - #else - return NULL; - #endif -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; - PyObject *replace = NULL, *getframe = NULL, *frame = NULL; - PyObject *exc_type, *exc_value, *exc_traceback; - int success = 0; - if (c_line) { - (void) __pyx_cfilenm; - (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); - } - PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); - code_object = Py_CompileString("_getframe()", filename, Py_eval_input); - if (unlikely(!code_object)) goto bad; - py_py_line = PyLong_FromLong(py_line); - if (unlikely(!py_py_line)) goto bad; - py_funcname = PyUnicode_FromString(funcname); - if (unlikely(!py_funcname)) goto bad; - dict = PyDict_New(); - if (unlikely(!dict)) goto bad; - { - PyObject *old_code_object = code_object; - code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); - Py_DECREF(old_code_object); - } - if (unlikely(!code_object)) goto bad; - getframe = PySys_GetObject("_getframe"); - if (unlikely(!getframe)) goto bad; - if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; - frame = PyEval_EvalCode(code_object, dict, dict); - if (unlikely(!frame) || frame == Py_None) goto bad; - success = 1; - bad: - PyErr_Restore(exc_type, exc_value, exc_traceback); - Py_XDECREF(code_object); - Py_XDECREF(py_py_line); - Py_XDECREF(py_funcname); - Py_XDECREF(dict); - Py_XDECREF(replace); - if (success) { - PyTraceBack_Here( - (struct _frame*)frame); - } - Py_XDECREF(frame); -} -#else -static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( - const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = NULL; - PyObject *py_funcname = NULL; - #if PY_MAJOR_VERSION < 3 - PyObject *py_srcfile = NULL; - py_srcfile = PyString_FromString(filename); - if (!py_srcfile) goto bad; - #endif - if (c_line) { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - #else - py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); - if (!py_funcname) goto bad; - funcname = PyUnicode_AsUTF8(py_funcname); - if (!funcname) goto bad; - #endif - } - else { - #if PY_MAJOR_VERSION < 3 - py_funcname = PyString_FromString(funcname); - if (!py_funcname) goto bad; - #endif - } - #if PY_MAJOR_VERSION < 3 - py_code = __Pyx_PyCode_New( - 0, - 0, - 0, - 0, - 0, - 0, - __pyx_empty_bytes, /*PyObject *code,*/ - __pyx_empty_tuple, /*PyObject *consts,*/ - __pyx_empty_tuple, /*PyObject *names,*/ - __pyx_empty_tuple, /*PyObject *varnames,*/ - __pyx_empty_tuple, /*PyObject *freevars,*/ - __pyx_empty_tuple, /*PyObject *cellvars,*/ - py_srcfile, /*PyObject *filename,*/ - py_funcname, /*PyObject *name,*/ - py_line, - __pyx_empty_bytes /*PyObject *lnotab*/ - ); - Py_DECREF(py_srcfile); - #else - py_code = PyCode_NewEmpty(filename, funcname, py_line); - #endif - Py_XDECREF(py_funcname); - return py_code; -bad: - Py_XDECREF(py_funcname); - #if PY_MAJOR_VERSION < 3 - Py_XDECREF(py_srcfile); - #endif - return NULL; -} -static void __Pyx_AddTraceback(const char *funcname, int c_line, - int py_line, const char *filename) { - PyCodeObject *py_code = 0; - PyFrameObject *py_frame = 0; - PyThreadState *tstate = __Pyx_PyThreadState_Current; - PyObject *ptype, *pvalue, *ptraceback; - if (c_line) { - c_line = __Pyx_CLineForTraceback(tstate, c_line); - } - py_code = __pyx_find_code_object(c_line ? -c_line : py_line); - if (!py_code) { - __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); - py_code = __Pyx_CreateCodeObjectForTraceback( - funcname, c_line, py_line, filename); - if (!py_code) { - /* If the code object creation fails, then we should clear the - fetched exception references and propagate the new exception */ - Py_XDECREF(ptype); - Py_XDECREF(pvalue); - Py_XDECREF(ptraceback); - goto bad; - } - __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); - __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); - } - py_frame = PyFrame_New( - tstate, /*PyThreadState *tstate,*/ - py_code, /*PyCodeObject *code,*/ - __pyx_d, /*PyObject *globals,*/ - 0 /*PyObject *locals*/ - ); - if (!py_frame) goto bad; - __Pyx_PyFrame_SetLineNumber(py_frame, py_line); - PyTraceBack_Here(py_frame); -bad: - Py_XDECREF(py_code); - Py_XDECREF(py_frame); -} -#endif - -/* CIntFromPyVerify */ -#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) -#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ - __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) -#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ - {\ - func_type value = func_value;\ - if (sizeof(target_type) < sizeof(func_type)) {\ - if (unlikely(value != (func_type) (target_type) value)) {\ - func_type zero = 0;\ - if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ - return (target_type) -1;\ - if (is_unsigned && unlikely(value < zero))\ - goto raise_neg_overflow;\ - else\ - goto raise_overflow;\ - }\ - }\ - return (target_type) value;\ - } - -/* CIntFromPy */ -static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const size_t neg_one = (size_t) -1, const_zero = (size_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(size_t) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (size_t) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 2 * PyLong_SHIFT)) { - return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 3 * PyLong_SHIFT)) { - return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) >= 4 * PyLong_SHIFT)) { - return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (size_t) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(size_t) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(size_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(size_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(size_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { - return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(size_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT)) { - return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(size_t) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(size_t) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - size_t val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (size_t) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (size_t) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (size_t) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (size_t) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (size_t) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(size_t) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((size_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(size_t) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((size_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((size_t) 1) << (sizeof(size_t) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (size_t) -1; - } - } else { - size_t val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (size_t) -1; - val = __Pyx_PyInt_As_size_t(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to size_t"); - return (size_t) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to size_t"); - return (size_t) -1; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(uint32_t) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(uint32_t) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(uint32_t) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(uint32_t), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(uint32_t)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(long) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(long) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(long) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(long), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* CIntFromPy */ -static CYTHON_INLINE uint32_t __Pyx_PyInt_As_uint32_t(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const uint32_t neg_one = (uint32_t) -1, const_zero = (uint32_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(uint32_t) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (uint32_t) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 2 * PyLong_SHIFT)) { - return (uint32_t) (((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 3 * PyLong_SHIFT)) { - return (uint32_t) (((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) >= 4 * PyLong_SHIFT)) { - return (uint32_t) (((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (uint32_t) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(uint32_t) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(uint32_t) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(uint32_t, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(uint32_t) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(uint32_t) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - return (uint32_t) ((((((uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(uint32_t) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(uint32_t) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - return (uint32_t) ((((((((uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(uint32_t) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { - return (uint32_t) (((uint32_t)-1)*(((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(uint32_t) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(uint32_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(uint32_t) - 1 > 4 * PyLong_SHIFT)) { - return (uint32_t) ((((((((((uint32_t)digits[3]) << PyLong_SHIFT) | (uint32_t)digits[2]) << PyLong_SHIFT) | (uint32_t)digits[1]) << PyLong_SHIFT) | (uint32_t)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(uint32_t) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(uint32_t) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(uint32_t, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - uint32_t val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (uint32_t) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (uint32_t) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (uint32_t) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (uint32_t) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (uint32_t) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(uint32_t) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((uint32_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(uint32_t) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((uint32_t) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((uint32_t) 1) << (sizeof(uint32_t) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (uint32_t) -1; - } - } else { - uint32_t val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (uint32_t) -1; - val = __Pyx_PyInt_As_uint32_t(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to uint32_t"); - return (uint32_t) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to uint32_t"); - return (uint32_t) -1; -} - -/* CIntFromPy */ -static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(int) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (int) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { - return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { - return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { - return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(int) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { - return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(int) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - int val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (int) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (int) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (int) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (int) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (int) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((int) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (int) -1; - } - } else { - int val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (int) -1; - val = __Pyx_PyInt_As_int(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to int"); - return (int) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to int"); - return (int) -1; -} - -/* CIntToPy */ -static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const uint64_t neg_one = (uint64_t) -1, const_zero = (uint64_t) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; - if (is_unsigned) { - if (sizeof(uint64_t) < sizeof(long)) { - return PyInt_FromLong((long) value); - } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { - return PyLong_FromUnsignedLong((unsigned long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { - return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); -#endif - } - } else { - if (sizeof(uint64_t) <= sizeof(long)) { - return PyInt_FromLong((long) value); -#ifdef HAVE_LONG_LONG - } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { - return PyLong_FromLongLong((PY_LONG_LONG) value); -#endif - } - } - { - int one = 1; int little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&value; -#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 - return _PyLong_FromByteArray(bytes, sizeof(uint64_t), - little, !is_unsigned); -#else - PyObject *from_bytes, *result = NULL; - PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; - from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); - if (!from_bytes) return NULL; - py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(uint64_t)); - if (!py_bytes) goto limited_bad; - order_str = PyUnicode_FromString(little ? "little" : "big"); - if (!order_str) goto limited_bad; - arg_tuple = PyTuple_Pack(2, py_bytes, order_str); - if (!arg_tuple) goto limited_bad; - if (!is_unsigned) { - kwds = PyDict_New(); - if (!kwds) goto limited_bad; - if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; - } - result = PyObject_Call(from_bytes, arg_tuple, kwds); - limited_bad: - Py_XDECREF(kwds); - Py_XDECREF(arg_tuple); - Py_XDECREF(order_str); - Py_XDECREF(py_bytes); - Py_XDECREF(from_bytes); - return result; -#endif - } -} - -/* FormatTypeName */ -#if CYTHON_COMPILING_IN_LIMITED_API -static __Pyx_TypeName -__Pyx_PyType_GetName(PyTypeObject* tp) -{ - PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, - __pyx_n_s_name); - if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { - PyErr_Clear(); - Py_XDECREF(name); - name = __Pyx_NewRef(__pyx_n_s__15); - } - return name; -} -#endif - -/* CIntFromPy */ -static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" -#endif - const long neg_one = (long) -1, const_zero = (long) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop -#endif - const int is_unsigned = neg_one > const_zero; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x))) { - if ((sizeof(long) < sizeof(long))) { - __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) - } else { - long val = PyInt_AS_LONG(x); - if (is_unsigned && unlikely(val < 0)) { - goto raise_neg_overflow; - } - return (long) val; - } - } else -#endif - if (likely(PyLong_Check(x))) { - if (is_unsigned) { -#if CYTHON_USE_PYLONG_INTERNALS - if (unlikely(__Pyx_PyLong_IsNeg(x))) { - goto raise_neg_overflow; - } else if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_DigitCount(x)) { - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { - return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { - return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { - return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); - } - } - break; - } - } -#endif -#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 - if (unlikely(Py_SIZE(x) < 0)) { - goto raise_neg_overflow; - } -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - if (unlikely(result == 1)) - goto raise_neg_overflow; - } -#endif - if ((sizeof(long) <= sizeof(unsigned long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) -#endif - } - } else { -#if CYTHON_USE_PYLONG_INTERNALS - if (__Pyx_PyLong_IsCompact(x)) { - __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) - } else { - const digit* digits = __Pyx_PyLong_Digits(x); - assert(__Pyx_PyLong_DigitCount(x) > 1); - switch (__Pyx_PyLong_SignedDigitCount(x)) { - case -2: - if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 2: - if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -3: - if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 3: - if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case -4: - if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - case 4: - if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { - if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { - __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { - return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); - } - } - break; - } - } -#endif - if ((sizeof(long) <= sizeof(long))) { - __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) -#ifdef HAVE_LONG_LONG - } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { - __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) -#endif - } - } - { - long val; - PyObject *v = __Pyx_PyNumber_IntOrLong(x); -#if PY_MAJOR_VERSION < 3 - if (likely(v) && !PyLong_Check(v)) { - PyObject *tmp = v; - v = PyNumber_Long(tmp); - Py_DECREF(tmp); - } -#endif - if (likely(v)) { - int ret = -1; -#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) - int one = 1; int is_little = (int)*(unsigned char *)&one; - unsigned char *bytes = (unsigned char *)&val; - ret = _PyLong_AsByteArray((PyLongObject *)v, - bytes, sizeof(val), - is_little, !is_unsigned); -#else - PyObject *stepval = NULL, *mask = NULL, *shift = NULL; - int bits, remaining_bits, is_negative = 0; - long idigit; - int chunk_size = (sizeof(long) < 8) ? 30 : 62; - if (unlikely(!PyLong_CheckExact(v))) { - PyObject *tmp = v; - v = PyNumber_Long(v); - assert(PyLong_CheckExact(v)); - Py_DECREF(tmp); - if (unlikely(!v)) return (long) -1; - } -#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(x) == 0) - return (long) 0; - is_negative = Py_SIZE(x) < 0; -#else - { - int result = PyObject_RichCompareBool(x, Py_False, Py_LT); - if (unlikely(result < 0)) - return (long) -1; - is_negative = result == 1; - } -#endif - if (is_unsigned && unlikely(is_negative)) { - goto raise_neg_overflow; - } else if (is_negative) { - stepval = PyNumber_Invert(v); - if (unlikely(!stepval)) - return (long) -1; - } else { - stepval = __Pyx_NewRef(v); - } - val = (long) 0; - mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; - shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; - for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { - PyObject *tmp, *digit; - digit = PyNumber_And(stepval, mask); - if (unlikely(!digit)) goto done; - idigit = PyLong_AsLong(digit); - Py_DECREF(digit); - if (unlikely(idigit < 0)) goto done; - tmp = PyNumber_Rshift(stepval, shift); - if (unlikely(!tmp)) goto done; - Py_DECREF(stepval); stepval = tmp; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - if (Py_SIZE(stepval) == 0) - goto unpacking_done; - #endif - } - idigit = PyLong_AsLong(stepval); - if (unlikely(idigit < 0)) goto done; - remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); - if (unlikely(idigit >= (1L << remaining_bits))) - goto raise_overflow; - val |= ((long) idigit) << bits; - #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 - unpacking_done: - #endif - if (!is_unsigned) { - if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) - goto raise_overflow; - if (is_negative) - val = ~val; - } - ret = 0; - done: - Py_XDECREF(shift); - Py_XDECREF(mask); - Py_XDECREF(stepval); -#endif - Py_DECREF(v); - if (likely(!ret)) - return val; - } - return (long) -1; - } - } else { - long val; - PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); - if (!tmp) return (long) -1; - val = __Pyx_PyInt_As_long(tmp); - Py_DECREF(tmp); - return val; - } -raise_overflow: - PyErr_SetString(PyExc_OverflowError, - "value too large to convert to long"); - return (long) -1; -raise_neg_overflow: - PyErr_SetString(PyExc_OverflowError, - "can't convert negative value to long"); - return (long) -1; -} - -/* FastTypeChecks */ -#if CYTHON_COMPILING_IN_CPYTHON -static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { - while (a) { - a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); - if (a == b) - return 1; - } - return b == &PyBaseObject_Type; -} -static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (a == b) return 1; - mro = a->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(a, b); -} -static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { - PyObject *mro; - if (cls == a || cls == b) return 1; - mro = cls->tp_mro; - if (likely(mro)) { - Py_ssize_t i, n; - n = PyTuple_GET_SIZE(mro); - for (i = 0; i < n; i++) { - PyObject *base = PyTuple_GET_ITEM(mro, i); - if (base == (PyObject *)a || base == (PyObject *)b) - return 1; - } - return 0; - } - return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); -} -#if PY_MAJOR_VERSION == 2 -static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { - PyObject *exception, *value, *tb; - int res; - __Pyx_PyThreadState_declare - __Pyx_PyThreadState_assign - __Pyx_ErrFetch(&exception, &value, &tb); - res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - if (!res) { - res = PyObject_IsSubclass(err, exc_type2); - if (unlikely(res == -1)) { - PyErr_WriteUnraisable(err); - res = 0; - } - } - __Pyx_ErrRestore(exception, value, tb); - return res; -} -#else -static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { - if (exc_type1) { - return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); - } else { - return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); - } -} -#endif -static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { - Py_ssize_t i, n; - assert(PyExceptionClass_Check(exc_type)); - n = PyTuple_GET_SIZE(tuple); -#if PY_MAJOR_VERSION >= 3 - for (i=0; i= 0x030B00A4 - return Py_Version & ~0xFFUL; -#else - const char* rt_version = Py_GetVersion(); - unsigned long version = 0; - unsigned long factor = 0x01000000UL; - unsigned int digit = 0; - int i = 0; - while (factor) { - while ('0' <= rt_version[i] && rt_version[i] <= '9') { - digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); - ++i; - } - version += factor * digit; - if (rt_version[i] != '.') - break; - digit = 0; - factor >>= 8; - ++i; - } - return version; -#endif -} -static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { - const unsigned long MAJOR_MINOR = 0xFFFF0000UL; - if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) - return 0; - if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) - return 1; - { - char message[200]; - PyOS_snprintf(message, sizeof(message), - "compile time Python version %d.%d " - "of module '%.100s' " - "%s " - "runtime version %d.%d", - (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), - __Pyx_MODULE_NAME, - (allow_newer) ? "was newer than" : "does not match", - (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) - ); - return PyErr_WarnEx(NULL, message, 1); - } -} - -/* InitStrings */ -#if PY_MAJOR_VERSION >= 3 -static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { - if (t.is_unicode | t.is_str) { - if (t.intern) { - *str = PyUnicode_InternFromString(t.s); - } else if (t.encoding) { - *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); - } else { - *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); - } - } else { - *str = PyBytes_FromStringAndSize(t.s, t.n - 1); - } - if (!*str) - return -1; - if (PyObject_Hash(*str) == -1) - return -1; - return 0; -} -#endif -static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { - while (t->p) { - #if PY_MAJOR_VERSION >= 3 - __Pyx_InitString(*t, t->p); - #else - if (t->is_unicode) { - *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); - } else if (t->intern) { - *t->p = PyString_InternFromString(t->s); - } else { - *t->p = PyString_FromStringAndSize(t->s, t->n - 1); - } - if (!*t->p) - return -1; - if (PyObject_Hash(*t->p) == -1) - return -1; - #endif - ++t; - } - return 0; -} - -#include -static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { - size_t len = strlen(s); - if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { - PyErr_SetString(PyExc_OverflowError, "byte string is too long"); - return -1; - } - return (Py_ssize_t) len; -} -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return __Pyx_PyUnicode_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { - Py_ssize_t len = __Pyx_ssize_strlen(c_str); - if (unlikely(len < 0)) return NULL; - return PyByteArray_FromStringAndSize(c_str, len); -} -static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { - Py_ssize_t ignore; - return __Pyx_PyObject_AsStringAndSize(o, &ignore); -} -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT -#if !CYTHON_PEP393_ENABLED -static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - char* defenc_c; - PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); - if (!defenc) return NULL; - defenc_c = PyBytes_AS_STRING(defenc); -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - { - char* end = defenc_c + PyBytes_GET_SIZE(defenc); - char* c; - for (c = defenc_c; c < end; c++) { - if ((unsigned char) (*c) >= 128) { - PyUnicode_AsASCIIString(o); - return NULL; - } - } - } -#endif - *length = PyBytes_GET_SIZE(defenc); - return defenc_c; -} -#else -static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { - if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - if (likely(PyUnicode_IS_ASCII(o))) { - *length = PyUnicode_GET_LENGTH(o); - return PyUnicode_AsUTF8(o); - } else { - PyUnicode_AsASCIIString(o); - return NULL; - } -#else - return PyUnicode_AsUTF8AndSize(o, length); -#endif -} -#endif -#endif -static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { -#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT - if ( -#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII - __Pyx_sys_getdefaultencoding_not_ascii && -#endif - PyUnicode_Check(o)) { - return __Pyx_PyUnicode_AsStringAndSize(o, length); - } else -#endif -#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) - if (PyByteArray_Check(o)) { - *length = PyByteArray_GET_SIZE(o); - return PyByteArray_AS_STRING(o); - } else -#endif - { - char* result; - int r = PyBytes_AsStringAndSize(o, &result, length); - if (unlikely(r < 0)) { - return NULL; - } else { - return result; - } - } -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { - int is_true = x == Py_True; - if (is_true | (x == Py_False) | (x == Py_None)) return is_true; - else return PyObject_IsTrue(x); -} -static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { - int retval; - if (unlikely(!x)) return -1; - retval = __Pyx_PyObject_IsTrue(x); - Py_DECREF(x); - return retval; -} -static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { - __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); -#if PY_MAJOR_VERSION >= 3 - if (PyLong_Check(result)) { - if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, - "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " - "The ability to return an instance of a strict subclass of int is deprecated, " - "and may be removed in a future version of Python.", - result_type_name)) { - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; - } - __Pyx_DECREF_TypeName(result_type_name); - return result; - } -#endif - PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", - type_name, type_name, result_type_name); - __Pyx_DECREF_TypeName(result_type_name); - Py_DECREF(result); - return NULL; -} -static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { -#if CYTHON_USE_TYPE_SLOTS - PyNumberMethods *m; -#endif - const char *name = NULL; - PyObject *res = NULL; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_Check(x) || PyLong_Check(x))) -#else - if (likely(PyLong_Check(x))) -#endif - return __Pyx_NewRef(x); -#if CYTHON_USE_TYPE_SLOTS - m = Py_TYPE(x)->tp_as_number; - #if PY_MAJOR_VERSION < 3 - if (m && m->nb_int) { - name = "int"; - res = m->nb_int(x); - } - else if (m && m->nb_long) { - name = "long"; - res = m->nb_long(x); - } - #else - if (likely(m && m->nb_int)) { - name = "int"; - res = m->nb_int(x); - } - #endif -#else - if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { - res = PyNumber_Int(x); - } -#endif - if (likely(res)) { -#if PY_MAJOR_VERSION < 3 - if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { -#else - if (unlikely(!PyLong_CheckExact(res))) { -#endif - return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); - } - } - else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_TypeError, - "an integer is required"); - } - return res; -} -static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { - Py_ssize_t ival; - PyObject *x; -#if PY_MAJOR_VERSION < 3 - if (likely(PyInt_CheckExact(b))) { - if (sizeof(Py_ssize_t) >= sizeof(long)) - return PyInt_AS_LONG(b); - else - return PyInt_AsSsize_t(b); - } -#endif - if (likely(PyLong_CheckExact(b))) { - #if CYTHON_USE_PYLONG_INTERNALS - if (likely(__Pyx_PyLong_IsCompact(b))) { - return __Pyx_PyLong_CompactValue(b); - } else { - const digit* digits = __Pyx_PyLong_Digits(b); - const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); - switch (size) { - case 2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -2: - if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -3: - if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case 4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - case -4: - if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { - return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); - } - break; - } - } - #endif - return PyLong_AsSsize_t(b); - } - x = PyNumber_Index(b); - if (!x) return -1; - ival = PyInt_AsSsize_t(x); - Py_DECREF(x); - return ival; -} -static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { - if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { - return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); -#if PY_MAJOR_VERSION < 3 - } else if (likely(PyInt_CheckExact(o))) { - return PyInt_AS_LONG(o); -#endif - } else { - Py_ssize_t ival; - PyObject *x; - x = PyNumber_Index(o); - if (!x) return -1; - ival = PyInt_AsLong(x); - Py_DECREF(x); - return ival; - } -} -static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { - return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); -} -static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { - return PyInt_FromSize_t(ival); -} - - -/* #### Code section: utility_code_pragmas_end ### */ -#ifdef _MSC_VER -#pragma warning( pop ) -#endif - - - -/* #### Code section: end ### */ -#endif /* Py_PYTHON_H */ diff --git a/opendbc/can/parser_pyx.so b/opendbc/can/parser_pyx.so deleted file mode 100755 index c949622b803cd6b90cea3827b42714af86b83cb7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1151272 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

    Ue~InZ$6#XQfa6O?W>J{`{2)}7S0s-D6-G2vw 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%0Dq)|bmBgN1CwFSDstP6&znE=|P&+3QR}W>IW? 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

    >Y-_?!O)n zQ~kLfy8cPn9RzMhJ==i;z~%H$8T9q?W+68RoCh}lM3+?8H(LG>$~^@f1&$f~83KP+ zle=J$XF0Yz1-Y3UEPv5pzwBK%$-r&~27tSPdMg|T9{~;kM_wa&_9Kb%x4c``Cjiv_ zuh;zDyo~%+$j<@if!Bb#eU4`_?6UpS27gAu&jF9TNBJKE>h?=FtNZQ1!@vmeS1oVy zW5VFi>rLK;pM${Dz+vE7ps7B;?)o#R-z;zrcn!D++-%6lUw8ci)T&AZmvmsE`_fC1n> zpdOD?;D>={ffufm{3Ps5180D92K(2TzotAb0G0xE|4)M-0geIZZm|4CgZ<4vRURG! zjss_bT`#NqXMuWsSZ*`!&j7C(@e?|5$(Cps&~e0^}xulfW*N z*9RN}7A{l%0^k3+D(O6M2B??6h;gD|s~Q(K0qcRkYI*jfn9HwFeiZ_Bf3EU)2l+*y zNj{1D1HeJxFz{*M2v9F?6#N+QJaF6~Ukbms00Y1pU_G!IsF!yZ^}7Q5T)&eB`KQ5O z1kMAm8RXA_pSnTvhbmS34FFFAhk;K67lCC}N`4DakH?L&mwc7}u>QF<*5|d>KLWq6 zX#Shxzf$>8wBt1JGVm&J7TCN^wR;kH5~!DdqwGz*N`F{?agFtPt@X#?cLn0k?O}@l zO6A-CpR#ZScma43sN3JNsF(XXF0Z80=Z2$SiaO?{}lMAffK-rn^k>zdT~#YCeQV#Mtv4;RrT5T28DWia=VqF9@ZO`Tq#hOw;)#tECQ}npW}K3 zdR$Jmp}Z-`O#^3uE7c!B{fB{EPQ9VL3y_-tP6DTZdOXe|uIGRkfa8XEGe3>{G5C=* z_%jE&MYemNYM;wM-JjLUM+%j_Gr(EkH6WL>Xee(0a>FZ>=W<3Me-?NicmX<mW)j z>h&EhQvOc@E%Z}f&+77#+m!s%zzxvb1a$9E_fG=P-K(yrfV#ai&^rqpyi>`K0(JQr z$jt%g*DLu2pe}z6a*M!Cu)Et}f23I1y8xutxo}&^u?)*UP)n z^6UrKXSw?8^6ksSYo&4SGQ^wp7Z5K~JDK#aLT}EXugCjF%d;O`AI>wA|GNAU#K|OI zdbi5wW?%s0(h=ZA^#7s~C8yV)^*0;zb$Q+&Ph+1v1H5F|kI!S@d=0n&T;%=qo0VS$ zK)t*huCEn%5q?|-&I60z;vc_u@Dbq2QYCi=sF}BFH2E%EUjSOrD+DfQZ!`2NfB_); z!}h1wX#ezEReeT)W579}Ucc)lf6-vS_&1b4UBE%$@Y@uB4mb2f1Qk1uzI~ z2Ob9M@h%0=dMp<)$m@1p$gR}>8?CR`uewa-`6#g9es#SYH~=hoyW&my?lSr#uyc7C zdt9C_KLRl*;n!1_4XMBe;zmvoC3}Ri{5GQ|50VJ@V_Z61_oYK*EK+XzJ3MI*-K!rg6+Nw z_JRC9^U%8$&+jWI-=nS~YQ`SFET-+TS|H(JyC{rKCgd0+l^Yvd6>`6A0Ne(S9D)ZL~kKbrj zeAJIG$qyPa>#R2!_%|E)w;1?R1OHY7{~LL{h;D)PqW5%y1yma3w|ff-+-zm|4Ny?> z`FW-I{5<)WfR-x!t;;HnLoOg?b-Dm(f4DL%e-lTY4?ZK8;CQnRn@6zdmi&6_Ott(67i&54GC!Y>OFn-bNJ>6G z&wC}G-;Yj8KEL1nmgMvM#h~Qxvo>q>`h?_5tR~NM^^al6-)S9bmH+VWepX)Q_umo8 z-);?P?fXUMG2gMF{|KJvJ?8&}p4S0v|5@<79$@}Cwu5y6^FIX7>jUQJB%hxruYm8<=8?PQa9wO& zRSC&vtapNsgruU!SA%yua{2w>FKGOe;IC->2f>$wbM2f0AJq8IfFIKMFM%J|_^*J! zrt#C@w?uNw{Q>wc)d9WwzD)d0G><>DUCB!^x_j$7#c$R4`@nw&JYCA4cY*(k#_s_C z3yp6iUW|Li|5xdc!rdt3AJocy3Vc2I0+jo4@Dmz;2K?PSm0_0uWAHccQ2ZNV=f8q) z0DlYkZ-ReLlm7wupK1J0!9M|iZiSsfazMnn67tNy1^hp1e7WQ|S~VD#%3!A!^6O#$ z4d5RE|K}PX1^-R(w?qCz;4g#cID88HXTcXj{@;WDvc~@<__xA;mY)Xyb&Y=>{EHg@ zbIEVCCR7KZxk>%pO${OD*(r^G0Q@v~E_aXQ*ISeDb3N=F0)IQo<@(0KZ_xNt;J*!? z?R-}98?6DY+&_W*djl%3ZbP|K;6JMI-vfU?{ABr;!M~*O>nUMG{=5_Z6v6%`@H@fZ z0sdj)W&i3^L_HGj1K_XxNbx0apr#?Jo@i*;LH9% z@iVZ$juKV)GlY3?5(7;Y@uGc`T0Hkle!X=Q;=uKdfKO}uhroY9!p|~FFcJR^u+RDMo8X@Z&+%_3UX(lXVP%-t&x7FS@p*~@ z*dK$PeXw&k{P|n(H)9-Q`~M*M`>g67WuOA`H&J5C`kqomAMEb{KmRrrfDPcEBwp0( zyU5SGVCN~8A5;YU{}uCBM-c)Y{7d-=*>YTJki1AwTbdpI-!j zMB~54b})ZkLc2Uqyr^&4$CLp+Un!x)mi!MCKLP(A1<&6P#O*r>{>bA>z6@K0KLuZL zTJbzy{RDh5c+Tf7cdBwHke@+JJWqn>b4kv(-vd7YJ5#C{>zm+5&|Yl+&SGUh_`6E* z9ONGbKcThn=ZP2NVGZKH8S)d7UvGT`aprnmg&pe?N|628L>*bga~eFC+YNr;lS;k@ z_P-2%0{js81@I%EQUvGE1JpspxbZdg7v6CNi5KMtVW1iL_G$1nzo+bsgZ~=r?1dfP z8P0+KxW?Z@i6`tAza0hu2Z$H`gdxv6y(+ z!IvQp1CZanQQ5h&m@7X3-ukTKOO;#JB=`|L@1?NFpW7+ng+FE2)HU<1;3ptIp>A7e zzz@Oy0QeW!4*ZXS|7VoI(*7?MaTZ(okAtuIyyELI&|hL+^XDCOBq8h!;CU_EPcjdA z=Dz~|h-T+DDqq-{=jXnN&lBJ$UQ+&4!2eP3e4c-i?24aXvK>vng*uwZpCr}~Wm4L* zhKU#D*5En+H24?5U%9LZ<{RIt>`ZHRJ_&wE<1Y~}?DP8rr;(rAsKW}LzlW0fPY^Hs zoY(Ap2mF}EZ+e@M-)J4dyi*AOD z75)7GJFu^x+dnVu(0GFLt|H+!{Vc+c{=8tnyqo{rO%z<=Gq|Co5c z_APnPKW+~i_*w)1DDiR}z&+o!e)}PRJHrP4j|}`@82E1(_-Bb1e)97*EQ_u7a({o05%1UTA12SE#0x+9y`M#_H*VePFMlubetvEyUfRKP(lhYqQwBR{A9LH_0nWuKpuPQ!i)@qYDshk*|m_$CAYn1Syw@G%2_(!dWI_%9gv|6<@T8u(`o z{L2RZ4VC`!yq|c#JbWMVe)-U5uyf47f5>3xzZ>Ld4E$9C|5F3MzRJJ8Z!z!>8TeWQ z-)i7H419|CyO7)2@JZtD&L;5h8H1hg8~C3X_+J?K+qU_ayNUQ>AAcS;@XZGPUl{lg z8u*VI_)i)5FB$m1H1K~*{9Sau!SCS|ppHK?$lpc>Uw&~YBVLS${GP^TjH}NW$CrrFw-kvhp88PsGW#Fd`{AB|_OT37`_dYD* z|Ct^B^*u|xpZ|YNe3?(4KWDJ>W8&}jk-v4Pf4TP=_%h=C?0n3?|GmM^OT_!t>rK`E z{yb>l-)rDo4Sa-nzjA-eAU{mJU!4D)LH-#7KWVV@U4#5j4E*i8{NrCrykCE*Ht?+m z-rCxePHpXo#0qNqvZ)} zQ=b(M#bWjeCv@CC8oy4K<7Al%NV`2pkCun6h?81NTjwRww+S(McY&(*$ zJ7bBCP|S|FiB#GS^^iY_?qtkyok;nvN{WoHkbN{7kJ_PBD%5W~aW~a(9ZiM09Xry~ z-Q7Vfy!^tE$QeG*4?U28B%HP%U_b&0fO8%;lzolT6Vzx;p zAb)R{zomgHGSF8};(g_n>NhFTze$OHlM?+VCHhTDedUsn*Yc7~^p#5snO4|;Sz1C1P?F4t)iH>7V*lnw@ z)qgC4BB{ZI52T}rj-GTb(dl?rmBdrgq?D*)mF`e9p39`2*ins1I?7p3%XQMq@HVy+ zjya)}RP(4*DBkJhQt4z2^@LQn<8~z?%Ig5zYU%0jaFj8RbK)Y`q&1I=b|(`l2#=*2C6LE$L+Xt!tM>lG&Y@WVW;x1 zqbC}3qj8&a0Q7OYuC}G#q47(VmrV!dz$6Rw==T1k(~wFfR0DZ5<*RHW8bqn;9xc)? zQx}g;Igy^QL*s~)u2xB38;P{1LSd&P6h0o@AC5*T>9gDb~xow6M6zZI?`c!Hwhg0jE2W64gbty&K^~EJg!E zG!a(~@7;(vM?*a^HxdoYj!{M9Q;=M$>u>CdOL-Xr>5GhrXn4=Zwkq5EPk6}M!Tx%( zXYX~~CfDiCh^ywwNIepd%1-e9L^SS6#bU?UmKuXvd*W`iJCj2~U)>QCV>A?tK1E$i z>R>d?@;>DxQ^6_>L>c~|94E7N;H*fD#!xzw7O`kF%5tjIa4eKgi#`{n%H`hbNk*s* zBX%efNy$K0VXUPFriP?o+v!-sRkz3~E!1*QT-sYG1^ZPEj4}3x-nvlScExHV!UJ6u zjip+_NKR9nyta|Gg}T>?dZ-s|tFkj8V<{0X9z=3Rfhrn)H4h>VE#ea4r7NGWMy)_g zFtb`v_Isc5s8cSj$a86~gN4N; zW;;;@5l-OZeZI87PCj4Q<=x+{7(K!_EE^ zkA`ABj@?+>)?QcJ+?>@?nW;v|i+0asl$>(JOv8;SZgV%&CV(m|2KaW~Q0grfLh1f^ zIGUg|NF{n`)>q30);~^r9^z=ew5i@|#+AiGzgte(yb}@^QMm%Fq6u8)WhU3^sGqCJ z)vK?nEhcYPkxPk#Nik)GVo2$om=b%(>p0am|m_E&~)t+#@e)RAf>PQ z8jsTapGe8Q@ORk%zB`WO(NtjK`BD_#%X>$tV9o1*EeB_UU?UUH&`in2vx z$c=~EVc2S+MLPv=SG6sFRU@hxO=pI*Qp zSXR&}f8}EY+w+ke#4NUb#l{f&C5_QSS4l=Uu1Aor zw@XWe%5H3}Jn>#6Lwc99-+s_^^cXOoTKHo-PuPc zgwzehVPw?pw|nV{t$2gOlB+7qu7A9x_COOoN4DD!)Op6~Nm0C$_RaKq3MF@UG%laf zqIVu_Y;0?2x7%y?G&k6mcN`)PD;r6Yo@zO%M%okCt0yBFiG87T7xjqtrj|ChI+{q^ z9igG1W$(ei;!KMe;>IrW~Q8YhYiPoV*Z#>Bj_S@~L9*5L>=rOIj z+Z2yDed<29Ly(?>(_Pgl;;fP`_SV_;-kS?;?k+D6dvh|xqS=6-#>yk}M6$oGD@14g zq>v^%&Ghz@4V$@j^eR>Fq{At@DP13OL!=>6p)uu%fuGWVrZTrHl{i7kN{>fHerOJ4 z%BN@Uq%O|jTIscsL`qacp1d}t+j=_0c@1^5a9@Z{qB?1+2#ce+ni@*=+C5EnCB2Wt z&&@?*itr14@zi1u#mC-9uW}I~o25-Pi^|j;z4Cxu^eS>zo;p=lQP+xwaTL`Qrg~I{ zDJq;Y;Red*Ftt2E+jg6hrh<}2){c5QosQB|eF|h#3(e5Ei}K2C+G zeoeHu-)^_jelApNtu-EM0XLxPCGW1$osL(&B|Pi?xkt*)ub3p=+)9fh6;4l!f4 zWY)Tsf!sBDL+k!F_tn;S2l?Ad%lW3t%C=}H4OntC5s}zKcRI*p?@=jbYE}j4(W#S) z%YlUZgGyP|@Td>94SEoWrgT%Bjx*zOoDq>}NvNk?RM&P2M`cwcA=eI$c>N(SyGcBr z+k=GpXh)BWHw$ue0^zl7de$$705QDgjE*9!#hVB!t7A^Q)9tcl(ex-vD_snPtIerh zB9qc-imYg@fSqGf4d`N!XgWxtptn6}{HCRDj)$3)5wWI4UUx`z1=*8plj6XWu4H4V z#aEkng-E_oP)|36aTQ-xK(K#LKfT69U798U*>1J*NE=NA9R5Ip)`>@B)Wv-oz#HgY7n%K1>MUY&S>ijwBBsM{4xqz}ep{k182 z#|kak;`GVEl2V0|No5h;Lsnu^!$|D8MFL*F(P$&z^~i8)9GBB4Sw%=`=!D8%C+?)8 zVUiNLCESv=lmj3Q0Z5fZCk-k7nG)=8j3q+!28x*X6FuS$wqSquF(F>cA(n@OdPh9D zf26&!S`A|&CuzRoH)H6GUJgNWhN`5+xw@yw;11Pu>DhEcLwkiy;|>i(0WtK*0hd}T zdNk_LXhJhkW*t)Jy&ELkNae~wv_5Bx82%5ag@78!D52;b(9E+GD#UJf=plNm6Yil6 zMz161KDlaGO(m8cT)C3oh(|RP!&HDOEe2eHs`B-ATb~&@&e?hPq81VyV+WZ6JpOG4f`ov79!8a{VI4ffjmCgWHw!E;9~fC8O%I zB7UoBL0V9)dU$MTtM;0$)^6J+r%Q6RHbuRTo)1LB%3=G7NGzx=H85XPh^2^2%ZX?t zXKJE^lipj_Jj8A9p+(mcV;mJ}*WtxhsuRz!oPd;b736fNO^oRDCbiH7bkY6eDF$*=uScEQ(ZpcZx!2 zHQK;0=F&mM0riHeoOtT18hS~>eiVldo<}sAiu|K{A{Frli&zz@rS!ozI~`Bby4pQT zB62!W>j)b2#R6OCsTsgqG0Dw}s3~l=BwU&XVoo=0M4SjGI>z+O=!+Svy^CJdq_?Xu zS&|J%Qh~A^m812v&2ngMN&{ZTS?)ZwX*FQOVKuFE+xz2*6LGOILBj3w7R$M5k#6?bU*P`fAE_vGegd1ZB`>J-7u zh1ha9ViUu)RZ|oZvUN~dF*|CZmb(R70?>9Ab;+7v+T28v!b>Y=aTMhR9oC2t^%U}K zlvf80-AR`|Q6ble)gqu_dL<|~p7s-!72>2nmPj1$Nw)4^OSY2-qIC5#aK=BmLK2%H z@g^T{pl~HeUAdE?!!NNp(snTjf*esEqmQ?=I!EbE!AxA`d&g81w&|H|ITWcO9*K*c z&v7|{H_}_*nH8{95`#DvLeOcAhP&$M^D7}bN=PK=crg>{I&>LGHl@X$l(u5xxUXBj z-zwg=kV|lWoG#uOAc4$4syd_S5Z-!}Mg(eBpG5$VduwS8-jLD0Q_O~P9fI9_)BELC zt)X|hg#&NO>XQfC#o&c7KN1&dNCEPE)Pg38SR5%THnxVekLh$*NNE8 z(t6x?FDs35M-Zz{hxWUqlYb9b@rF!|3EMMtjV5`7sfSAZ0c67}|qSFFYaM zzoz31dZCPL)YZ|cTty}yyuKjjEIBG<@80Vw8=`9)ld`w@be@(BMN>`3qVlw&ma0yJ z;u`vv*qEx%Dm1j}bAmi)^m;)~PeC|$MC0-)BYmE&lY$Y~Mq)LLxAoIU?Yem&7X!P> zLuT^FDvBk~HW$jG4~{%U&spS^I4rfwBmHsGR7e{Ed50eaWnb8IFXhBS zLIM9u#$2mh>_Dw@SLA=WJSi_vCFsKuA*}x#aSN|R5sKHAC(RM zHx(7?rZj*gVm%U9yHX8t$D zh5sqeuc0dk(6rBon%6+l*CkqSp#N`%E`L8QBYkaI&JTb7o=N(;66@txUh)2_%sf8V z%@~2;I$$9y0_o$v;#1*X`G?>LW7$1QP?Rfduzrc6ts3y`KmXk!#y`6kf&jSZk^AUh zuVnepf1ikvzyFo}=W-YyA^l%w>GR()VjMzAy8rBeh>y6(_W17|F_z)O&0M}-|2Xvb zz##u!B*sH`s2f6GghJQvBTmHRR{CH3@ZV2j+@NUhx9~OlN2Fo4KL4F1#<4eMOJ_c- z&7ax+u%^#{kBPDLyZ-vjp3?OB?=~@VIV`XH|2xp<`19X)V!TgukgOj)e?Cq31jqXP zcc2&xxZz+!FMmYS=f4-lnB*@Kfv-8-}N`R`N>u26r5bVcrQ`TTvBL(nfnVA*djm)rGO(iNVvK7WtpSX}vE zt$-xd59>2NM|8G6|9!04gi^f11snALQPbzYqc!C!{jO!&??uuVzOeuNy`2>wRr;fR zLn|Mb*30w{Az8r$koDiM@ye>w5w~8U|C!4ceG28@|JB?8=(4vHp>x8{=kNy@K6zWV z)qGj;_0N9#4;)k@Qt=m-))!xAD)jaG|K^KI|IKIo{pT{p*JJU&vrB6KT`?;*OzAgi3fiUh{{fR5JnsMi

    • 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 !397uJa-C6i1w{ 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